Index: frontend/node_modules/webpack/lib/APIPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/APIPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/APIPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,394 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + getExternalModuleNodeCommonjsInitFragment +} = require("./ExternalModule"); +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const ConstDependency = require("./dependencies/ConstDependency"); +const ModuleInitFragmentDependency = require("./dependencies/ModuleInitFragmentDependency"); +const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirementsDependency"); +const WebpackError = require("./errors/WebpackError"); +const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression"); +const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin"); +const { + evaluateToString, + toConstantDependency +} = require("./javascript/JavascriptParserHelpers"); +const ChunkNameRuntimeModule = require("./runtime/ChunkNameRuntimeModule"); +const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ + +/** + * Returns the replacement definitions used for webpack API identifiers. + * @returns {Record} replacements + */ +function getReplacements() { + return { + __webpack_require__: { + expr: RuntimeGlobals.require, + req: [RuntimeGlobals.require], + type: "function", + assign: false + }, + __webpack_global__: { + expr: RuntimeGlobals.require, + req: [RuntimeGlobals.require], + type: "function", + assign: false + }, + __webpack_public_path__: { + expr: RuntimeGlobals.publicPath, + req: [RuntimeGlobals.publicPath], + type: "string", + assign: true + }, + __webpack_base_uri__: { + expr: RuntimeGlobals.baseURI, + req: [RuntimeGlobals.baseURI], + type: "string", + assign: true + }, + __webpack_modules__: { + expr: RuntimeGlobals.moduleFactories, + req: [RuntimeGlobals.moduleFactories], + type: "object", + assign: false + }, + __webpack_chunk_load__: { + expr: RuntimeGlobals.ensureChunk, + req: [RuntimeGlobals.ensureChunk], + type: "function", + assign: true + }, + __non_webpack_require__: { + expr: "require", + req: null, + type: undefined, // type is not known, depends on environment + assign: true + }, + __webpack_nonce__: { + expr: RuntimeGlobals.scriptNonce, + req: [RuntimeGlobals.scriptNonce], + type: "string", + assign: true + }, + __webpack_hash__: { + expr: `${RuntimeGlobals.getFullHash}()`, + req: [RuntimeGlobals.getFullHash], + type: "string", + assign: false + }, + __webpack_chunkname__: { + expr: RuntimeGlobals.chunkName, + req: [RuntimeGlobals.chunkName], + type: "string", + assign: false + }, + __webpack_get_script_filename__: { + expr: RuntimeGlobals.getChunkScriptFilename, + req: [RuntimeGlobals.getChunkScriptFilename], + type: "function", + assign: true + }, + __webpack_runtime_id__: { + expr: RuntimeGlobals.runtimeId, + req: [RuntimeGlobals.runtimeId], + assign: false + }, + "require.onError": { + expr: RuntimeGlobals.uncaughtErrorHandler, + req: [RuntimeGlobals.uncaughtErrorHandler], + type: undefined, // type is not known, could be function or undefined + assign: true // is never a pattern + }, + __system_context__: { + expr: RuntimeGlobals.systemContext, + req: [RuntimeGlobals.systemContext], + type: "object", + assign: false + }, + __webpack_share_scopes__: { + expr: RuntimeGlobals.shareScopeMap, + req: [RuntimeGlobals.shareScopeMap], + type: "object", + assign: false + }, + __webpack_init_sharing__: { + expr: RuntimeGlobals.initializeSharing, + req: [RuntimeGlobals.initializeSharing], + type: "function", + assign: true + } + }; +} + +const PLUGIN_NAME = "APIPlugin"; + +class APIPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + const moduleOutput = compilation.options.output.module; + const nodeTarget = compiler.platform.node; + const nodeEsm = moduleOutput && nodeTarget; + + const REPLACEMENTS = getReplacements(); + if (nodeEsm) { + REPLACEMENTS.__non_webpack_require__.expr = + "__WEBPACK_EXTERNAL_createRequire_require"; + } + + compilation.dependencyTemplates.set( + ConstDependency, + new ConstDependency.Template() + ); + compilation.dependencyTemplates.set( + ModuleInitFragmentDependency, + new ModuleInitFragmentDependency.Template() + ); + + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.chunkName) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule( + chunk, + new ChunkNameRuntimeModule(/** @type {string} */ (chunk.name)) + ); + return true; + }); + + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.getFullHash) + .tap(PLUGIN_NAME, (chunk, _set) => { + compilation.addRuntimeModule(chunk, new GetFullHashRuntimeModule()); + return true; + }); + + const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation); + + hooks.renderModuleContent.tap( + PLUGIN_NAME, + (source, module, renderContext) => { + if (/** @type {BuildInfo} */ (module.buildInfo).needCreateRequire) { + const chunkInitFragments = [ + getExternalModuleNodeCommonjsInitFragment( + renderContext.runtimeTemplate + ) + ]; + + renderContext.chunkInitFragments.push(...chunkInitFragments); + } + + return source; + } + ); + + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + */ + const handler = (parser) => { + parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator) => { + if ( + parser.scope.topLevelScope === true && + declarator.id.type === "Identifier" && + declarator.id.name === "module" + ) { + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).moduleArgument = + "__webpack_module__"; + } + }); + + parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => { + if (parser.scope.topLevelScope === true) { + if ( + statement.type === "FunctionDeclaration" && + statement.id && + statement.id.name === "module" + ) { + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).moduleArgument = + "__webpack_module__"; + } else if ( + statement.type === "ClassDeclaration" && + statement.id && + statement.id.name === "module" + ) { + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).moduleArgument = + "__webpack_module__"; + } + } + }); + + for (const key of Object.keys(REPLACEMENTS)) { + const info = REPLACEMENTS[key]; + parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expression) => { + const dep = toConstantDependency(parser, info.expr, info.req); + + if (key === "__non_webpack_require__" && moduleOutput) { + if (nodeTarget) { + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).needCreateRequire = true; + } else { + const warning = new WebpackError( + `${PLUGIN_NAME}\n__non_webpack_require__ is only allowed in target node` + ); + warning.loc = /** @type {DependencyLocation} */ ( + expression.loc + ); + warning.module = parser.state.module; + compilation.warnings.push(warning); + } + } + + return dep(expression); + }); + if (info.assign === false) { + parser.hooks.assign.for(key).tap(PLUGIN_NAME, (expr) => { + const err = new WebpackError(`${key} must not be assigned`); + err.loc = /** @type {DependencyLocation} */ (expr.loc); + throw err; + }); + } + if (info.type) { + parser.hooks.evaluateTypeof + .for(key) + .tap(PLUGIN_NAME, evaluateToString(info.type)); + } + } + + parser.hooks.expression + .for("__webpack_layer__") + .tap(PLUGIN_NAME, (expr) => { + const dep = new ConstDependency( + JSON.stringify(parser.state.module.layer), + /** @type {Range} */ (expr.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return true; + }); + parser.hooks.evaluateIdentifier + .for("__webpack_layer__") + .tap(PLUGIN_NAME, (expr) => + (parser.state.module.layer === null + ? new BasicEvaluatedExpression().setNull() + : new BasicEvaluatedExpression().setString( + parser.state.module.layer + ) + ).setRange(/** @type {Range} */ (expr.range)) + ); + parser.hooks.evaluateTypeof + .for("__webpack_layer__") + .tap(PLUGIN_NAME, (expr) => + new BasicEvaluatedExpression() + .setString( + parser.state.module.layer === null ? "object" : "string" + ) + .setRange(/** @type {Range} */ (expr.range)) + ); + + parser.hooks.expression + .for("__webpack_module__.id") + .tap(PLUGIN_NAME, (expr) => { + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).moduleConcatenationBailout = + "__webpack_module__.id"; + const moduleArgument = parser.state.module.moduleArgument; + if (moduleArgument === "__webpack_module__") { + const dep = new RuntimeRequirementsDependency([ + RuntimeGlobals.moduleId + ]); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + } else { + const initDep = new ModuleInitFragmentDependency( + `var __webpack_internal_module_id__ = ${moduleArgument}.id;\n`, + [RuntimeGlobals.moduleId], + "__webpack_internal_module_id__" + ); + parser.state.module.addPresentationalDependency(initDep); + const dep = new ConstDependency( + "__webpack_internal_module_id__", + /** @type {Range} */ (expr.range), + [] + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + } + return true; + }); + + parser.hooks.expression + .for("__webpack_module__") + .tap(PLUGIN_NAME, (expr) => { + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).moduleConcatenationBailout = + "__webpack_module__"; + const moduleArgument = parser.state.module.moduleArgument; + if (moduleArgument === "__webpack_module__") { + const dep = new RuntimeRequirementsDependency([ + RuntimeGlobals.module + ]); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + } else { + const initDep = new ModuleInitFragmentDependency( + `var __webpack_internal_module__ = ${moduleArgument};\n`, + [RuntimeGlobals.module], + "__webpack_internal_module__" + ); + parser.state.module.addPresentationalDependency(initDep); + const dep = new ConstDependency( + "__webpack_internal_module__", + /** @type {Range} */ (expr.range), + [] + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + } + return true; + }); + parser.hooks.evaluateTypeof + .for("__webpack_module__") + .tap(PLUGIN_NAME, evaluateToString("object")); + }; + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } +} + +module.exports = APIPlugin; Index: frontend/node_modules/webpack/lib/AsyncDependenciesBlock.js =================================================================== --- frontend/node_modules/webpack/lib/AsyncDependenciesBlock.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/AsyncDependenciesBlock.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,131 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const DependenciesBlock = require("./DependenciesBlock"); +const makeSerializable = require("./util/makeSerializable"); + +/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ + +/** @typedef {(ChunkGroupOptions & { entryOptions?: EntryOptions } & { circular?: boolean })} GroupOptions */ + +class AsyncDependenciesBlock extends DependenciesBlock { + /** + * @param {GroupOptions | string | null} groupOptions options for the group + * @param {(DependencyLocation | null)=} loc the line of code + * @param {(string | null)=} request the request + */ + constructor(groupOptions, loc, request) { + super(); + if (typeof groupOptions === "string") { + groupOptions = { name: groupOptions }; + } else if (!groupOptions) { + groupOptions = { name: undefined }; + } + if (typeof groupOptions.circular !== "boolean") { + // default allow circular references + groupOptions.circular = true; + } + /** @type {GroupOptions} */ + this.groupOptions = groupOptions; + /** @type {DependencyLocation | null | undefined} */ + this.loc = loc; + /** @type {string | null | undefined} */ + this.request = request; + /** @type {undefined | string} */ + this._stringifiedGroupOptions = undefined; + } + + /** + * @returns {ChunkGroupOptions["name"]} The name of the chunk + */ + get chunkName() { + return this.groupOptions.name; + } + + /** + * @param {string | undefined} value The new chunk name + * @returns {void} + */ + set chunkName(value) { + if (this.groupOptions.name !== value) { + this.groupOptions.name = value; + this._stringifiedGroupOptions = undefined; + } + } + + /** + * @returns {boolean} Whether circular references are allowed + */ + get circular() { + return Boolean(this.groupOptions.circular); + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) { + const { chunkGraph } = context; + if (this._stringifiedGroupOptions === undefined) { + this._stringifiedGroupOptions = JSON.stringify(this.groupOptions); + } + const chunkGroup = chunkGraph.getBlockChunkGroup(this); + hash.update( + `${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}` + ); + super.updateHash(hash, context); + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + write(this.groupOptions); + write(this.loc); + write(this.request); + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + this.groupOptions = read(); + this.loc = read(); + this.request = read(); + super.deserialize(context); + } +} + +makeSerializable(AsyncDependenciesBlock, "webpack/lib/AsyncDependenciesBlock"); + +Object.defineProperty(AsyncDependenciesBlock.prototype, "module", { + get() { + throw new Error( + "module property was removed from AsyncDependenciesBlock (it's not needed)" + ); + }, + set() { + throw new Error( + "module property was removed from AsyncDependenciesBlock (it's not needed)" + ); + } +}); + +module.exports = AsyncDependenciesBlock; Index: frontend/node_modules/webpack/lib/AutomaticPrefetchPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/AutomaticPrefetchPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/AutomaticPrefetchPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,71 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const asyncLib = require("neo-async"); +const NormalModule = require("./NormalModule"); +const PrefetchDependency = require("./dependencies/PrefetchDependency"); + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "AutomaticPrefetchPlugin"; + +/** + * Records modules from one compilation and adds them back as prefetch + * dependencies in the next compilation. + */ +class AutomaticPrefetchPlugin { + /** + * Registers hooks that remember previously built normal modules and enqueue + * them as `PrefetchDependency` requests during the next make phase. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyFactories.set( + PrefetchDependency, + normalModuleFactory + ); + } + ); + /** @type {{ context: string | null, request: string }[] | null} */ + let lastModules = null; + compiler.hooks.afterCompile.tap(PLUGIN_NAME, (compilation) => { + lastModules = []; + + for (const m of compilation.modules) { + if (m instanceof NormalModule) { + lastModules.push({ + context: m.context, + request: m.request + }); + } + } + }); + compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => { + if (!lastModules) return callback(); + asyncLib.each( + lastModules, + (m, callback) => { + compilation.addModuleChain( + m.context || compiler.context, + new PrefetchDependency(`!!${m.request}`), + callback + ); + }, + (err) => { + lastModules = null; + callback(err); + } + ); + }); + } +} + +module.exports = AutomaticPrefetchPlugin; Index: frontend/node_modules/webpack/lib/BannerPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/BannerPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/BannerPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,146 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { ConcatSource } = require("webpack-sources"); +const Compilation = require("./Compilation"); +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); +const Template = require("./Template"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */ +/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */ +/** @typedef {import("./Compilation").PathDataChunk} PathDataChunk */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Chunk")} Chunk */ + +/** @typedef {(data: { hash?: string, chunk: Chunk, filename: string }) => string} BannerFunction */ + +/** + * Wraps banner text in a JavaScript block comment, preserving multi-line + * formatting and escaping accidental comment terminators. + * @param {string} str string to wrap + * @returns {string} wrapped string + */ +const wrapComment = (str) => { + if (!str.includes("\n")) { + return Template.toComment(str); + } + return `/*!\n * ${str + .replace(/\*\//g, "* /") + .split("\n") + .join("\n * ") + .replace(/\s+\n/g, "\n") + .trimEnd()}\n */`; +}; + +const PLUGIN_NAME = "BannerPlugin"; + +/** + * Prepends or appends banner text to emitted assets that match the configured + * file filters. + */ +class BannerPlugin { + /** + * Normalizes banner options and compiles the configured banner source into a + * function that can render per-asset banner text. + * @param {BannerPluginArgument} options options object + */ + constructor(options) { + if (typeof options === "string" || typeof options === "function") { + options = { + banner: options + }; + } + + /** @type {BannerPluginOptions} */ + this.options = options; + + const bannerOption = options.banner; + if (typeof bannerOption === "function") { + const getBanner = bannerOption; + /** @type {BannerFunction} */ + this.banner = this.options.raw + ? getBanner + : /** @type {BannerFunction} */ (data) => wrapComment(getBanner(data)); + } else { + const banner = this.options.raw + ? bannerOption + : wrapComment(bannerOption); + /** @type {BannerFunction} */ + this.banner = () => banner; + } + } + + /** + * Validates the configured options and injects rendered banner comments into + * matching compilation assets at the configured process-assets stage. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => require("../schemas/plugins/BannerPlugin.json"), + this.options, + { + name: "Banner Plugin", + baseDataPath: "options" + }, + (options) => require("../schemas/plugins/BannerPlugin.check")(options) + ); + }); + const options = this.options; + const banner = this.banner; + const matchObject = ModuleFilenameHelpers.matchObject.bind( + undefined, + options + ); + /** @type {WeakMap} */ + const cache = new WeakMap(); + const stage = + this.options.stage || Compilation.PROCESS_ASSETS_STAGE_ADDITIONS; + + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + compilation.hooks.processAssets.tap({ name: PLUGIN_NAME, stage }, () => { + for (const chunk of compilation.chunks) { + if (options.entryOnly && !chunk.canBeInitial()) { + continue; + } + + for (const file of chunk.files) { + if (!matchObject(file)) { + continue; + } + + /** @type {PathDataChunk} */ + const data = { chunk, filename: file }; + + const comment = compilation.getPath( + /** @type {string | import("./TemplatedPathPlugin").TemplatePathFn} */ + (banner), + data + ); + + compilation.updateAsset(file, (old) => { + const cached = cache.get(old); + if (!cached || cached.comment !== comment) { + const source = options.footer + ? new ConcatSource(old, "\n", comment) + : new ConcatSource(comment, "\n", old); + cache.set(old, { source, comment }); + return source; + } + return cached.source; + }); + } + } + }); + }); + } +} + +module.exports = BannerPlugin; Index: frontend/node_modules/webpack/lib/Cache.js =================================================================== --- frontend/node_modules/webpack/lib/Cache.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Cache.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,190 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = require("tapable"); +const { + makeWebpackError, + makeWebpackErrorCallback +} = require("./errors/HookWebpackError"); + +/** + * Cache validation token whose string representation identifies the build + * inputs associated with a cached value. + * @typedef {object} Etag + * @property {() => string} toString + */ + +/** + * Completion callback used by cache operations that either fail with a `Error` or resolve with a typed result. + * @template T + * @callback CallbackCache + * @param {Error | null} err + * @param {T=} result + * @returns {void} + */ + +/** @typedef {EXPECTED_ANY} Data */ + +/** + * Handler invoked after a cache read succeeds so additional cache layers can + * react to the retrieved value. + * @template T + * @callback GotHandler + * @param {T} result + * @param {() => void} callback + * @returns {void} + */ + +/** + * Creates a callback wrapper that waits for a fixed number of completions and + * forwards the first error immediately. + * @param {number} times times + * @param {(err?: Error | null) => void} callback callback + * @returns {(err?: Error | null) => void} callback + */ +const needCalls = (times, callback) => (err) => { + if (--times === 0) { + return callback(err); + } + if (err && times > 0) { + times = 0; + return callback(err); + } +}; + +/** + * Abstract cache interface backed by tapable hooks for reading, writing, idle + * transitions, and shutdown across webpack cache implementations. + */ +class Cache { + /** + * Initializes the cache lifecycle hooks implemented by cache backends. + */ + constructor() { + this.hooks = { + /** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], Data>} */ + get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]), + /** @type {AsyncParallelHook<[string, Etag | null, Data]>} */ + store: new AsyncParallelHook(["identifier", "etag", "data"]), + /** @type {AsyncParallelHook<[Iterable]>} */ + storeBuildDependencies: new AsyncParallelHook(["dependencies"]), + /** @type {SyncHook<[]>} */ + beginIdle: new SyncHook([]), + /** @type {AsyncParallelHook<[]>} */ + endIdle: new AsyncParallelHook([]), + /** @type {AsyncParallelHook<[]>} */ + shutdown: new AsyncParallelHook([]) + }; + } + + /** + * Retrieves a cached value and lets registered `gotHandlers` observe the + * result before the caller receives it. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @param {CallbackCache} callback signals when the value is retrieved + * @returns {void} + */ + get(identifier, etag, callback) { + /** @type {GotHandler[]} */ + const gotHandlers = []; + this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => { + if (err) { + callback(makeWebpackError(err, "Cache.hooks.get")); + return; + } + if (result === null) { + result = undefined; + } + if (gotHandlers.length > 1) { + const innerCallback = needCalls(gotHandlers.length, () => + callback(null, result) + ); + for (const gotHandler of gotHandlers) { + gotHandler(result, innerCallback); + } + } else if (gotHandlers.length === 1) { + gotHandlers[0](result, () => callback(null, result)); + } else { + callback(null, result); + } + }); + } + + /** + * Stores a cache entry for the identifier and etag through the registered + * cache backend hooks. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @param {T} data the value to store + * @param {CallbackCache} callback signals when the value is stored + * @returns {void} + */ + store(identifier, etag, data, callback) { + this.hooks.store.callAsync( + identifier, + etag, + data, + makeWebpackErrorCallback(callback, "Cache.hooks.store") + ); + } + + /** + * Persists the set of build dependencies required to determine whether the + * cache can be restored in a future compilation. + * @param {Iterable} dependencies list of all build dependencies + * @param {CallbackCache} callback signals when the dependencies are stored + * @returns {void} + */ + storeBuildDependencies(dependencies, callback) { + this.hooks.storeBuildDependencies.callAsync( + dependencies, + makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies") + ); + } + + /** + * Signals that webpack is entering an idle phase and cache backends may flush + * or compact pending work. + * @returns {void} + */ + beginIdle() { + this.hooks.beginIdle.call(); + } + + /** + * Signals that webpack is leaving the idle phase and waits for cache + * backends to finish any asynchronous resume work. + * @param {CallbackCache} callback signals when the call finishes + * @returns {void} + */ + endIdle(callback) { + this.hooks.endIdle.callAsync( + makeWebpackErrorCallback(callback, "Cache.hooks.endIdle") + ); + } + + /** + * Shuts down every registered cache backend and waits for cleanup to finish. + * @param {CallbackCache} callback signals when the call finishes + * @returns {void} + */ + shutdown(callback) { + this.hooks.shutdown.callAsync( + makeWebpackErrorCallback(callback, "Cache.hooks.shutdown") + ); + } +} + +Cache.STAGE_MEMORY = -10; +Cache.STAGE_DEFAULT = 0; +Cache.STAGE_DISK = 10; +Cache.STAGE_NETWORK = 20; + +module.exports = Cache; Index: frontend/node_modules/webpack/lib/CacheFacade.js =================================================================== --- frontend/node_modules/webpack/lib/CacheFacade.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/CacheFacade.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,375 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { forEachBail } = require("enhanced-resolve"); +const asyncLib = require("neo-async"); +const getLazyHashedEtag = require("./cache/getLazyHashedEtag"); +const mergeEtags = require("./cache/mergeEtags"); + +/** @typedef {import("./Cache")} Cache */ +/** @typedef {import("./Cache").Etag} Etag */ +/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */ +/** @typedef {import("./util/Hash").HashFunction} HashFunction */ + +/** + * Defines the callback cache callback. + * @template T + * @callback CallbackCache + * @param {(Error | null)=} err + * @param {(T | null)=} result + * @returns {void} + */ + +/** + * Defines the callback normal error cache callback. + * @template T + * @callback CallbackNormalErrorCache + * @param {(Error | null)=} err + * @param {T=} result + * @returns {void} + */ + +class MultiItemCache { + /** + * Creates an instance of MultiItemCache. + * @param {ItemCacheFacade[]} items item caches + */ + constructor(items) { + this._items = items; + // @ts-expect-error expected - returns the single ItemCacheFacade when passed an array of length 1 + // eslint-disable-next-line no-constructor-return + if (items.length === 1) return /** @type {ItemCacheFacade} */ (items[0]); + } + + /** + * Returns value. + * @template T + * @param {CallbackCache} callback signals when the value is retrieved + * @returns {void} + */ + get(callback) { + forEachBail(this._items, (item, callback) => item.get(callback), callback); + } + + /** + * Returns promise with the data. + * @template T + * @returns {Promise} promise with the data + */ + getPromise() { + /** + * Returns promise with the data. + * @param {number} i index + * @returns {Promise} promise with the data + */ + const next = (i) => + this._items[i].getPromise().then((result) => { + if (result !== undefined) return result; + if (++i < this._items.length) return next(i); + }); + return next(0); + } + + /** + * Processes the provided data. + * @template T + * @param {T} data the value to store + * @param {CallbackCache} callback signals when the value is stored + * @returns {void} + */ + store(data, callback) { + asyncLib.each( + this._items, + (item, callback) => item.store(data, callback), + callback + ); + } + + /** + * Stores the provided data. + * @template T + * @param {T} data the value to store + * @returns {Promise} promise signals when the value is stored + */ + storePromise(data) { + return Promise.all(this._items.map((item) => item.storePromise(data))).then( + () => {} + ); + } +} + +class ItemCacheFacade { + /** + * Creates an instance of ItemCacheFacade. + * @param {Cache} cache the root cache + * @param {string} name the child cache item name + * @param {Etag | null} etag the etag + */ + constructor(cache, name, etag) { + this._cache = cache; + this._name = name; + this._etag = etag; + } + + /** + * Returns value. + * @template T + * @param {CallbackCache} callback signals when the value is retrieved + * @returns {void} + */ + get(callback) { + this._cache.get(this._name, this._etag, callback); + } + + /** + * Returns promise with the data. + * @template T + * @returns {Promise} promise with the data + */ + getPromise() { + return new Promise((resolve, reject) => { + this._cache.get(this._name, this._etag, (err, data) => { + if (err) { + reject(err); + } else { + resolve(data); + } + }); + }); + } + + /** + * Processes the provided data. + * @template T + * @param {T} data the value to store + * @param {CallbackCache} callback signals when the value is stored + * @returns {void} + */ + store(data, callback) { + this._cache.store(this._name, this._etag, data, callback); + } + + /** + * Stores the provided data. + * @template T + * @param {T} data the value to store + * @returns {Promise} promise signals when the value is stored + */ + storePromise(data) { + return new Promise((resolve, reject) => { + this._cache.store(this._name, this._etag, data, (err) => { + if (err) { + reject(err); + } else { + resolve(); + } + }); + }); + } + + /** + * Processes the provided computer. + * @template T + * @param {(callback: CallbackNormalErrorCache) => void} computer function to compute the value if not cached + * @param {CallbackNormalErrorCache} callback signals when the value is retrieved + * @returns {void} + */ + provide(computer, callback) { + this.get((err, cacheEntry) => { + if (err) return callback(err); + if (cacheEntry !== undefined) return cacheEntry; + computer((err, result) => { + if (err) return callback(err); + this.store(result, (err) => { + if (err) return callback(err); + callback(null, result); + }); + }); + }); + } + + /** + * Returns promise with the data. + * @template T + * @param {() => Promise | T} computer function to compute the value if not cached + * @returns {Promise} promise with the data + */ + async providePromise(computer) { + const cacheEntry = await this.getPromise(); + if (cacheEntry !== undefined) return cacheEntry; + const result = await computer(); + await this.storePromise(result); + return result; + } +} + +class CacheFacade { + /** + * Creates an instance of CacheFacade. + * @param {Cache} cache the root cache + * @param {string} name the child cache name + * @param {HashFunction=} hashFunction the hash function to use + */ + constructor(cache, name, hashFunction) { + this._cache = cache; + this._name = name; + this._hashFunction = hashFunction; + } + + /** + * Returns child cache. + * @param {string} name the child cache name# + * @returns {CacheFacade} child cache + */ + getChildCache(name) { + return new CacheFacade( + this._cache, + `${this._name}|${name}`, + this._hashFunction + ); + } + + /** + * Returns item cache. + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @returns {ItemCacheFacade} item cache + */ + getItemCache(identifier, etag) { + return new ItemCacheFacade( + this._cache, + `${this._name}|${identifier}`, + etag + ); + } + + /** + * Gets lazy hashed etag. + * @param {HashableObject} obj an hashable object + * @returns {Etag} an etag that is lazy hashed + */ + getLazyHashedEtag(obj) { + return getLazyHashedEtag(obj, this._hashFunction); + } + + /** + * Merges the provided values into a single result. + * @param {Etag} a an etag + * @param {Etag} b another etag + * @returns {Etag} an etag that represents both + */ + mergeEtags(a, b) { + return mergeEtags(a, b); + } + + /** + * Returns value. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @param {CallbackCache} callback signals when the value is retrieved + * @returns {void} + */ + get(identifier, etag, callback) { + this._cache.get(`${this._name}|${identifier}`, etag, callback); + } + + /** + * Returns promise with the data. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @returns {Promise} promise with the data + */ + getPromise(identifier, etag) { + return new Promise((resolve, reject) => { + this._cache.get(`${this._name}|${identifier}`, etag, (err, data) => { + if (err) { + reject(err); + } else { + resolve(data); + } + }); + }); + } + + /** + * Processes the provided identifier. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @param {T} data the value to store + * @param {CallbackCache} callback signals when the value is stored + * @returns {void} + */ + store(identifier, etag, data, callback) { + this._cache.store(`${this._name}|${identifier}`, etag, data, callback); + } + + /** + * Stores the provided identifier. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @param {T} data the value to store + * @returns {Promise} promise signals when the value is stored + */ + storePromise(identifier, etag, data) { + return new Promise((resolve, reject) => { + this._cache.store(`${this._name}|${identifier}`, etag, data, (err) => { + if (err) { + reject(err); + } else { + resolve(); + } + }); + }); + } + + /** + * Processes the provided identifier. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @param {(callback: CallbackNormalErrorCache) => void} computer function to compute the value if not cached + * @param {CallbackNormalErrorCache} callback signals when the value is retrieved + * @returns {void} + */ + provide(identifier, etag, computer, callback) { + this.get(identifier, etag, (err, cacheEntry) => { + if (err) return callback(err); + if (cacheEntry !== undefined) return cacheEntry; + computer((err, result) => { + if (err) return callback(err); + this.store(identifier, etag, result, (err) => { + if (err) return callback(err); + callback(null, result); + }); + }); + }); + } + + /** + * Returns promise with the data. + * @template T + * @param {string} identifier the cache identifier + * @param {Etag | null} etag the etag + * @param {() => Promise | T} computer function to compute the value if not cached + * @returns {Promise} promise with the data + */ + async providePromise(identifier, etag, computer) { + const cacheEntry = await this.getPromise(identifier, etag); + if (cacheEntry !== undefined) return cacheEntry; + const result = await computer(); + await this.storePromise(identifier, etag, result); + return result; + } +} + +module.exports = CacheFacade; +module.exports.ItemCacheFacade = ItemCacheFacade; +module.exports.MultiItemCache = MultiItemCache; Index: frontend/node_modules/webpack/lib/Chunk.js =================================================================== --- frontend/node_modules/webpack/lib/Chunk.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Chunk.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,966 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const ChunkGraph = require("./ChunkGraph"); +const Entrypoint = require("./Entrypoint"); +const { intersect } = require("./util/SetHelpers"); +const SortableSet = require("./util/SortableSet"); +const StringXor = require("./util/StringXor"); +const { + compareChunkGroupsByIndex, + compareModulesById, + compareModulesByIdentifier +} = require("./util/comparators"); +const { createArrayToSetDeprecationSet } = require("./util/deprecation"); +const { mergeRuntime } = require("./util/runtime"); + +/** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */ +/** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */ +/** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ +/** @typedef {import("./ChunkGroup")} ChunkGroup */ +/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */ +/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Compilation").PathDataChunk} PathDataChunk */ +/** @typedef {import("./TemplatedPathPlugin").TemplatePathFn} ChunkFilenameTemplateFn */ +/** @typedef {string | ChunkFilenameTemplateFn} ChunkFilenameTemplate */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** @typedef {string | null} ChunkName */ +/** @typedef {string | number} ChunkId */ +/** @typedef {SortableSet} IdNameHints */ + +const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files"); + +/** + * Defines the chunk maps type used by this module. + * @deprecated + * @typedef {object} ChunkMaps + * @property {Record} hash + * @property {Record>} contentHash + * @property {Record} name + */ + +/** + * Defines the chunk module id map type used by this module. + * @deprecated + * @typedef {Record} ChunkModuleIdMap + */ + +/** + * Defines the chunk module hash map type used by this module. + * @deprecated + * @typedef {Record} chunkModuleHashMap + */ + +/** + * Defines the chunk module maps type used by this module. + * @deprecated + * @typedef {object} ChunkModuleMaps + * @property {ChunkModuleIdMap} id + * @property {chunkModuleHashMap} hash + */ + +/** @typedef {Set} Chunks */ +/** @typedef {Set} Entrypoints */ +/** @typedef {Set} Queue */ +/** @typedef {SortableSet} SortableChunkGroups */ +/** @typedef {Record} ChunkChildIdsByOrdersMap */ +/** @typedef {Record} ChunkChildIdsByOrdersMapByData */ +/** @typedef {{ onChunks: Chunk[], chunks: Chunks }} ChunkChildOfTypeInOrder */ + +let debugId = 1000; + +/** + * A Chunk is a unit of encapsulation for Modules. + * Chunks are "rendered" into bundles that get emitted when the build completes. + */ +class Chunk { + /** + * Creates an instance of Chunk. + * @param {ChunkName=} name of chunk being created, is optional (for subclasses) + * @param {boolean} backCompat enable backward-compatibility + */ + constructor(name, backCompat = true) { + /** @type {ChunkId | null} */ + this.id = null; + /** @type {ChunkId[] | null} */ + this.ids = null; + /** @type {number} */ + this.debugId = debugId++; + /** @type {ChunkName | undefined} */ + this.name = name; + /** @type {IdNameHints} */ + this.idNameHints = new SortableSet(); + /** @type {boolean} */ + this.preventIntegration = false; + /** @type {ChunkFilenameTemplate | undefined} */ + this.filenameTemplate = undefined; + /** @type {ChunkFilenameTemplate | undefined} */ + this.cssFilenameTemplate = undefined; + /** + * @private + * @type {SortableChunkGroups} + */ + this._groups = new SortableSet(undefined, compareChunkGroupsByIndex); + /** @type {RuntimeSpec} */ + this.runtime = undefined; + /** @type {Set} */ + this.files = backCompat ? new ChunkFilesSet() : new Set(); + /** @type {Set} */ + this.auxiliaryFiles = new Set(); + /** @type {boolean} */ + this.rendered = false; + /** @type {string=} */ + this.hash = undefined; + /** @type {Record} */ + this.contentHash = Object.create(null); + /** @type {string=} */ + this.renderedHash = undefined; + /** @type {string=} */ + this.chunkReason = undefined; + /** @type {boolean} */ + this.extraAsync = false; + } + + // TODO remove in webpack 6 + // BACKWARD-COMPAT START + /** + * Returns entry module. + * @deprecated + * @returns {Module | undefined} entry module + */ + get entryModule() { + const entryModules = [ + ...ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.entryModule", + "DEP_WEBPACK_CHUNK_ENTRY_MODULE" + ).getChunkEntryModulesIterable(this) + ]; + if (entryModules.length === 0) { + return undefined; + } else if (entryModules.length === 1) { + return entryModules[0]; + } + + throw new Error( + "Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)" + ); + } + + /** + * Checks whether this chunk has an entry module. + * @deprecated + * @returns {boolean} true, if the chunk contains an entry module + */ + hasEntryModule() { + return ( + ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.hasEntryModule", + "DEP_WEBPACK_CHUNK_HAS_ENTRY_MODULE" + ).getNumberOfEntryModules(this) > 0 + ); + } + + /** + * Adds the provided module to the chunk. + * @deprecated + * @param {Module} module the module + * @returns {boolean} true, if the chunk could be added + */ + addModule(module) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.addModule", + "DEP_WEBPACK_CHUNK_ADD_MODULE" + ); + if (chunkGraph.isModuleInChunk(module, this)) return false; + chunkGraph.connectChunkAndModule(this, module); + return true; + } + + /** + * Removes the provided module from the chunk. + * @deprecated + * @param {Module} module the module + * @returns {void} + */ + removeModule(module) { + ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.removeModule", + "DEP_WEBPACK_CHUNK_REMOVE_MODULE" + ).disconnectChunkAndModule(this, module); + } + + /** + * Gets the number of modules in this chunk. + * @deprecated + * @returns {number} the number of module which are contained in this chunk + */ + getNumberOfModules() { + return ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.getNumberOfModules", + "DEP_WEBPACK_CHUNK_GET_NUMBER_OF_MODULES" + ).getNumberOfChunkModules(this); + } + + /** + * @deprecated + * @returns {Iterable} modules + */ + get modulesIterable() { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.modulesIterable", + "DEP_WEBPACK_CHUNK_MODULES_ITERABLE" + ); + return chunkGraph.getOrderedChunkModulesIterable( + this, + compareModulesByIdentifier + ); + } + + /** + * Compares this chunk with another chunk. + * @deprecated + * @param {Chunk} otherChunk the chunk to compare with + * @returns {-1 | 0 | 1} the comparison result + */ + compareTo(otherChunk) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.compareTo", + "DEP_WEBPACK_CHUNK_COMPARE_TO" + ); + return chunkGraph.compareChunks(this, otherChunk); + } + + /** + * Checks whether this chunk contains the module. + * @deprecated + * @param {Module} module the module + * @returns {boolean} true, if the chunk contains the module + */ + containsModule(module) { + return ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.containsModule", + "DEP_WEBPACK_CHUNK_CONTAINS_MODULE" + ).isModuleInChunk(module, this); + } + + /** + * Returns the modules for this chunk. + * @deprecated + * @returns {Module[]} the modules for this chunk + */ + getModules() { + return ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.getModules", + "DEP_WEBPACK_CHUNK_GET_MODULES" + ).getChunkModules(this); + } + + /** + * Removes this chunk from the chunk graph and chunk groups. + * @deprecated + * @returns {void} + */ + remove() { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.remove", + "DEP_WEBPACK_CHUNK_REMOVE" + ); + chunkGraph.disconnectChunk(this); + this.disconnectFromGroups(); + } + + /** + * Moves a module from this chunk to another chunk. + * @deprecated + * @param {Module} module the module + * @param {Chunk} otherChunk the target chunk + * @returns {void} + */ + moveModule(module, otherChunk) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.moveModule", + "DEP_WEBPACK_CHUNK_MOVE_MODULE" + ); + chunkGraph.disconnectChunkAndModule(this, module); + chunkGraph.connectChunkAndModule(otherChunk, module); + } + + /** + * Integrates another chunk into this chunk when possible. + * @deprecated + * @param {Chunk} otherChunk the other chunk + * @returns {boolean} true, if the specified chunk has been integrated + */ + integrate(otherChunk) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.integrate", + "DEP_WEBPACK_CHUNK_INTEGRATE" + ); + if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) { + chunkGraph.integrateChunks(this, otherChunk); + return true; + } + + return false; + } + + /** + * Checks whether this chunk can be integrated with another chunk. + * @deprecated + * @param {Chunk} otherChunk the other chunk + * @returns {boolean} true, if chunks could be integrated + */ + canBeIntegrated(otherChunk) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.canBeIntegrated", + "DEP_WEBPACK_CHUNK_CAN_BE_INTEGRATED" + ); + return chunkGraph.canChunksBeIntegrated(this, otherChunk); + } + + /** + * Checks whether this chunk is empty. + * @deprecated + * @returns {boolean} true, if this chunk contains no module + */ + isEmpty() { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.isEmpty", + "DEP_WEBPACK_CHUNK_IS_EMPTY" + ); + return chunkGraph.getNumberOfChunkModules(this) === 0; + } + + /** + * Returns the total size of all modules in this chunk. + * @deprecated + * @returns {number} total size of all modules in this chunk + */ + modulesSize() { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.modulesSize", + "DEP_WEBPACK_CHUNK_MODULES_SIZE" + ); + return chunkGraph.getChunkModulesSize(this); + } + + /** + * Returns the estimated size for the requested source type. + * @deprecated + * @param {ChunkSizeOptions} options options object + * @returns {number} total size of this chunk + */ + size(options = {}) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.size", + "DEP_WEBPACK_CHUNK_SIZE" + ); + return chunkGraph.getChunkSize(this, options); + } + + /** + * Returns the integrated size with another chunk. + * @deprecated + * @param {Chunk} otherChunk the other chunk + * @param {ChunkSizeOptions} options options object + * @returns {number} total size of the chunk or false if the chunk can't be integrated + */ + integratedSize(otherChunk, options) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.integratedSize", + "DEP_WEBPACK_CHUNK_INTEGRATED_SIZE" + ); + return chunkGraph.getIntegratedChunksSize(this, otherChunk, options); + } + + /** + * Gets chunk module maps. + * @deprecated + * @param {ModuleFilterPredicate} filterFn function used to filter modules + * @returns {ChunkModuleMaps} module map information + */ + getChunkModuleMaps(filterFn) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.getChunkModuleMaps", + "DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS" + ); + /** @type {ChunkModuleIdMap} */ + const chunkModuleIdMap = Object.create(null); + /** @type {chunkModuleHashMap} */ + const chunkModuleHashMap = Object.create(null); + + for (const asyncChunk of this.getAllAsyncChunks()) { + /** @type {ChunkId[] | undefined} */ + let array; + for (const module of chunkGraph.getOrderedChunkModulesIterable( + asyncChunk, + compareModulesById(chunkGraph) + )) { + if (filterFn(module)) { + if (array === undefined) { + array = []; + chunkModuleIdMap[/** @type {ChunkId} */ (asyncChunk.id)] = array; + } + const moduleId = + /** @type {ModuleId} */ + (chunkGraph.getModuleId(module)); + array.push(moduleId); + chunkModuleHashMap[moduleId] = chunkGraph.getRenderedModuleHash( + module, + undefined + ); + } + } + } + + return { + id: chunkModuleIdMap, + hash: chunkModuleHashMap + }; + } + + /** + * Checks whether this chunk contains a matching module in the graph. + * @deprecated + * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules + * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks + * @returns {boolean} return true if module exists in graph + */ + hasModuleInGraph(filterFn, filterChunkFn) { + const chunkGraph = ChunkGraph.getChunkGraphForChunk( + this, + "Chunk.hasModuleInGraph", + "DEP_WEBPACK_CHUNK_HAS_MODULE_IN_GRAPH" + ); + return chunkGraph.hasModuleInGraph(this, filterFn, filterChunkFn); + } + + /** + * Returns the chunk map information. + * @deprecated + * @param {boolean} realHash whether the full hash or the rendered hash is to be used + * @returns {ChunkMaps} the chunk map information + */ + getChunkMaps(realHash) { + /** @type {Record} */ + const chunkHashMap = Object.create(null); + /** @type {Record>} */ + const chunkContentHashMap = Object.create(null); + /** @type {Record} */ + const chunkNameMap = Object.create(null); + + for (const chunk of this.getAllAsyncChunks()) { + const id = /** @type {ChunkId} */ (chunk.id); + chunkHashMap[id] = + /** @type {string} */ + (realHash ? chunk.hash : chunk.renderedHash); + for (const key of Object.keys(chunk.contentHash)) { + if (!chunkContentHashMap[key]) { + chunkContentHashMap[key] = Object.create(null); + } + chunkContentHashMap[key][id] = chunk.contentHash[key]; + } + if (chunk.name) { + chunkNameMap[id] = chunk.name; + } + } + + return { + hash: chunkHashMap, + contentHash: chunkContentHashMap, + name: chunkNameMap + }; + } + // BACKWARD-COMPAT END + + /** + * Checks whether this chunk has runtime. + * @returns {boolean} whether or not the Chunk will have a runtime + */ + hasRuntime() { + for (const chunkGroup of this._groups) { + if ( + chunkGroup instanceof Entrypoint && + chunkGroup.getRuntimeChunk() === this + ) { + return true; + } + } + return false; + } + + /** + * Checks whether it can be initial. + * @returns {boolean} whether or not this chunk can be an initial chunk + */ + canBeInitial() { + for (const chunkGroup of this._groups) { + if (chunkGroup.isInitial()) return true; + } + return false; + } + + /** + * Checks whether this chunk is only initial. + * @returns {boolean} whether this chunk can only be an initial chunk + */ + isOnlyInitial() { + if (this._groups.size <= 0) return false; + for (const chunkGroup of this._groups) { + if (!chunkGroup.isInitial()) return false; + } + return true; + } + + /** + * Gets entry options. + * @returns {EntryOptions | undefined} the entry options for this chunk + */ + getEntryOptions() { + for (const chunkGroup of this._groups) { + if (chunkGroup instanceof Entrypoint) { + return chunkGroup.options; + } + } + return undefined; + } + + /** + * Adds the provided chunk group to the chunk. + * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added + * @returns {void} + */ + addGroup(chunkGroup) { + this._groups.add(chunkGroup); + } + + /** + * Removes the provided chunk group from the chunk. + * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from + * @returns {void} + */ + removeGroup(chunkGroup) { + this._groups.delete(chunkGroup); + } + + /** + * Checks whether this chunk is in group. + * @param {ChunkGroup} chunkGroup the chunkGroup to check + * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup + */ + isInGroup(chunkGroup) { + return this._groups.has(chunkGroup); + } + + /** + * Gets number of groups. + * @returns {number} the amount of groups that the said chunk is in + */ + getNumberOfGroups() { + return this._groups.size; + } + + /** + * Gets groups iterable. + * @returns {SortableChunkGroups} the chunkGroups that the said chunk is referenced in + */ + get groupsIterable() { + this._groups.sort(); + return this._groups; + } + + /** + * Disconnects from groups. + * @returns {void} + */ + disconnectFromGroups() { + for (const chunkGroup of this._groups) { + chunkGroup.removeChunk(this); + } + } + + /** + * Processes the provided new chunk. + * @param {Chunk} newChunk the new chunk that will be split out of + * @returns {void} + */ + split(newChunk) { + for (const chunkGroup of this._groups) { + chunkGroup.insertChunk(newChunk, this); + newChunk.addGroup(chunkGroup); + } + for (const idHint of this.idNameHints) { + newChunk.idNameHints.add(idHint); + } + newChunk.runtime = mergeRuntime(newChunk.runtime, this.runtime); + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash hash (will be modified) + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {void} + */ + updateHash(hash, chunkGraph) { + hash.update( + `${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} ` + ); + const xor = new StringXor(); + for (const m of chunkGraph.getChunkModulesIterable(this)) { + xor.add(chunkGraph.getModuleHash(m, this.runtime)); + } + xor.updateHash(hash); + const entryModules = + chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this); + for (const [m, chunkGroup] of entryModules) { + hash.update( + `entry${chunkGraph.getModuleId(m)}${ + /** @type {ChunkGroup} */ (chunkGroup).id + }` + ); + } + } + + /** + * Gets all async chunks. + * @returns {Chunks} a set of all the async chunks + */ + getAllAsyncChunks() { + /** @type {Queue} */ + const queue = new Set(); + /** @type {Chunks} */ + const chunks = new Set(); + + const initialChunks = intersect( + Array.from(this.groupsIterable, (g) => new Set(g.chunks)) + ); + + /** @type {Queue} */ + const initialQueue = new Set(this.groupsIterable); + + for (const chunkGroup of initialQueue) { + for (const child of chunkGroup.childrenIterable) { + if (child instanceof Entrypoint) { + initialQueue.add(child); + } else { + queue.add(child); + } + } + } + + for (const chunkGroup of queue) { + for (const chunk of chunkGroup.chunks) { + if (!initialChunks.has(chunk)) { + chunks.add(chunk); + } + } + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + + return chunks; + } + + /** + * Gets all initial chunks. + * @returns {Chunks} a set of all the initial chunks (including itself) + */ + getAllInitialChunks() { + /** @type {Chunks} */ + const chunks = new Set(); + /** @type {Queue} */ + const queue = new Set(this.groupsIterable); + for (const group of queue) { + if (group.isInitial()) { + for (const c of group.chunks) chunks.add(c); + for (const g of group.childrenIterable) queue.add(g); + } + } + return chunks; + } + + /** + * Gets all referenced chunks. + * @returns {Chunks} a set of all the referenced chunks (including itself) + */ + getAllReferencedChunks() { + /** @type {Queue} */ + const queue = new Set(this.groupsIterable); + /** @type {Chunks} */ + const chunks = new Set(); + + for (const chunkGroup of queue) { + for (const chunk of chunkGroup.chunks) { + chunks.add(chunk); + } + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + + return chunks; + } + + /** + * Gets all referenced async entrypoints. + * @returns {Entrypoints} a set of all the referenced entrypoints + */ + getAllReferencedAsyncEntrypoints() { + /** @type {Queue} */ + const queue = new Set(this.groupsIterable); + /** @type {Entrypoints} */ + const entrypoints = new Set(); + + for (const chunkGroup of queue) { + for (const entrypoint of chunkGroup.asyncEntrypointsIterable) { + entrypoints.add(/** @type {Entrypoint} */ (entrypoint)); + } + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + + return entrypoints; + } + + /** + * Checks whether this chunk has async chunks. + * @returns {boolean} true, if the chunk references async chunks + */ + hasAsyncChunks() { + /** @type {Queue} */ + const queue = new Set(); + + const initialChunks = intersect( + Array.from(this.groupsIterable, (g) => new Set(g.chunks)) + ); + + for (const chunkGroup of this.groupsIterable) { + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + + for (const chunkGroup of queue) { + for (const chunk of chunkGroup.chunks) { + if (!initialChunks.has(chunk)) { + return true; + } + } + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + + return false; + } + + /** + * Gets child ids by orders. + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {ChunkFilterPredicate=} filterFn function used to filter chunks + * @returns {Record} a record object of names to lists of child ids(?) + */ + getChildIdsByOrders(chunkGraph, filterFn) { + /** @type {Map} */ + const lists = new Map(); + for (const group of this.groupsIterable) { + if (group.chunks[group.chunks.length - 1] === this) { + for (const childGroup of group.childrenIterable) { + const edgeOptions = group.getChildOrderOptions( + childGroup, + chunkGraph + ); + for (const key of Object.keys(edgeOptions)) { + const name = key.slice(0, key.length - "Order".length); + let list = lists.get(name); + if (list === undefined) { + list = []; + lists.set(name, list); + } + list.push({ + order: edgeOptions[key], + group: childGroup + }); + } + } + } + } + /** @type {Record} */ + const result = Object.create(null); + for (const [name, list] of lists) { + list.sort((a, b) => { + const cmp = b.order - a.order; + if (cmp !== 0) return cmp; + return a.group.compareTo(chunkGraph, b.group); + }); + /** @type {Set} */ + const chunkIdSet = new Set(); + for (const item of list) { + for (const chunk of item.group.chunks) { + if (filterFn && !filterFn(chunk, chunkGraph)) continue; + chunkIdSet.add(/** @type {ChunkId} */ (chunk.id)); + } + } + if (chunkIdSet.size > 0) { + result[name] = [...chunkIdSet]; + } + } + return result; + } + + /** + * Gets children of type in order. + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {string} type option name + * @returns {ChunkChildOfTypeInOrder[] | undefined} referenced chunks for a specific type + */ + getChildrenOfTypeInOrder(chunkGraph, type) { + /** @type {{ order: number, group: ChunkGroup, childGroup: ChunkGroup }[]} */ + const list = []; + for (const group of this.groupsIterable) { + for (const childGroup of group.childrenIterable) { + const edgeOptions = group.getChildOrderOptions(childGroup, chunkGraph); + const order = edgeOptions[type]; + if (order === undefined) continue; + list.push({ + order, + group, + childGroup + }); + } + } + if (list.length === 0) return; + list.sort((a, b) => { + const cmp = b.order - a.order; + if (cmp !== 0) return cmp; + return a.group.compareTo(chunkGraph, b.group); + }); + /** @type {ChunkChildOfTypeInOrder[]} */ + const result = []; + /** @type {undefined | ChunkChildOfTypeInOrder} */ + let lastEntry; + for (const { group, childGroup } of list) { + if (lastEntry && lastEntry.onChunks === group.chunks) { + for (const chunk of childGroup.chunks) { + lastEntry.chunks.add(chunk); + } + } else { + result.push( + (lastEntry = { + onChunks: group.chunks, + chunks: new Set(childGroup.chunks) + }) + ); + } + } + return result; + } + + /** + * Gets child ids by orders map. + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included) + * @param {ChunkFilterPredicate=} filterFn function used to filter chunks + * @returns {ChunkChildIdsByOrdersMapByData} a record object of names to lists of child ids(?) by chunk id + */ + getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) { + /** @type {ChunkChildIdsByOrdersMapByData} */ + const chunkMaps = Object.create(null); + + /** + * Adds child ids by orders to map. + * @param {Chunk} chunk a chunk + * @returns {void} + */ + const addChildIdsByOrdersToMap = (chunk) => { + const data = chunk.getChildIdsByOrders(chunkGraph, filterFn); + for (const key of Object.keys(data)) { + let chunkMap = chunkMaps[key]; + if (chunkMap === undefined) { + chunkMaps[key] = chunkMap = Object.create(null); + } + chunkMap[/** @type {ChunkId} */ (chunk.id)] = data[key]; + } + }; + + if (includeDirectChildren) { + /** @type {Chunks} */ + const chunks = new Set(); + for (const chunkGroup of this.groupsIterable) { + for (const chunk of chunkGroup.chunks) { + chunks.add(chunk); + } + } + for (const chunk of chunks) { + addChildIdsByOrdersToMap(chunk); + } + } + + for (const chunk of this.getAllAsyncChunks()) { + addChildIdsByOrdersToMap(chunk); + } + + return chunkMaps; + } + + /** + * Checks whether this chunk contains the chunk graph. + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {string} type option name + * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included) + * @param {ChunkFilterPredicate=} filterFn function used to filter chunks + * @returns {boolean} true when the child is of type order, otherwise false + */ + hasChildByOrder(chunkGraph, type, includeDirectChildren, filterFn) { + if (includeDirectChildren) { + /** @type {Chunks} */ + const chunks = new Set(); + for (const chunkGroup of this.groupsIterable) { + for (const chunk of chunkGroup.chunks) { + chunks.add(chunk); + } + } + for (const chunk of chunks) { + const data = chunk.getChildIdsByOrders(chunkGraph, filterFn); + if (data[type] !== undefined) return true; + } + } + + for (const chunk of this.getAllAsyncChunks()) { + const data = chunk.getChildIdsByOrders(chunkGraph, filterFn); + if (data[type] !== undefined) return true; + } + + return false; + } +} + +module.exports = Chunk; Index: frontend/node_modules/webpack/lib/ChunkGraph.js =================================================================== --- frontend/node_modules/webpack/lib/ChunkGraph.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ChunkGraph.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2083 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const Entrypoint = require("./Entrypoint"); +const ModuleGraphConnection = require("./ModuleGraphConnection"); +const { DEFAULTS } = require("./config/defaults"); +const { first } = require("./util/SetHelpers"); +const SortableSet = require("./util/SortableSet"); +const { + compareIds, + compareIterables, + compareModulesById, + compareModulesByIdentifier, + compareSelect, + concatComparators +} = require("./util/comparators"); +const createHash = require("./util/createHash"); +const findGraphRoots = require("./util/findGraphRoots"); +const { + RuntimeSpecMap, + RuntimeSpecSet, + forEachRuntime, + mergeRuntime, + runtimeToString +} = require("./util/runtime"); + +/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Chunk").Chunks} Chunks */ +/** @typedef {import("./Chunk").Entrypoints} Entrypoints */ +/** @typedef {import("./Chunk").ChunkId} ChunkId */ +/** @typedef {import("./ChunkGroup")} ChunkGroup */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").SourceType} SourceType */ +/** @typedef {import("./Module").SourceTypes} SourceTypes */ +/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */ +/** @typedef {import("./RuntimeModule")} RuntimeModule */ +/** @typedef {import("./util/Hash").HashFunction} HashFunction */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** @type {ReadonlySet} */ +const EMPTY_SET = new Set(); + +const ZERO_BIG_INT = BigInt(0); + +const compareModuleIterables = compareIterables(compareModulesByIdentifier); + +/** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */ +/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */ +/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */ + +/** + * Represents the module hash info runtime component. + * @typedef {object} ChunkSizeOptions + * @property {number=} chunkOverhead constant overhead for a chunk + * @property {number=} entryChunkMultiplicator multiplicator for initial chunks + */ + +class ModuleHashInfo { + /** + * Creates an instance of ModuleHashInfo. + * @param {string} hash hash + * @param {string} renderedHash rendered hash + */ + constructor(hash, renderedHash) { + /** @type {string} */ + this.hash = hash; + /** @type {string} */ + this.renderedHash = renderedHash; + } +} + +/** + * Returns set as array. + * @template T + * @param {SortableSet} set the set + * @returns {T[]} set as array + */ +const getArray = (set) => [...set]; + +/** + * Gets module runtimes. + * @param {SortableChunks} chunks the chunks + * @returns {RuntimeSpecSet} runtimes + */ +const getModuleRuntimes = (chunks) => { + const runtimes = new RuntimeSpecSet(); + for (const chunk of chunks) { + runtimes.add(chunk.runtime); + } + return runtimes; +}; + +/** + * Modules by source type. + * @param {SourceTypesByModule | undefined} sourceTypesByModule sourceTypesByModule + * @returns {ModulesBySourceType} modules by source type + */ +const modulesBySourceType = (sourceTypesByModule) => (set) => { + /** @typedef {SortableSet} ModuleSortableSet */ + /** @type {Map} */ + const map = new Map(); + for (const module of set) { + const sourceTypes = + (sourceTypesByModule && sourceTypesByModule.get(module)) || + module.getSourceTypes(); + for (const sourceType of sourceTypes) { + let innerSet = map.get(sourceType); + if (innerSet === undefined) { + /** @type {ModuleSortableSet} */ + innerSet = new SortableSet(); + map.set(sourceType, innerSet); + } + innerSet.add(module); + } + } + for (const [key, innerSet] of map) { + // When all modules have the source type, we reuse the original SortableSet + // to benefit from the shared cache (especially for sorting) + if (innerSet.size === set.size) { + map.set(key, set); + } + } + return map; +}; + +/** @typedef {(set: SortableSet) => Map>} ModulesBySourceType */ + +/** @type {ModulesBySourceType} */ +const defaultModulesBySourceType = modulesBySourceType(undefined); + +/** + * Defines the module set to array function type used by this module. + * @typedef {(set: SortableSet) => Module[]} ModuleSetToArrayFunction + */ + +/** + * @template T + * @type {WeakMap} + */ +const createOrderedArrayFunctionMap = new WeakMap(); + +/** + * Creates an ordered array function. + * @template T + * @param {ModuleComparator} comparator comparator function + * @returns {ModuleSetToArrayFunction} set as ordered array + */ +const createOrderedArrayFunction = (comparator) => { + let fn = createOrderedArrayFunctionMap.get(comparator); + if (fn !== undefined) return fn; + fn = (set) => { + set.sortWith(comparator); + return [...set]; + }; + createOrderedArrayFunctionMap.set(comparator, fn); + return fn; +}; + +/** + * Returns the size of the modules. + * @param {Iterable} modules the modules to get the count/size of + * @returns {number} the size of the modules + */ +const getModulesSize = (modules) => { + let size = 0; + for (const module of modules) { + for (const type of module.getSourceTypes()) { + size += module.size(type); + } + } + return size; +}; + +/** @typedef {Record} SizesOfModules */ + +/** + * Gets modules sizes. + * @param {Iterable} modules the sortable Set to get the size of + * @returns {SizesOfModules} the sizes of the modules + */ +const getModulesSizes = (modules) => { + /** @type {SizesOfModules} */ + const sizes = Object.create(null); + for (const module of modules) { + for (const type of module.getSourceTypes()) { + sizes[type] = (sizes[type] || 0) + module.size(type); + } + } + return sizes; +}; + +/** + * Checks whether this module hash info is available chunk. + * @param {Chunk} a chunk + * @param {Chunk} b chunk + * @returns {boolean} true, if a is always a parent of b + */ +const isAvailableChunk = (a, b) => { + const queue = new Set(b.groupsIterable); + for (const chunkGroup of queue) { + if (a.isInGroup(chunkGroup)) continue; + if (chunkGroup.isInitial()) return false; + for (const parent of chunkGroup.parentsIterable) { + queue.add(parent); + } + } + return true; +}; + +/** @typedef {SortableSet} SortableChunks */ +/** @typedef {Set} EntryInChunks */ +/** @typedef {Set} RuntimeInChunks */ +/** @typedef {string | number} ModuleId */ +/** @typedef {RuntimeSpecMap, RuntimeRequirements>} ChunkGraphRuntimeRequirements */ + +class ChunkGraphModule { + constructor() { + /** @type {SortableChunks} */ + this.chunks = new SortableSet(); + /** @type {EntryInChunks | undefined} */ + this.entryInChunks = undefined; + /** @type {RuntimeInChunks | undefined} */ + this.runtimeInChunks = undefined; + /** @type {RuntimeSpecMap | undefined} */ + this.hashes = undefined; + /** @type {ModuleId | null} */ + this.id = null; + /** @type {ChunkGraphRuntimeRequirements | undefined} */ + this.runtimeRequirements = undefined; + /** @type {RuntimeSpecMap | undefined} */ + this.graphHashes = undefined; + /** @type {RuntimeSpecMap | undefined} */ + this.graphHashesWithConnections = undefined; + } +} + +/** @typedef {WeakMap} SourceTypesByModule */ +/** @typedef {Map} EntryModules */ + +class ChunkGraphChunk { + constructor() { + /** @type {SortableSet} */ + this.modules = new SortableSet(); + /** @type {SourceTypesByModule | undefined} */ + this.sourceTypesByModule = undefined; + /** @type {EntryModules} */ + this.entryModules = new Map(); + /** @type {SortableSet} */ + this.runtimeModules = new SortableSet(); + /** @type {Set | undefined} */ + this.fullHashModules = undefined; + /** @type {Set | undefined} */ + this.dependentHashModules = undefined; + /** @type {RuntimeRequirements | undefined} */ + this.runtimeRequirements = undefined; + /** @type {Set} */ + this.runtimeRequirementsInTree = new Set(); + /** @type {ModulesBySourceType} */ + this._modulesBySourceType = defaultModulesBySourceType; + } +} + +/** @typedef {string | number} RuntimeId */ +/** @typedef {Record} IdToHashMap */ +/** @typedef {Record} ChunkModuleHashMap */ +/** @typedef {Record} ChunkModuleIdMap */ +/** @typedef {Record} ChunkConditionMap */ + +/** @typedef {(a: Module, b: Module) => -1 | 0 | 1} ModuleComparator */ + +class ChunkGraph { + /** + * Creates an instance of ChunkGraph. + * @param {ModuleGraph} moduleGraph the module graph + * @param {HashFunction} hashFunction the hash function to use + */ + constructor(moduleGraph, hashFunction = DEFAULTS.HASH_FUNCTION) { + /** + * @private + * @type {WeakMap} + */ + this._modules = new WeakMap(); + /** + * @private + * @type {WeakMap} + */ + this._chunks = new WeakMap(); + /** + * @private + * @type {WeakMap} + */ + this._blockChunkGroups = new WeakMap(); + /** + * @private + * @type {Map} + */ + this._runtimeIds = new Map(); + /** @type {ModuleGraph} */ + this.moduleGraph = moduleGraph; + + this._hashFunction = hashFunction; + + this._getGraphRoots = this._getGraphRoots.bind(this); + } + + /** + * Get chunk graph module. + * @private + * @param {Module} module the module + * @returns {ChunkGraphModule} internal module + */ + _getChunkGraphModule(module) { + let cgm = this._modules.get(module); + if (cgm === undefined) { + cgm = new ChunkGraphModule(); + this._modules.set(module, cgm); + } + return cgm; + } + + /** + * Get chunk graph chunk. + * @private + * @param {Chunk} chunk the chunk + * @returns {ChunkGraphChunk} internal chunk + */ + _getChunkGraphChunk(chunk) { + let cgc = this._chunks.get(chunk); + if (cgc === undefined) { + cgc = new ChunkGraphChunk(); + this._chunks.set(chunk, cgc); + } + return cgc; + } + + /** + * Returns the graph roots. + * @param {SortableSet} set the sortable Set to get the roots of + * @returns {Module[]} the graph roots + */ + _getGraphRoots(set) { + const { moduleGraph } = this; + return [ + ...findGraphRoots(set, (module) => { + /** @type {Set} */ + const set = new Set(); + /** + * Adds the provided module to the chunk graph. + * @param {Module} module module + */ + const addDependencies = (module) => { + for (const connection of moduleGraph.getOutgoingConnections(module)) { + if (!connection.module) continue; + const activeState = connection.getActiveState(undefined); + if (activeState === false) continue; + if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) { + addDependencies(connection.module); + continue; + } + set.add(connection.module); + } + }; + addDependencies(module); + return set; + }) + ].sort(compareModulesByIdentifier); + } + + /** + * Connects chunk and module. + * @param {Chunk} chunk the new chunk + * @param {Module} module the module + * @returns {void} + */ + connectChunkAndModule(chunk, module) { + const cgm = this._getChunkGraphModule(module); + const cgc = this._getChunkGraphChunk(chunk); + cgm.chunks.add(chunk); + cgc.modules.add(module); + } + + /** + * Disconnects chunk and module. + * @param {Chunk} chunk the chunk + * @param {Module} module the module + * @returns {void} + */ + disconnectChunkAndModule(chunk, module) { + const cgm = this._getChunkGraphModule(module); + const cgc = this._getChunkGraphChunk(chunk); + cgc.modules.delete(module); + // No need to invalidate cgc._modulesBySourceType because we modified cgc.modules anyway + if (cgc.sourceTypesByModule) cgc.sourceTypesByModule.delete(module); + cgm.chunks.delete(chunk); + } + + /** + * Processes the provided chunk. + * @param {Chunk} chunk the chunk which will be disconnected + * @returns {void} + */ + disconnectChunk(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + for (const module of cgc.modules) { + const cgm = this._getChunkGraphModule(module); + cgm.chunks.delete(chunk); + } + cgc.modules.clear(); + chunk.disconnectFromGroups(); + ChunkGraph.clearChunkGraphForChunk(chunk); + } + + /** + * Processes the provided chunk. + * @param {Chunk} chunk the chunk + * @param {Iterable} modules the modules + * @returns {void} + */ + attachModules(chunk, modules) { + const cgc = this._getChunkGraphChunk(chunk); + for (const module of modules) { + cgc.modules.add(module); + } + } + + /** + * Attach runtime modules. + * @param {Chunk} chunk the chunk + * @param {Iterable} modules the runtime modules + * @returns {void} + */ + attachRuntimeModules(chunk, modules) { + const cgc = this._getChunkGraphChunk(chunk); + for (const module of modules) { + cgc.runtimeModules.add(module); + } + } + + /** + * Attach full hash modules. + * @param {Chunk} chunk the chunk + * @param {Iterable} modules the modules that require a full hash + * @returns {void} + */ + attachFullHashModules(chunk, modules) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set(); + for (const module of modules) { + cgc.fullHashModules.add(module); + } + } + + /** + * Attach dependent hash modules. + * @param {Chunk} chunk the chunk + * @param {Iterable} modules the modules that require a full hash + * @returns {void} + */ + attachDependentHashModules(chunk, modules) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.dependentHashModules === undefined) { + cgc.dependentHashModules = new Set(); + } + for (const module of modules) { + cgc.dependentHashModules.add(module); + } + } + + /** + * Processes the provided old module. + * @param {Module} oldModule the replaced module + * @param {Module} newModule the replacing module + * @returns {void} + */ + replaceModule(oldModule, newModule) { + const oldCgm = this._getChunkGraphModule(oldModule); + const newCgm = this._getChunkGraphModule(newModule); + + for (const chunk of oldCgm.chunks) { + const cgc = this._getChunkGraphChunk(chunk); + cgc.modules.delete(oldModule); + cgc.modules.add(newModule); + newCgm.chunks.add(chunk); + } + oldCgm.chunks.clear(); + + if (oldCgm.entryInChunks !== undefined) { + if (newCgm.entryInChunks === undefined) { + newCgm.entryInChunks = new Set(); + } + for (const chunk of oldCgm.entryInChunks) { + const cgc = this._getChunkGraphChunk(chunk); + const old = /** @type {Entrypoint} */ (cgc.entryModules.get(oldModule)); + /** @type {EntryModules} */ + const newEntryModules = new Map(); + for (const [m, cg] of cgc.entryModules) { + if (m === oldModule) { + newEntryModules.set(newModule, old); + } else { + newEntryModules.set(m, cg); + } + } + cgc.entryModules = newEntryModules; + newCgm.entryInChunks.add(chunk); + } + oldCgm.entryInChunks = undefined; + } + + if (oldCgm.runtimeInChunks !== undefined) { + if (newCgm.runtimeInChunks === undefined) { + newCgm.runtimeInChunks = new Set(); + } + for (const chunk of oldCgm.runtimeInChunks) { + const cgc = this._getChunkGraphChunk(chunk); + cgc.runtimeModules.delete(/** @type {RuntimeModule} */ (oldModule)); + cgc.runtimeModules.add(/** @type {RuntimeModule} */ (newModule)); + newCgm.runtimeInChunks.add(chunk); + if ( + cgc.fullHashModules !== undefined && + cgc.fullHashModules.has(/** @type {RuntimeModule} */ (oldModule)) + ) { + cgc.fullHashModules.delete(/** @type {RuntimeModule} */ (oldModule)); + cgc.fullHashModules.add(/** @type {RuntimeModule} */ (newModule)); + } + if ( + cgc.dependentHashModules !== undefined && + cgc.dependentHashModules.has(/** @type {RuntimeModule} */ (oldModule)) + ) { + cgc.dependentHashModules.delete( + /** @type {RuntimeModule} */ (oldModule) + ); + cgc.dependentHashModules.add( + /** @type {RuntimeModule} */ (newModule) + ); + } + } + oldCgm.runtimeInChunks = undefined; + } + } + + /** + * Checks whether this chunk graph is module in chunk. + * @param {Module} module the checked module + * @param {Chunk} chunk the checked chunk + * @returns {boolean} true, if the chunk contains the module + */ + isModuleInChunk(module, chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.modules.has(module); + } + + /** + * Checks whether this chunk graph is module in chunk group. + * @param {Module} module the checked module + * @param {ChunkGroup} chunkGroup the checked chunk group + * @returns {boolean} true, if the chunk contains the module + */ + isModuleInChunkGroup(module, chunkGroup) { + for (const chunk of chunkGroup.chunks) { + if (this.isModuleInChunk(module, chunk)) return true; + } + return false; + } + + /** + * Checks whether this chunk graph is entry module. + * @param {Module} module the checked module + * @returns {boolean} true, if the module is entry of any chunk + */ + isEntryModule(module) { + const cgm = this._getChunkGraphModule(module); + return cgm.entryInChunks !== undefined; + } + + /** + * Gets module chunks iterable. + * @param {Module} module the module + * @returns {Iterable} iterable of chunks (do not modify) + */ + getModuleChunksIterable(module) { + const cgm = this._getChunkGraphModule(module); + return cgm.chunks; + } + + /** + * Gets ordered module chunks iterable. + * @param {Module} module the module + * @param {(a: Chunk, b: Chunk) => -1 | 0 | 1} sortFn sort function + * @returns {Iterable} iterable of chunks (do not modify) + */ + getOrderedModuleChunksIterable(module, sortFn) { + const cgm = this._getChunkGraphModule(module); + cgm.chunks.sortWith(sortFn); + return cgm.chunks; + } + + /** + * Gets module chunks. + * @param {Module} module the module + * @returns {Chunk[]} array of chunks (cached, do not modify) + */ + getModuleChunks(module) { + const cgm = this._getChunkGraphModule(module); + return cgm.chunks.getFromCache(getArray); + } + + /** + * Gets number of module chunks. + * @param {Module} module the module + * @returns {number} the number of chunk which contain the module + */ + getNumberOfModuleChunks(module) { + const cgm = this._getChunkGraphModule(module); + return cgm.chunks.size; + } + + /** + * Gets module runtimes. + * @param {Module} module the module + * @returns {RuntimeSpecSet} runtimes + */ + getModuleRuntimes(module) { + const cgm = this._getChunkGraphModule(module); + return cgm.chunks.getFromUnorderedCache(getModuleRuntimes); + } + + /** + * Gets number of chunk modules. + * @param {Chunk} chunk the chunk + * @returns {number} the number of modules which are contained in this chunk + */ + getNumberOfChunkModules(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.modules.size; + } + + /** + * Gets number of chunk full hash modules. + * @param {Chunk} chunk the chunk + * @returns {number} the number of full hash modules which are contained in this chunk + */ + getNumberOfChunkFullHashModules(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.fullHashModules === undefined ? 0 : cgc.fullHashModules.size; + } + + /** + * Gets chunk modules iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable} return the modules for this chunk + */ + getChunkModulesIterable(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.modules; + } + + /** + * Gets chunk modules iterable by source type. + * @param {Chunk} chunk the chunk + * @param {string} sourceType source type + * @returns {Iterable | undefined} return the modules for this chunk + */ + getChunkModulesIterableBySourceType(chunk, sourceType) { + const cgc = this._getChunkGraphChunk(chunk); + const modulesWithSourceType = cgc.modules + .getFromUnorderedCache(cgc._modulesBySourceType) + .get(sourceType); + return modulesWithSourceType; + } + + /** + * Sets chunk module source types. + * @param {Chunk} chunk chunk + * @param {Module} module chunk module + * @param {SourceTypes} sourceTypes source types + */ + setChunkModuleSourceTypes(chunk, module, sourceTypes) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.sourceTypesByModule === undefined) { + cgc.sourceTypesByModule = new WeakMap(); + } + cgc.sourceTypesByModule.set(module, sourceTypes); + // Update cgc._modulesBySourceType to invalidate the cache + cgc._modulesBySourceType = modulesBySourceType(cgc.sourceTypesByModule); + } + + /** + * Gets chunk module source types. + * @param {Chunk} chunk chunk + * @param {Module} module chunk module + * @returns {SourceTypes} source types + */ + getChunkModuleSourceTypes(chunk, module) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.sourceTypesByModule === undefined) { + return module.getSourceTypes(); + } + return cgc.sourceTypesByModule.get(module) || module.getSourceTypes(); + } + + /** + * Gets module source types. + * @param {Module} module module + * @returns {SourceTypes} source types + */ + getModuleSourceTypes(module) { + return ( + this._getOverwrittenModuleSourceTypes(module) || module.getSourceTypes() + ); + } + + /** + * Get overwritten module source types. + * @param {Module} module module + * @returns {SourceTypes | undefined} source types + */ + _getOverwrittenModuleSourceTypes(module) { + let newSet = false; + /** @type {Set | undefined} */ + let sourceTypes; + for (const chunk of this.getModuleChunksIterable(module)) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.sourceTypesByModule === undefined) return; + const st = cgc.sourceTypesByModule.get(module); + if (st === undefined) return; + if (!sourceTypes) { + sourceTypes = /** @type {Set} */ (st); + } else if (!newSet) { + for (const type of st) { + if (!newSet) { + if (!sourceTypes.has(type)) { + newSet = true; + sourceTypes = new Set(sourceTypes); + sourceTypes.add(type); + } + } else { + sourceTypes.add(type); + } + } + } else { + for (const type of st) sourceTypes.add(type); + } + } + + return sourceTypes; + } + + /** + * Gets ordered chunk modules iterable. + * @param {Chunk} chunk the chunk + * @param {ModuleComparator} comparator comparator function + * @returns {Iterable} return the modules for this chunk + */ + getOrderedChunkModulesIterable(chunk, comparator) { + const cgc = this._getChunkGraphChunk(chunk); + cgc.modules.sortWith(comparator); + return cgc.modules; + } + + /** + * Gets ordered chunk modules iterable by source type. + * @param {Chunk} chunk the chunk + * @param {string} sourceType source type + * @param {ModuleComparator} comparator comparator function + * @returns {Iterable | undefined} return the modules for this chunk + */ + getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) { + const cgc = this._getChunkGraphChunk(chunk); + const modulesWithSourceType = cgc.modules + .getFromUnorderedCache(cgc._modulesBySourceType) + .get(sourceType); + if (modulesWithSourceType === undefined) return; + modulesWithSourceType.sortWith(comparator); + return modulesWithSourceType; + } + + /** + * Gets chunk modules. + * @param {Chunk} chunk the chunk + * @returns {Module[]} return the modules for this chunk (cached, do not modify) + */ + getChunkModules(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.modules.getFromUnorderedCache(getArray); + } + + /** + * Gets ordered chunk modules. + * @param {Chunk} chunk the chunk + * @param {ModuleComparator} comparator comparator function + * @returns {Module[]} return the modules for this chunk (cached, do not modify) + */ + getOrderedChunkModules(chunk, comparator) { + const cgc = this._getChunkGraphChunk(chunk); + const arrayFunction = createOrderedArrayFunction(comparator); + return cgc.modules.getFromUnorderedCache(arrayFunction); + } + + /** + * Gets chunk module id map. + * @param {Chunk} chunk the chunk + * @param {ModuleFilterPredicate} filterFn function used to filter modules + * @param {boolean} includeAllChunks all chunks or only async chunks + * @returns {ChunkModuleIdMap} chunk to module ids object + */ + getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) { + /** @type {ChunkModuleIdMap} */ + const chunkModuleIdMap = Object.create(null); + + for (const asyncChunk of includeAllChunks + ? chunk.getAllReferencedChunks() + : chunk.getAllAsyncChunks()) { + /** @type {ModuleId[] | undefined} */ + let array; + for (const module of this.getOrderedChunkModulesIterable( + asyncChunk, + compareModulesById(this) + )) { + if (filterFn(module)) { + if (array === undefined) { + array = []; + chunkModuleIdMap[/** @type {ChunkId} */ (asyncChunk.id)] = array; + } + const moduleId = /** @type {ModuleId} */ (this.getModuleId(module)); + array.push(moduleId); + } + } + } + + return chunkModuleIdMap; + } + + /** + * Gets chunk module rendered hash map. + * @param {Chunk} chunk the chunk + * @param {ModuleFilterPredicate} filterFn function used to filter modules + * @param {number} hashLength length of the hash + * @param {boolean} includeAllChunks all chunks or only async chunks + * @returns {ChunkModuleHashMap} chunk to module id to module hash object + */ + getChunkModuleRenderedHashMap( + chunk, + filterFn, + hashLength = 0, + includeAllChunks = false + ) { + /** @type {ChunkModuleHashMap} */ + const chunkModuleHashMap = Object.create(null); + + for (const asyncChunk of includeAllChunks + ? chunk.getAllReferencedChunks() + : chunk.getAllAsyncChunks()) { + /** @type {IdToHashMap | undefined} */ + let idToHashMap; + for (const module of this.getOrderedChunkModulesIterable( + asyncChunk, + compareModulesById(this) + )) { + if (filterFn(module)) { + if (idToHashMap === undefined) { + /** @type {IdToHashMap} */ + idToHashMap = Object.create(null); + chunkModuleHashMap[/** @type {ChunkId} */ (asyncChunk.id)] = + /** @type {IdToHashMap} */ + (idToHashMap); + } + const moduleId = this.getModuleId(module); + const hash = this.getRenderedModuleHash(module, asyncChunk.runtime); + /** @type {IdToHashMap} */ + (idToHashMap)[/** @type {ModuleId} */ (moduleId)] = hashLength + ? hash.slice(0, hashLength) + : hash; + } + } + } + + return chunkModuleHashMap; + } + + /** + * Gets chunk condition map. + * @param {Chunk} chunk the chunk + * @param {ChunkFilterPredicate} filterFn function used to filter chunks + * @returns {ChunkConditionMap} chunk condition map + */ + getChunkConditionMap(chunk, filterFn) { + /** @type {ChunkConditionMap} */ + const map = Object.create(null); + for (const c of chunk.getAllReferencedChunks()) { + map[/** @type {ChunkId} */ (c.id)] = filterFn(c, this); + } + return map; + } + + /** + * Checks whether this chunk graph contains the chunk. + * @param {Chunk} chunk the chunk + * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules + * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks + * @returns {boolean} return true if module exists in graph + */ + hasModuleInGraph(chunk, filterFn, filterChunkFn) { + const queue = new Set(chunk.groupsIterable); + /** @type {Set} */ + const chunksProcessed = new Set(); + + for (const chunkGroup of queue) { + for (const innerChunk of chunkGroup.chunks) { + if (!chunksProcessed.has(innerChunk)) { + chunksProcessed.add(innerChunk); + if (!filterChunkFn || filterChunkFn(innerChunk, this)) { + for (const module of this.getChunkModulesIterable(innerChunk)) { + if (filterFn(module)) { + return true; + } + } + } + } + } + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + return false; + } + + /** + * Compares the provided values and returns their ordering. + * @param {Chunk} chunkA first chunk + * @param {Chunk} chunkB second chunk + * @returns {-1 | 0 | 1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order + */ + compareChunks(chunkA, chunkB) { + const cgcA = this._getChunkGraphChunk(chunkA); + const cgcB = this._getChunkGraphChunk(chunkB); + if (cgcA.modules.size > cgcB.modules.size) return -1; + if (cgcA.modules.size < cgcB.modules.size) return 1; + cgcA.modules.sortWith(compareModulesByIdentifier); + cgcB.modules.sortWith(compareModulesByIdentifier); + return compareModuleIterables(cgcA.modules, cgcB.modules); + } + + /** + * Gets chunk modules size. + * @param {Chunk} chunk the chunk + * @returns {number} total size of all modules in the chunk + */ + getChunkModulesSize(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.modules.getFromUnorderedCache(getModulesSize); + } + + /** + * Gets chunk modules sizes. + * @param {Chunk} chunk the chunk + * @returns {Record} total sizes of all modules in the chunk by source type + */ + getChunkModulesSizes(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.modules.getFromUnorderedCache(getModulesSizes); + } + + /** + * Gets chunk root modules. + * @param {Chunk} chunk the chunk + * @returns {Module[]} root modules of the chunks (ordered by identifier) + */ + getChunkRootModules(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.modules.getFromUnorderedCache(this._getGraphRoots); + } + + /** + * Returns total size of the chunk. + * @param {Chunk} chunk the chunk + * @param {ChunkSizeOptions} options options object + * @returns {number} total size of the chunk + */ + getChunkSize(chunk, options = {}) { + const cgc = this._getChunkGraphChunk(chunk); + const modulesSize = cgc.modules.getFromUnorderedCache(getModulesSize); + const chunkOverhead = + typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000; + const entryChunkMultiplicator = + typeof options.entryChunkMultiplicator === "number" + ? options.entryChunkMultiplicator + : 10; + return ( + chunkOverhead + + modulesSize * (chunk.canBeInitial() ? entryChunkMultiplicator : 1) + ); + } + + /** + * Gets integrated chunks size. + * @param {Chunk} chunkA chunk + * @param {Chunk} chunkB chunk + * @param {ChunkSizeOptions} options options object + * @returns {number} total size of the chunk or false if chunks can't be integrated + */ + getIntegratedChunksSize(chunkA, chunkB, options = {}) { + const cgcA = this._getChunkGraphChunk(chunkA); + const cgcB = this._getChunkGraphChunk(chunkB); + const allModules = new Set(cgcA.modules); + for (const m of cgcB.modules) allModules.add(m); + const modulesSize = getModulesSize(allModules); + const chunkOverhead = + typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000; + const entryChunkMultiplicator = + typeof options.entryChunkMultiplicator === "number" + ? options.entryChunkMultiplicator + : 10; + return ( + chunkOverhead + + modulesSize * + (chunkA.canBeInitial() || chunkB.canBeInitial() + ? entryChunkMultiplicator + : 1) + ); + } + + /** + * Checks whether it can chunks be integrated. + * @param {Chunk} chunkA chunk + * @param {Chunk} chunkB chunk + * @returns {boolean} true, if chunks could be integrated + */ + canChunksBeIntegrated(chunkA, chunkB) { + if (chunkA.preventIntegration || chunkB.preventIntegration) { + return false; + } + + const hasRuntimeA = chunkA.hasRuntime(); + const hasRuntimeB = chunkB.hasRuntime(); + + if (hasRuntimeA !== hasRuntimeB) { + if (hasRuntimeA) { + return isAvailableChunk(chunkA, chunkB); + } else if (hasRuntimeB) { + return isAvailableChunk(chunkB, chunkA); + } + + return false; + } + + if ( + this.getNumberOfEntryModules(chunkA) > 0 || + this.getNumberOfEntryModules(chunkB) > 0 + ) { + return false; + } + + return true; + } + + /** + * Processes the provided chunk a. + * @param {Chunk} chunkA the target chunk + * @param {Chunk} chunkB the chunk to integrate + * @returns {void} + */ + integrateChunks(chunkA, chunkB) { + // Decide for one name (deterministic) + if (chunkA.name && chunkB.name) { + if ( + this.getNumberOfEntryModules(chunkA) > 0 === + this.getNumberOfEntryModules(chunkB) > 0 + ) { + // When both chunks have entry modules or none have one, use + // shortest name + if (chunkA.name.length !== chunkB.name.length) { + chunkA.name = + chunkA.name.length < chunkB.name.length ? chunkA.name : chunkB.name; + } else { + chunkA.name = chunkA.name < chunkB.name ? chunkA.name : chunkB.name; + } + } else if (this.getNumberOfEntryModules(chunkB) > 0) { + // Pick the name of the chunk with the entry module + chunkA.name = chunkB.name; + } + } else if (chunkB.name) { + chunkA.name = chunkB.name; + } + + // Merge id name hints + for (const hint of chunkB.idNameHints) { + chunkA.idNameHints.add(hint); + } + + // Merge runtime + chunkA.runtime = mergeRuntime(chunkA.runtime, chunkB.runtime); + + // getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies + for (const module of this.getChunkModules(chunkB)) { + this.disconnectChunkAndModule(chunkB, module); + this.connectChunkAndModule(chunkA, module); + } + + for (const [ + module, + chunkGroup + ] of this.getChunkEntryModulesWithChunkGroupIterable(chunkB)) { + this.disconnectChunkAndEntryModule(chunkB, module); + this.connectChunkAndEntryModule( + chunkA, + module, + /** @type {Entrypoint} */ + (chunkGroup) + ); + } + + for (const chunkGroup of chunkB.groupsIterable) { + chunkGroup.replaceChunk(chunkB, chunkA); + chunkA.addGroup(chunkGroup); + chunkB.removeGroup(chunkGroup); + } + ChunkGraph.clearChunkGraphForChunk(chunkB); + } + + /** + * Upgrade dependent to full hash modules. + * @param {Chunk} chunk the chunk to upgrade + * @returns {void} + */ + upgradeDependentToFullHashModules(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.dependentHashModules === undefined) return; + if (cgc.fullHashModules === undefined) { + cgc.fullHashModules = cgc.dependentHashModules; + } else { + for (const m of cgc.dependentHashModules) { + cgc.fullHashModules.add(m); + } + cgc.dependentHashModules = undefined; + } + } + + /** + * Checks whether this chunk graph is entry module in chunk. + * @param {Module} module the checked module + * @param {Chunk} chunk the checked chunk + * @returns {boolean} true, if the chunk contains the module as entry + */ + isEntryModuleInChunk(module, chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.entryModules.has(module); + } + + /** + * Connects chunk and entry module. + * @param {Chunk} chunk the new chunk + * @param {Module} module the entry module + * @param {Entrypoint} entrypoint the chunk group which must be loaded before the module is executed + * @returns {void} + */ + connectChunkAndEntryModule(chunk, module, entrypoint) { + const cgm = this._getChunkGraphModule(module); + const cgc = this._getChunkGraphChunk(chunk); + if (cgm.entryInChunks === undefined) { + cgm.entryInChunks = new Set(); + } + cgm.entryInChunks.add(chunk); + cgc.entryModules.set(module, entrypoint); + } + + /** + * Connects chunk and runtime module. + * @param {Chunk} chunk the new chunk + * @param {RuntimeModule} module the runtime module + * @returns {void} + */ + connectChunkAndRuntimeModule(chunk, module) { + const cgm = this._getChunkGraphModule(module); + const cgc = this._getChunkGraphChunk(chunk); + if (cgm.runtimeInChunks === undefined) { + cgm.runtimeInChunks = new Set(); + } + cgm.runtimeInChunks.add(chunk); + cgc.runtimeModules.add(module); + } + + /** + * Adds full hash module to chunk. + * @param {Chunk} chunk the new chunk + * @param {RuntimeModule} module the module that require a full hash + * @returns {void} + */ + addFullHashModuleToChunk(chunk, module) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set(); + cgc.fullHashModules.add(module); + } + + /** + * Adds dependent hash module to chunk. + * @param {Chunk} chunk the new chunk + * @param {RuntimeModule} module the module that require a full hash + * @returns {void} + */ + addDependentHashModuleToChunk(chunk, module) { + const cgc = this._getChunkGraphChunk(chunk); + if (cgc.dependentHashModules === undefined) { + cgc.dependentHashModules = new Set(); + } + cgc.dependentHashModules.add(module); + } + + /** + * Disconnects chunk and entry module. + * @param {Chunk} chunk the new chunk + * @param {Module} module the entry module + * @returns {void} + */ + disconnectChunkAndEntryModule(chunk, module) { + const cgm = this._getChunkGraphModule(module); + const cgc = this._getChunkGraphChunk(chunk); + /** @type {EntryInChunks} */ + (cgm.entryInChunks).delete(chunk); + if (/** @type {EntryInChunks} */ (cgm.entryInChunks).size === 0) { + cgm.entryInChunks = undefined; + } + cgc.entryModules.delete(module); + } + + /** + * Disconnects chunk and runtime module. + * @param {Chunk} chunk the new chunk + * @param {RuntimeModule} module the runtime module + * @returns {void} + */ + disconnectChunkAndRuntimeModule(chunk, module) { + const cgm = this._getChunkGraphModule(module); + const cgc = this._getChunkGraphChunk(chunk); + /** @type {RuntimeInChunks} */ + (cgm.runtimeInChunks).delete(chunk); + if (/** @type {RuntimeInChunks} */ (cgm.runtimeInChunks).size === 0) { + cgm.runtimeInChunks = undefined; + } + cgc.runtimeModules.delete(module); + } + + /** + * Disconnects entry module. + * @param {Module} module the entry module, it will no longer be entry + * @returns {void} + */ + disconnectEntryModule(module) { + const cgm = this._getChunkGraphModule(module); + for (const chunk of /** @type {EntryInChunks} */ (cgm.entryInChunks)) { + const cgc = this._getChunkGraphChunk(chunk); + cgc.entryModules.delete(module); + } + cgm.entryInChunks = undefined; + } + + /** + * Disconnects entries. + * @param {Chunk} chunk the chunk, for which all entries will be removed + * @returns {void} + */ + disconnectEntries(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + for (const module of cgc.entryModules.keys()) { + const cgm = this._getChunkGraphModule(module); + /** @type {EntryInChunks} */ + (cgm.entryInChunks).delete(chunk); + if (/** @type {EntryInChunks} */ (cgm.entryInChunks).size === 0) { + cgm.entryInChunks = undefined; + } + } + cgc.entryModules.clear(); + } + + /** + * Gets number of entry modules. + * @param {Chunk} chunk the chunk + * @returns {number} the amount of entry modules in chunk + */ + getNumberOfEntryModules(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.entryModules.size; + } + + /** + * Gets number of runtime modules. + * @param {Chunk} chunk the chunk + * @returns {number} the amount of entry modules in chunk + */ + getNumberOfRuntimeModules(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.runtimeModules.size; + } + + /** + * Gets chunk entry modules iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable} iterable of modules (do not modify) + */ + getChunkEntryModulesIterable(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.entryModules.keys(); + } + + /** + * Gets chunk entry dependent chunks iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable} iterable of chunks + */ + getChunkEntryDependentChunksIterable(chunk) { + /** @type {Chunks} */ + const set = new Set(); + for (const chunkGroup of chunk.groupsIterable) { + if (chunkGroup instanceof Entrypoint) { + const entrypointChunk = chunkGroup.getEntrypointChunk(); + const cgc = this._getChunkGraphChunk(entrypointChunk); + for (const chunkGroup of cgc.entryModules.values()) { + for (const c of chunkGroup.chunks) { + if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) { + set.add(c); + } + } + } + } + } + + return set; + } + + /** + * Gets runtime chunk dependent chunks iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable} iterable of chunks and include chunks from children entrypoints + */ + getRuntimeChunkDependentChunksIterable(chunk) { + /** @type {Chunks} */ + const set = new Set(); + + /** @type {Entrypoints} */ + const entrypoints = new Set(); + + for (const chunkGroup of chunk.groupsIterable) { + if (chunkGroup instanceof Entrypoint) { + const queue = [chunkGroup]; + while (queue.length > 0) { + const current = queue.shift(); + if (current) { + entrypoints.add(current); + + let hasChildrenEntrypoint = false; + for (const child of current.childrenIterable) { + if (child instanceof Entrypoint && child.dependOn(current)) { + hasChildrenEntrypoint = true; + queue.push(/** @type {Entrypoint} */ (child)); + } + } + // entryChunkB: hasChildrenEntrypoint = true + // entryChunkA: dependOn = entryChunkB + if (hasChildrenEntrypoint) { + const entrypointChunk = current.getEntrypointChunk(); + if (entrypointChunk !== chunk && !entrypointChunk.hasRuntime()) { + // add entryChunkB to set + set.add(entrypointChunk); + } + } + } + } + } + } + + for (const entrypoint of entrypoints) { + const entrypointChunk = entrypoint.getEntrypointChunk(); + const cgc = this._getChunkGraphChunk(entrypointChunk); + for (const chunkGroup of cgc.entryModules.values()) { + for (const c of chunkGroup.chunks) { + if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) { + set.add(c); + } + } + } + } + return set; + } + + /** + * Checks whether this chunk graph contains the chunk. + * @param {Chunk} chunk the chunk + * @returns {boolean} true, when it has dependent chunks + */ + hasChunkEntryDependentChunks(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + for (const chunkGroup of cgc.entryModules.values()) { + for (const c of chunkGroup.chunks) { + if (c !== chunk) { + return true; + } + } + } + return false; + } + + /** + * Gets chunk runtime modules iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable} iterable of modules (do not modify) + */ + getChunkRuntimeModulesIterable(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.runtimeModules; + } + + /** + * Gets chunk runtime modules in order. + * @param {Chunk} chunk the chunk + * @returns {RuntimeModule[]} array of modules in order of execution + */ + getChunkRuntimeModulesInOrder(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + const array = [...cgc.runtimeModules]; + array.sort( + concatComparators( + compareSelect( + (r) => /** @type {RuntimeModule} */ (r).stage, + compareIds + ), + compareModulesByIdentifier + ) + ); + return array; + } + + /** + * Gets chunk full hash modules iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable | undefined} iterable of modules (do not modify) + */ + getChunkFullHashModulesIterable(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.fullHashModules; + } + + /** + * Gets chunk full hash modules set. + * @param {Chunk} chunk the chunk + * @returns {ReadonlySet | undefined} set of modules (do not modify) + */ + getChunkFullHashModulesSet(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.fullHashModules; + } + + /** + * Gets chunk dependent hash modules iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable | undefined} iterable of modules (do not modify) + */ + getChunkDependentHashModulesIterable(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.dependentHashModules; + } + + /** + * Gets chunk entry modules with chunk group iterable. + * @param {Chunk} chunk the chunk + * @returns {Iterable} iterable of modules (do not modify) + */ + getChunkEntryModulesWithChunkGroupIterable(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.entryModules; + } + + /** + * Gets block chunk group. + * @param {AsyncDependenciesBlock} depBlock the async block + * @returns {ChunkGroup | undefined} the chunk group + */ + getBlockChunkGroup(depBlock) { + return this._blockChunkGroups.get(depBlock); + } + + /** + * Connects block and chunk group. + * @param {AsyncDependenciesBlock} depBlock the async block + * @param {ChunkGroup} chunkGroup the chunk group + * @returns {void} + */ + connectBlockAndChunkGroup(depBlock, chunkGroup) { + this._blockChunkGroups.set(depBlock, chunkGroup); + chunkGroup.addBlock(depBlock); + } + + /** + * Disconnects chunk group. + * @param {ChunkGroup} chunkGroup the chunk group + * @returns {void} + */ + disconnectChunkGroup(chunkGroup) { + for (const block of chunkGroup.blocksIterable) { + this._blockChunkGroups.delete(block); + } + // TODO refactor by moving blocks list into ChunkGraph + chunkGroup._blocks.clear(); + } + + /** + * Returns the id of the module. + * @param {Module} module the module + * @returns {ModuleId | null} the id of the module + */ + getModuleId(module) { + const cgm = this._getChunkGraphModule(module); + return cgm.id; + } + + /** + * Updates module id using the provided module. + * @param {Module} module the module + * @param {ModuleId} id the id of the module + * @returns {void} + */ + setModuleId(module, id) { + const cgm = this._getChunkGraphModule(module); + cgm.id = id; + } + + /** + * Returns the id of the runtime. + * @param {string} runtime runtime + * @returns {RuntimeId} the id of the runtime + */ + getRuntimeId(runtime) { + return /** @type {RuntimeId} */ (this._runtimeIds.get(runtime)); + } + + /** + * Updates runtime id using the provided runtime. + * @param {string} runtime runtime + * @param {RuntimeId} id the id of the runtime + * @returns {void} + */ + setRuntimeId(runtime, id) { + this._runtimeIds.set(runtime, id); + } + + /** + * Get module hash info. + * @template T + * @param {Module} module the module + * @param {RuntimeSpecMap} hashes hashes data + * @param {RuntimeSpec} runtime the runtime + * @returns {T} hash + */ + _getModuleHashInfo(module, hashes, runtime) { + if (!hashes) { + throw new Error( + `Module ${module.identifier()} has no hash info for runtime ${runtimeToString( + runtime + )} (hashes not set at all)` + ); + } else if (runtime === undefined) { + const hashInfoItems = new Set(hashes.values()); + if (hashInfoItems.size !== 1) { + throw new Error( + `No unique hash info entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from( + hashes.keys(), + (r) => runtimeToString(r) + ).join(", ")}). +Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").` + ); + } + return /** @type {T} */ (first(hashInfoItems)); + } else { + const hashInfo = hashes.get(runtime); + if (!hashInfo) { + throw new Error( + `Module ${module.identifier()} has no hash info for runtime ${runtimeToString( + runtime + )} (available runtimes ${Array.from( + hashes.keys(), + runtimeToString + ).join(", ")})` + ); + } + return hashInfo; + } + } + + /** + * Checks whether this chunk graph contains the module. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, if the module has hashes for this runtime + */ + hasModuleHashes(module, runtime) { + const cgm = this._getChunkGraphModule(module); + const hashes = /** @type {RuntimeSpecMap} */ (cgm.hashes); + return hashes && hashes.has(runtime); + } + + /** + * Returns hash. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @returns {string} hash + */ + getModuleHash(module, runtime) { + const cgm = this._getChunkGraphModule(module); + const hashes = /** @type {RuntimeSpecMap} */ (cgm.hashes); + return this._getModuleHashInfo(module, hashes, runtime).hash; + } + + /** + * Gets rendered module hash. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @returns {string} hash + */ + getRenderedModuleHash(module, runtime) { + const cgm = this._getChunkGraphModule(module); + const hashes = /** @type {RuntimeSpecMap} */ (cgm.hashes); + return this._getModuleHashInfo(module, hashes, runtime).renderedHash; + } + + /** + * Sets module hashes. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @param {string} hash the full hash + * @param {string} renderedHash the shortened hash for rendering + * @returns {void} + */ + setModuleHashes(module, runtime, hash, renderedHash) { + const cgm = this._getChunkGraphModule(module); + if (cgm.hashes === undefined) { + cgm.hashes = new RuntimeSpecMap(); + } + cgm.hashes.set(runtime, new ModuleHashInfo(hash, renderedHash)); + } + + /** + * Adds module runtime requirements. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @param {RuntimeRequirements} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false) + * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified + * @returns {void} + */ + addModuleRuntimeRequirements( + module, + runtime, + items, + transferOwnership = true + ) { + const cgm = this._getChunkGraphModule(module); + const runtimeRequirementsMap = cgm.runtimeRequirements; + if (runtimeRequirementsMap === undefined) { + /** @type {ChunkGraphRuntimeRequirements} */ + const map = new RuntimeSpecMap(); + // TODO avoid cloning item and track ownership instead + map.set(runtime, transferOwnership ? items : new Set(items)); + cgm.runtimeRequirements = map; + return; + } + runtimeRequirementsMap.update(runtime, (runtimeRequirements) => { + if (runtimeRequirements === undefined) { + return transferOwnership ? items : new Set(items); + } else if (!transferOwnership || runtimeRequirements.size >= items.size) { + for (const item of items) runtimeRequirements.add(item); + return runtimeRequirements; + } + + for (const item of runtimeRequirements) items.add(item); + return items; + }); + } + + /** + * Adds chunk runtime requirements. + * @param {Chunk} chunk the chunk + * @param {RuntimeRequirements} items runtime requirements to be added (ownership of this Set is given to ChunkGraph) + * @returns {void} + */ + addChunkRuntimeRequirements(chunk, items) { + const cgc = this._getChunkGraphChunk(chunk); + const runtimeRequirements = cgc.runtimeRequirements; + if (runtimeRequirements === undefined) { + cgc.runtimeRequirements = items; + } else if (runtimeRequirements.size >= items.size) { + for (const item of items) runtimeRequirements.add(item); + } else { + for (const item of runtimeRequirements) items.add(item); + cgc.runtimeRequirements = items; + } + } + + /** + * Adds tree runtime requirements. + * @param {Chunk} chunk the chunk + * @param {Iterable} items runtime requirements to be added + * @returns {void} + */ + addTreeRuntimeRequirements(chunk, items) { + const cgc = this._getChunkGraphChunk(chunk); + const runtimeRequirements = cgc.runtimeRequirementsInTree; + for (const item of items) runtimeRequirements.add(item); + } + + /** + * Gets module runtime requirements. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @returns {ReadOnlyRuntimeRequirements} runtime requirements + */ + getModuleRuntimeRequirements(module, runtime) { + const cgm = this._getChunkGraphModule(module); + const runtimeRequirements = + cgm.runtimeRequirements && cgm.runtimeRequirements.get(runtime); + return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements; + } + + /** + * Gets chunk runtime requirements. + * @param {Chunk} chunk the chunk + * @returns {ReadOnlyRuntimeRequirements} runtime requirements + */ + getChunkRuntimeRequirements(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + const runtimeRequirements = cgc.runtimeRequirements; + return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements; + } + + /** + * Gets module graph hash. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @param {boolean} withConnections include connections + * @returns {string} hash + */ + getModuleGraphHash(module, runtime, withConnections = true) { + const cgm = this._getChunkGraphModule(module); + return withConnections + ? this._getModuleGraphHashWithConnections(cgm, module, runtime) + : this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16); + } + + /** + * Gets module graph hash big int. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @param {boolean} withConnections include connections + * @returns {bigint} hash + */ + getModuleGraphHashBigInt(module, runtime, withConnections = true) { + const cgm = this._getChunkGraphModule(module); + return withConnections + ? BigInt( + `0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}` + ) + : this._getModuleGraphHashBigInt(cgm, module, runtime); + } + + /** + * Get module graph hash big int. + * @param {ChunkGraphModule} cgm the ChunkGraphModule + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @returns {bigint} hash as big int + */ + _getModuleGraphHashBigInt(cgm, module, runtime) { + if (cgm.graphHashes === undefined) { + cgm.graphHashes = new RuntimeSpecMap(); + } + const graphHash = cgm.graphHashes.provide(runtime, () => { + const hash = createHash(this._hashFunction); + hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`); + const sourceTypes = this._getOverwrittenModuleSourceTypes(module); + if (sourceTypes !== undefined) { + for (const type of sourceTypes) hash.update(type); + } + this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime); + return BigInt(`0x${hash.digest("hex")}`); + }); + return graphHash; + } + + /** + * Get module graph hash with connections. + * @param {ChunkGraphModule} cgm the ChunkGraphModule + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @returns {string} hash + */ + _getModuleGraphHashWithConnections(cgm, module, runtime) { + if (cgm.graphHashesWithConnections === undefined) { + cgm.graphHashesWithConnections = new RuntimeSpecMap(); + } + + /** + * Active state to string. + * @param {ConnectionState} state state + * @returns {"F" | "T" | "O"} result + */ + const activeStateToString = (state) => { + if (state === false) return "F"; + if (state === true) return "T"; + if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O"; + throw new Error("Not implemented active state"); + }; + const strict = module.buildMeta && module.buildMeta.strictHarmonyModule; + return cgm.graphHashesWithConnections.provide(runtime, () => { + const graphHash = this._getModuleGraphHashBigInt( + cgm, + module, + runtime + ).toString(16); + const connections = this.moduleGraph.getOutgoingConnections(module); + /** @type {Set} */ + const activeNamespaceModules = new Set(); + /** @type {Map>} */ + const connectedModules = new Map(); + /** + * Process connection. + * @param {ModuleGraphConnection} connection connection + * @param {string} stateInfo state info + */ + const processConnection = (connection, stateInfo) => { + const module = connection.module; + stateInfo += module.getExportsType(this.moduleGraph, strict); + // cspell:word Tnamespace + if (stateInfo === "Tnamespace") { + activeNamespaceModules.add(module); + } else { + const oldModule = connectedModules.get(stateInfo); + if (oldModule === undefined) { + connectedModules.set(stateInfo, module); + } else if (oldModule instanceof Set) { + oldModule.add(module); + } else if (oldModule !== module) { + connectedModules.set(stateInfo, new Set([oldModule, module])); + } + } + }; + if (runtime === undefined || typeof runtime === "string") { + for (const connection of connections) { + const state = connection.getActiveState(runtime); + if (state === false) continue; + processConnection(connection, state === true ? "T" : "O"); + } + } else { + // cspell:word Tnamespace + for (const connection of connections) { + /** @type {Set} */ + const states = new Set(); + let stateInfo = ""; + forEachRuntime( + runtime, + (runtime) => { + const state = connection.getActiveState(runtime); + states.add(state); + stateInfo += activeStateToString(state) + runtime; + }, + true + ); + if (states.size === 1) { + const state = first(states); + if (state === false) continue; + stateInfo = activeStateToString( + /** @type {ConnectionState} */ + (state) + ); + } + processConnection(connection, stateInfo); + } + } + // cspell:word Tnamespace + if (activeNamespaceModules.size === 0 && connectedModules.size === 0) { + return graphHash; + } + const connectedModulesInOrder = + connectedModules.size > 1 + ? [...connectedModules].sort(([a], [b]) => (a < b ? -1 : 1)) + : connectedModules; + const hash = createHash(this._hashFunction); + /** + * Adds module to hash. + * @param {Module} module module + */ + const addModuleToHash = (module) => { + hash.update( + this._getModuleGraphHashBigInt( + this._getChunkGraphModule(module), + module, + runtime + ).toString(16) + ); + }; + /** + * Adds modules to hash. + * @param {Set} modules modules + */ + const addModulesToHash = (modules) => { + let xor = ZERO_BIG_INT; + for (const m of modules) { + xor ^= this._getModuleGraphHashBigInt( + this._getChunkGraphModule(m), + m, + runtime + ); + } + hash.update(xor.toString(16)); + }; + if (activeNamespaceModules.size === 1) { + addModuleToHash( + /** @type {Module} */ (activeNamespaceModules.values().next().value) + ); + } else if (activeNamespaceModules.size > 1) { + addModulesToHash(activeNamespaceModules); + } + for (const [stateInfo, modules] of connectedModulesInOrder) { + hash.update(stateInfo); + if (modules instanceof Set) { + addModulesToHash(modules); + } else { + addModuleToHash(modules); + } + } + hash.update(graphHash); + return hash.digest("hex"); + }); + } + + /** + * Gets tree runtime requirements. + * @param {Chunk} chunk the chunk + * @returns {ReadOnlyRuntimeRequirements} runtime requirements + */ + getTreeRuntimeRequirements(chunk) { + const cgc = this._getChunkGraphChunk(chunk); + return cgc.runtimeRequirementsInTree; + } + + // TODO remove in webpack 6 + /** + * Gets chunk graph for module. + * @deprecated + * @param {Module} module the module + * @param {string} deprecateMessage message for the deprecation message + * @param {string} deprecationCode code for the deprecation + * @returns {ChunkGraph} the chunk graph + */ + static getChunkGraphForModule(module, deprecateMessage, deprecationCode) { + const fn = deprecateGetChunkGraphForModuleMap.get(deprecateMessage); + if (fn) return fn(module); + const newFn = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {Module} module the module + * @returns {ChunkGraph} the chunk graph + */ + (module) => { + const chunkGraph = chunkGraphForModuleMap.get(module); + if (!chunkGraph) { + throw new Error( + `${ + deprecateMessage + }: There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)` + ); + } + return chunkGraph; + }, + `${deprecateMessage}: Use new ChunkGraph API`, + deprecationCode + ); + deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn); + return newFn(module); + } + + // TODO remove in webpack 6 + // BACKWARD-COMPAT START + /** + * Sets chunk graph for module. + * @deprecated + * @param {Module} module the module + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {void} + */ + static setChunkGraphForModule(module, chunkGraph) { + chunkGraphForModuleMap.set(module, chunkGraph); + } + + /** + * Clear chunk graph for module. + * @deprecated + * @param {Module} module the module + * @returns {void} + */ + static clearChunkGraphForModule(module) { + chunkGraphForModuleMap.delete(module); + } + + /** + * Gets chunk graph for chunk. + * @deprecated + * @param {Chunk} chunk the chunk + * @param {string} deprecateMessage message for the deprecation message + * @param {string} deprecationCode code for the deprecation + * @returns {ChunkGraph} the chunk graph + */ + static getChunkGraphForChunk(chunk, deprecateMessage, deprecationCode) { + const fn = deprecateGetChunkGraphForChunkMap.get(deprecateMessage); + if (fn) return fn(chunk); + const newFn = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {Chunk} chunk the chunk + * @returns {ChunkGraph} the chunk graph + */ + (chunk) => { + const chunkGraph = chunkGraphForChunkMap.get(chunk); + if (!chunkGraph) { + throw new Error( + `${ + deprecateMessage + }There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)` + ); + } + return chunkGraph; + }, + `${deprecateMessage}: Use new ChunkGraph API`, + deprecationCode + ); + deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn); + return newFn(chunk); + } + + /** + * Sets chunk graph for chunk. + * @deprecated + * @param {Chunk} chunk the chunk + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {void} + */ + static setChunkGraphForChunk(chunk, chunkGraph) { + chunkGraphForChunkMap.set(chunk, chunkGraph); + } + + /** + * Clear chunk graph for chunk. + * @deprecated + * @param {Chunk} chunk the chunk + * @returns {void} + */ + static clearChunkGraphForChunk(chunk) { + chunkGraphForChunkMap.delete(chunk); + } + // BACKWARD-COMPAT END +} + +// TODO remove in webpack 6 +/** @type {WeakMap} */ +const chunkGraphForModuleMap = new WeakMap(); + +// TODO remove in webpack 6 +/** @type {WeakMap} */ +const chunkGraphForChunkMap = new WeakMap(); + +// TODO remove in webpack 6 +/** @type {Map ChunkGraph>} */ +const deprecateGetChunkGraphForModuleMap = new Map(); + +// TODO remove in webpack 6 +/** @type {Map ChunkGraph>} */ +const deprecateGetChunkGraphForChunkMap = new Map(); + +module.exports = ChunkGraph; Index: frontend/node_modules/webpack/lib/ChunkGroup.js =================================================================== --- frontend/node_modules/webpack/lib/ChunkGroup.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ChunkGroup.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,701 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const SortableSet = require("./util/SortableSet"); +const { + compareChunks, + compareIterables, + compareLocations +} = require("./util/comparators"); + +/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./Entrypoint")} Entrypoint */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ + +/** @typedef {{ module: Module | null, loc: DependencyLocation, request: string }} OriginRecord */ + +/** + * Describes the scheduling hints that can be attached to a chunk group. + * These values influence how child groups are ordered for preload/prefetch + * and how their fetch priority is exposed to runtime code. + * @typedef {object} RawChunkGroupOptions + * @property {number=} preloadOrder + * @property {number=} prefetchOrder + * @property {("low" | "high" | "auto")=} fetchPriority + */ + +/** @typedef {RawChunkGroupOptions & { name?: string | null }} ChunkGroupOptions */ + +let debugId = 5000; + +/** + * Materializes a sortable set as an array without changing its current order. + * Used with `SortableSet` caches that expect a stable array result. + * @template T + * @param {SortableSet} set set to convert to array. + * @returns {T[]} the array format of existing set + */ +const getArray = (set) => [...set]; + +/** + * A convenience method used to sort chunks based on their id's + * @param {ChunkGroup} a first sorting comparator + * @param {ChunkGroup} b second sorting comparator + * @returns {1 | 0 | -1} a sorting index to determine order + */ +const sortById = (a, b) => { + if (a.id < b.id) return -1; + if (b.id < a.id) return 1; + return 0; +}; + +/** + * Orders origin records by referencing module and then by source location. + * This keeps origin metadata deterministic for hashing and diagnostics. + * @param {OriginRecord} a the first comparator in sort + * @param {OriginRecord} b the second comparator in sort + * @returns {1 | -1 | 0} returns sorting order as index + */ +const sortOrigin = (a, b) => { + const aIdent = a.module ? a.module.identifier() : ""; + const bIdent = b.module ? b.module.identifier() : ""; + if (aIdent < bIdent) return -1; + if (aIdent > bIdent) return 1; + return compareLocations(a.loc, b.loc); +}; + +/** + * Represents a connected group of chunks along with the parent/child + * relationships, async blocks, and traversal metadata webpack tracks for it. + */ +class ChunkGroup { + /** + * Creates a chunk group and initializes the relationship sets and ordering + * metadata used while building and optimizing the chunk graph. + * @param {string | ChunkGroupOptions=} options chunk group options passed to chunkGroup + */ + constructor(options) { + if (typeof options === "string") { + options = { name: options }; + } else if (!options) { + options = { name: undefined }; + } + /** @type {number} */ + this.groupDebugId = debugId++; + /** @type {ChunkGroupOptions} */ + this.options = options; + /** @type {SortableSet} */ + this._children = new SortableSet(undefined, sortById); + /** @type {SortableSet} */ + this._parents = new SortableSet(undefined, sortById); + /** @type {SortableSet} */ + this._asyncEntrypoints = new SortableSet(undefined, sortById); + /** @type {SortableSet} */ + this._blocks = new SortableSet(); + /** @type {Chunk[]} */ + this.chunks = []; + /** @type {OriginRecord[]} */ + this.origins = []; + + /** @typedef {Map} OrderIndices */ + + /** Indices in top-down order */ + /** + * @private + * @type {OrderIndices} + */ + this._modulePreOrderIndices = new Map(); + /** Indices in bottom-up order */ + /** + * @private + * @type {OrderIndices} + */ + this._modulePostOrderIndices = new Map(); + /** @type {number | undefined} */ + this.index = undefined; + } + + /** + * Merges additional options into the chunk group. + * Order-based options are combined by taking the higher priority, while + * unsupported conflicts surface as an explicit error. + * @param {ChunkGroupOptions} options the chunkGroup options passed to addOptions + * @returns {void} + */ + addOptions(options) { + for (const key of /** @type {(keyof ChunkGroupOptions)[]} */ ( + Object.keys(options) + )) { + if (this.options[key] === undefined) { + /** @type {ChunkGroupOptions[keyof ChunkGroupOptions]} */ + (this.options[key]) = options[key]; + } else if (this.options[key] !== options[key]) { + if (key.endsWith("Order")) { + const orderKey = + /** @type {Exclude} */ + (key); + + this.options[orderKey] = Math.max( + /** @type {number} */ + (this.options[orderKey]), + /** @type {number} */ + (options[orderKey]) + ); + } else { + throw new Error( + `ChunkGroup.addOptions: No option merge strategy for ${key}` + ); + } + } + } + } + + /** + * Returns the configured name of the chunk group, if one was assigned. + * @returns {ChunkGroupOptions["name"]} returns the ChunkGroup name + */ + get name() { + return this.options.name; + } + + /** + * Updates the configured name of the chunk group. + * @param {string | undefined} value the new name for ChunkGroup + * @returns {void} + */ + set name(value) { + this.options.name = value; + } + + /* istanbul ignore next */ + /** + * Returns a debug-only identifier derived from the group's member chunk + * debug ids. This is primarily useful in diagnostics and assertions. + * @returns {string} a unique concatenation of chunk debugId's + */ + get debugId() { + return Array.from(this.chunks, (x) => x.debugId).join("+"); + } + + /** + * Returns an identifier derived from the ids of the chunks currently in + * the group. + * @returns {string} a unique concatenation of chunk ids + */ + get id() { + return Array.from(this.chunks, (x) => x.id).join("+"); + } + + /** + * Moves a chunk to the front of the group or inserts it when it is not + * already present. + * @param {Chunk} chunk chunk being unshifted + * @returns {boolean} returns true if attempted chunk shift is accepted + */ + unshiftChunk(chunk) { + const oldIdx = this.chunks.indexOf(chunk); + if (oldIdx > 0) { + this.chunks.splice(oldIdx, 1); + this.chunks.unshift(chunk); + } else if (oldIdx < 0) { + this.chunks.unshift(chunk); + return true; + } + return false; + } + + /** + * Inserts a chunk directly before another chunk that already belongs to the + * group, preserving the rest of the ordering. + * @param {Chunk} chunk Chunk being inserted + * @param {Chunk} before Placeholder/target chunk marking new chunk insertion point + * @returns {boolean} return true if insertion was successful + */ + insertChunk(chunk, before) { + const oldIdx = this.chunks.indexOf(chunk); + const idx = this.chunks.indexOf(before); + if (idx < 0) { + throw new Error("before chunk not found"); + } + if (oldIdx >= 0 && oldIdx > idx) { + this.chunks.splice(oldIdx, 1); + this.chunks.splice(idx, 0, chunk); + } else if (oldIdx < 0) { + this.chunks.splice(idx, 0, chunk); + return true; + } + return false; + } + + /** + * Appends a chunk to the group when it is not already a member. + * @param {Chunk} chunk chunk being pushed into ChunkGroupS + * @returns {boolean} returns true if chunk addition was successful. + */ + pushChunk(chunk) { + const oldIdx = this.chunks.indexOf(chunk); + if (oldIdx >= 0) { + return false; + } + this.chunks.push(chunk); + return true; + } + + /** + * Replaces one member chunk with another while preserving the group's + * ordering and avoiding duplicates. + * @param {Chunk} oldChunk chunk to be replaced + * @param {Chunk} newChunk New chunk that will be replaced with + * @returns {boolean | undefined} returns true if the replacement was successful + */ + replaceChunk(oldChunk, newChunk) { + const oldIdx = this.chunks.indexOf(oldChunk); + if (oldIdx < 0) return false; + const newIdx = this.chunks.indexOf(newChunk); + if (newIdx < 0) { + this.chunks[oldIdx] = newChunk; + return true; + } + if (newIdx < oldIdx) { + this.chunks.splice(oldIdx, 1); + return true; + } else if (newIdx !== oldIdx) { + this.chunks[oldIdx] = newChunk; + this.chunks.splice(newIdx, 1); + return true; + } + } + + /** + * Removes a chunk from this group. + * @param {Chunk} chunk chunk to remove + * @returns {boolean} returns true if chunk was removed + */ + removeChunk(chunk) { + const idx = this.chunks.indexOf(chunk); + if (idx >= 0) { + this.chunks.splice(idx, 1); + return true; + } + return false; + } + + /** + * Indicates whether this chunk group is loaded as part of the initial page + * load instead of being created lazily. + * @returns {boolean} true, when this chunk group will be loaded on initial page load + */ + isInitial() { + return false; + } + + /** + * Adds a child chunk group to the current group. + * @param {ChunkGroup} group chunk group to add + * @returns {boolean} returns true if chunk group was added + */ + addChild(group) { + const size = this._children.size; + this._children.add(group); + return size !== this._children.size; + } + + /** + * Returns the child chunk groups reachable from this group. + * @returns {ChunkGroup[]} returns the children of this group + */ + getChildren() { + return this._children.getFromCache(getArray); + } + + getNumberOfChildren() { + return this._children.size; + } + + get childrenIterable() { + return this._children; + } + + /** + * Removes a child chunk group and clears the corresponding parent link on + * the removed child. + * @param {ChunkGroup} group the chunk group to remove + * @returns {boolean} returns true if the chunk group was removed + */ + removeChild(group) { + if (!this._children.has(group)) { + return false; + } + + this._children.delete(group); + group.removeParent(this); + return true; + } + + /** + * Records a parent chunk group relationship. + * @param {ChunkGroup} parentChunk the parent group to be added into + * @returns {boolean} returns true if this chunk group was added to the parent group + */ + addParent(parentChunk) { + if (!this._parents.has(parentChunk)) { + this._parents.add(parentChunk); + return true; + } + return false; + } + + /** + * Returns the parent chunk groups that can lead to this group. + * @returns {ChunkGroup[]} returns the parents of this group + */ + getParents() { + return this._parents.getFromCache(getArray); + } + + getNumberOfParents() { + return this._parents.size; + } + + /** + * Checks whether the provided group is registered as a parent. + * @param {ChunkGroup} parent the parent group + * @returns {boolean} returns true if the parent group contains this group + */ + hasParent(parent) { + return this._parents.has(parent); + } + + get parentsIterable() { + return this._parents; + } + + /** + * Removes a parent chunk group and clears the reverse child relationship. + * @param {ChunkGroup} chunkGroup the parent group + * @returns {boolean} returns true if this group has been removed from the parent + */ + removeParent(chunkGroup) { + if (this._parents.delete(chunkGroup)) { + chunkGroup.removeChild(this); + return true; + } + return false; + } + + /** + * Registers an async entrypoint that is rooted in this chunk group. + * @param {Entrypoint} entrypoint entrypoint to add + * @returns {boolean} returns true if entrypoint was added + */ + addAsyncEntrypoint(entrypoint) { + const size = this._asyncEntrypoints.size; + this._asyncEntrypoints.add(entrypoint); + return size !== this._asyncEntrypoints.size; + } + + get asyncEntrypointsIterable() { + return this._asyncEntrypoints; + } + + /** + * Returns the async dependency blocks that create or reference this group. + * @returns {AsyncDependenciesBlock[]} an array containing the blocks + */ + getBlocks() { + return this._blocks.getFromCache(getArray); + } + + getNumberOfBlocks() { + return this._blocks.size; + } + + /** + * Checks whether an async dependency block is associated with this group. + * @param {AsyncDependenciesBlock} block block + * @returns {boolean} true, if block exists + */ + hasBlock(block) { + return this._blocks.has(block); + } + + /** + * Exposes the group's async dependency blocks as an iterable. + * @returns {Iterable} blocks + */ + get blocksIterable() { + return this._blocks; + } + + /** + * Associates an async dependency block with this chunk group. + * @param {AsyncDependenciesBlock} block a block + * @returns {boolean} false, if block was already added + */ + addBlock(block) { + if (!this._blocks.has(block)) { + this._blocks.add(block); + return true; + } + return false; + } + + /** + * Records where this chunk group originated from in user code. + * The origin is used for diagnostics, ordering, and reporting. + * @param {Module | null} module origin module + * @param {DependencyLocation} loc location of the reference in the origin module + * @param {string} request request name of the reference + * @returns {void} + */ + addOrigin(module, loc, request) { + this.origins.push({ + module, + loc, + request + }); + } + + /** + * Collects the emitted files produced by every chunk in the group. + * @returns {string[]} the files contained this chunk group + */ + getFiles() { + /** @type {Set} */ + const files = new Set(); + + for (const chunk of this.chunks) { + for (const file of chunk.files) { + files.add(file); + } + } + + return [...files]; + } + + /** + * Disconnects this group from its parents, children, and chunks. + * Child groups are reconnected to this group's parents so the surrounding + * graph remains intact after removal. + * @returns {void} + */ + remove() { + // cleanup parents + for (const parentChunkGroup of this._parents) { + // remove this chunk from its parents + parentChunkGroup._children.delete(this); + + // cleanup "sub chunks" + for (const chunkGroup of this._children) { + /** + * remove this chunk as "intermediary" and connect + * it "sub chunks" and parents directly + */ + // add parent to each "sub chunk" + chunkGroup.addParent(parentChunkGroup); + // add "sub chunk" to parent + parentChunkGroup.addChild(chunkGroup); + } + } + + /** + * we need to iterate again over the children + * to remove this from the child's parents. + * This can not be done in the above loop + * as it is not guaranteed that `this._parents` contains anything. + */ + for (const chunkGroup of this._children) { + // remove this as parent of every "sub chunk" + chunkGroup._parents.delete(this); + } + + // remove chunks + for (const chunk of this.chunks) { + chunk.removeGroup(this); + } + } + + sortItems() { + this.origins.sort(sortOrigin); + } + + /** + * Sorting predicate which allows current ChunkGroup to be compared against another. + * Sorting values are based off of number of chunks in ChunkGroup. + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {ChunkGroup} otherGroup the chunkGroup to compare this against + * @returns {-1 | 0 | 1} sort position for comparison + */ + compareTo(chunkGraph, otherGroup) { + if (this.chunks.length > otherGroup.chunks.length) return -1; + if (this.chunks.length < otherGroup.chunks.length) return 1; + return compareIterables(compareChunks(chunkGraph))( + this.chunks, + otherGroup.chunks + ); + } + + /** + * Aggregates per-block `*Order` options for the blocks that bridge this + * chunk group to the given child chunk group. `*Order` options are tied to + * the originating `import()` call and must not be sourced from the child's + * shared options, otherwise a webpackPrefetch/Preload directive from one + * parent would leak into other parents that share the child by name. + * @param {ChunkGroup} childGroup the child chunk group + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {Record} merged `*Order` options for the edge from this group to `childGroup` + */ + getChildOrderOptions(childGroup, chunkGraph) { + /** @type {Record} */ + const result = Object.create(null); + let bridged = false; + for (const block of childGroup.blocksIterable) { + const rootModule = /** @type {Module} */ (block.getRootBlock()); + if (!chunkGraph.isModuleInChunkGroup(rootModule, this)) continue; + bridged = true; + const opts = block.groupOptions; + if (!opts) continue; + for (const key of Object.keys(opts)) { + if (!key.endsWith("Order")) continue; + const value = + /** @type {number} */ + (opts[/** @type {keyof ChunkGroupOptions} */ (key)]); + if (typeof value !== "number") continue; + if (result[key] === undefined || value > result[key]) { + result[key] = value; + } + } + } + // Fall back to the child's own options only when no block bridges + // this edge (e.g. a chunk group created by APIs that don't go through + // an AsyncDependenciesBlock). Otherwise we'd reintroduce the leak. + if (!bridged) { + for (const key of Object.keys(childGroup.options)) { + if (!key.endsWith("Order")) continue; + const value = + childGroup.options[/** @type {keyof ChunkGroupOptions} */ (key)]; + if (typeof value === "number") { + result[key] = value; + } + } + } + return result; + } + + /** + * Groups child chunk groups by their `*Order` options and sorts each group + * by descending order and deterministic chunk-group comparison. + * @param {ModuleGraph} moduleGraph the module graph + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {Record} mapping from children type to ordered list of ChunkGroups + */ + getChildrenByOrders(moduleGraph, chunkGraph) { + /** @type {Map} */ + const lists = new Map(); + for (const childGroup of this._children) { + const edgeOptions = this.getChildOrderOptions(childGroup, chunkGraph); + for (const key of Object.keys(edgeOptions)) { + const name = key.slice(0, key.length - "Order".length); + let list = lists.get(name); + if (list === undefined) { + lists.set(name, (list = [])); + } + list.push({ + order: edgeOptions[key], + group: childGroup + }); + } + } + /** @type {Record} */ + const result = Object.create(null); + for (const [name, list] of lists) { + list.sort((a, b) => { + const cmp = b.order - a.order; + if (cmp !== 0) return cmp; + return a.group.compareTo(chunkGraph, b.group); + }); + result[name] = list.map((i) => i.group); + } + return result; + } + + /** + * Stores the module's top-down traversal index within this group. + * @param {Module} module module for which the index should be set + * @param {number} index the index of the module + * @returns {void} + */ + setModulePreOrderIndex(module, index) { + this._modulePreOrderIndices.set(module, index); + } + + /** + * Returns the module's top-down traversal index within this group. + * @param {Module} module the module + * @returns {number | undefined} index + */ + getModulePreOrderIndex(module) { + return this._modulePreOrderIndices.get(module); + } + + /** + * Stores the module's bottom-up traversal index within this group. + * @param {Module} module module for which the index should be set + * @param {number} index the index of the module + * @returns {void} + */ + setModulePostOrderIndex(module, index) { + this._modulePostOrderIndices.set(module, index); + } + + /** + * Returns the module's bottom-up traversal index within this group. + * @param {Module} module the module + * @returns {number | undefined} index + */ + getModulePostOrderIndex(module) { + return this._modulePostOrderIndices.get(module); + } + + /* istanbul ignore next */ + checkConstraints() { + const chunk = this; + for (const child of chunk._children) { + if (!child._parents.has(chunk)) { + throw new Error( + `checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}` + ); + } + } + for (const parentChunk of chunk._parents) { + if (!parentChunk._children.has(chunk)) { + throw new Error( + `checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}` + ); + } + } + } +} + +ChunkGroup.prototype.getModuleIndex = util.deprecate( + ChunkGroup.prototype.getModulePreOrderIndex, + "ChunkGroup.getModuleIndex was renamed to getModulePreOrderIndex", + "DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX" +); + +ChunkGroup.prototype.getModuleIndex2 = util.deprecate( + ChunkGroup.prototype.getModulePostOrderIndex, + "ChunkGroup.getModuleIndex2 was renamed to getModulePostOrderIndex", + "DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX_2" +); + +module.exports = ChunkGroup; Index: frontend/node_modules/webpack/lib/ChunkTemplate.js =================================================================== --- frontend/node_modules/webpack/lib/ChunkTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ChunkTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,190 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const memoize = require("./util/memoize"); + +/** @typedef {import("tapable").Tap} Tap */ +/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Compilation").ChunkHashContext} ChunkHashContext */ +/** @typedef {import("./Compilation").Hash} Hash */ +/** @typedef {import("./Compilation").RenderManifestEntry} RenderManifestEntry */ +/** @typedef {import("./Compilation").RenderManifestOptions} RenderManifestOptions */ +/** @typedef {import("./Compilation").Source} Source */ +/** @typedef {import("./ModuleTemplate")} ModuleTemplate */ +/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */ +/** + * Defines the if set type used by this module. + * @template T + * @typedef {import("tapable").IfSet} IfSet + */ + +const getJavascriptModulesPlugin = memoize(() => + require("./javascript/JavascriptModulesPlugin") +); + +// TODO webpack 6 remove this class +class ChunkTemplate { + /** + * Creates an instance of ChunkTemplate. + * @param {OutputOptions} outputOptions output options + * @param {Compilation} compilation the compilation + */ + constructor(outputOptions, compilation) { + this._outputOptions = outputOptions || {}; + this.hooks = Object.freeze({ + renderManifest: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(renderManifestEntries: RenderManifestEntry[], renderManifestOptions: RenderManifestOptions) => RenderManifestEntry[]} fn function + */ + (options, fn) => { + compilation.hooks.renderManifest.tap( + options, + (entries, options) => { + if (options.chunk.hasRuntime()) return entries; + return fn(entries, options); + } + ); + }, + "ChunkTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_MANIFEST" + ) + }, + modules: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .renderChunk.tap(options, (source, renderContext) => + fn( + source, + compilation.moduleTemplates.javascript, + renderContext + ) + ); + }, + "ChunkTemplate.hooks.modules is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_MODULES" + ) + }, + render: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .renderChunk.tap(options, (source, renderContext) => + fn( + source, + compilation.moduleTemplates.javascript, + renderContext + ) + ); + }, + "ChunkTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_RENDER" + ) + }, + renderWithEntry: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, chunk: Chunk) => Source} fn function + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .render.tap(options, (source, renderContext) => { + if ( + renderContext.chunkGraph.getNumberOfEntryModules( + renderContext.chunk + ) === 0 || + renderContext.chunk.hasRuntime() + ) { + return source; + } + return fn(source, renderContext.chunk); + }); + }, + "ChunkTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_WITH_ENTRY" + ) + }, + hash: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(hash: Hash) => void} fn function + */ + (options, fn) => { + compilation.hooks.fullHash.tap(options, fn); + }, + "ChunkTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_HASH" + ) + }, + hashForChunk: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(hash: Hash, chunk: Chunk, chunkHashContext: ChunkHashContext) => void} fn function + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .chunkHash.tap(options, (chunk, hash, context) => { + if (chunk.hasRuntime()) return; + fn(hash, chunk, context); + }); + }, + "ChunkTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_HASH_FOR_CHUNK" + ) + } + }); + } +} + +Object.defineProperty(ChunkTemplate.prototype, "outputOptions", { + get: util.deprecate( + /** + * Returns output options. + * @this {ChunkTemplate} + * @returns {OutputOptions} output options + */ + function outputOptions() { + return this._outputOptions; + }, + "ChunkTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS" + ) +}); + +module.exports = ChunkTemplate; Index: frontend/node_modules/webpack/lib/CleanPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/CleanPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/CleanPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,511 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sergey Melyukov @smelukov +*/ + +"use strict"; + +const path = require("path"); +const asyncLib = require("neo-async"); +const { SyncBailHook } = require("tapable"); +const Compilation = require("./Compilation"); +const { join } = require("./util/fs"); +const processAsyncTree = require("./util/processAsyncTree"); + +/** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./logging/Logger").Logger} Logger */ +/** @typedef {import("./util/fs").IStats} IStats */ +/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */ +/** @typedef {import("./util/fs").StatsCallback} StatsCallback */ + +/** @typedef {Map} Assets */ + +/** + * Defines the clean plugin compilation hooks type used by this module. + * @typedef {object} CleanPluginCompilationHooks + * @property {SyncBailHook<[string], boolean | void>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config + */ + +/** + * Defines the keep fn callback. + * @callback KeepFn + * @param {string} path path + * @returns {boolean | undefined} true, if the path should be kept + */ + +const _10sec = 10 * 1000; + +/** + * merge assets map 2 into map 1 + * @param {Assets} as1 assets + * @param {Assets} as2 assets + * @returns {void} + */ +const mergeAssets = (as1, as2) => { + for (const [key, value1] of as2) { + const value2 = as1.get(key); + if (!value2 || value1 > value2) as1.set(key, value1); + } +}; + +/** @typedef {Map} CurrentAssets */ + +/** + * Returns set of directory paths. + * @param {CurrentAssets} assets current assets + * @returns {Set} Set of directory paths + */ +function getDirectories(assets) { + /** @type {Set} */ + const directories = new Set(); + /** + * Adds the provided filename to this object. + * @param {string} filename asset filename + */ + const addDirectory = (filename) => { + directories.add(path.dirname(filename)); + }; + + // get directories of assets + for (const [asset] of assets) { + addDirectory(asset); + } + // and all parent directories + for (const directory of directories) { + addDirectory(directory); + } + return directories; +} + +/** @typedef {Set} Diff */ + +/** + * Returns diff to fs. + * @param {OutputFileSystem} fs filesystem + * @param {string} outputPath output path + * @param {CurrentAssets} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator) + * @param {(err?: Error | null, set?: Diff) => void} callback returns the filenames of the assets that shouldn't be there + * @returns {void} + */ +const getDiffToFs = (fs, outputPath, currentAssets, callback) => { + const directories = getDirectories(currentAssets); + /** @type {Diff} */ + const diff = new Set(); + asyncLib.forEachLimit( + directories, + 10, + (directory, callback) => { + /** @type {NonNullable} */ + (fs.readdir)(join(fs, outputPath, directory), (err, entries) => { + if (err) { + if (err.code === "ENOENT") return callback(); + if (err.code === "ENOTDIR") { + diff.add(directory); + return callback(); + } + return callback(err); + } + for (const entry of /** @type {string[]} */ (entries)) { + const file = entry; + // Since path.normalize("./file") === path.normalize("file"), + // return file directly when directory === "." + const filename = + directory && directory !== "." ? `${directory}/${file}` : file; + if (!directories.has(filename) && !currentAssets.has(filename)) { + diff.add(filename); + } + } + callback(); + }); + }, + (err) => { + if (err) return callback(err); + + callback(null, diff); + } + ); +}; + +/** + * Gets diff to old assets. + * @param {Assets} currentAssets assets list + * @param {Assets} oldAssets old assets list + * @returns {Diff} diff + */ +const getDiffToOldAssets = (currentAssets, oldAssets) => { + /** @type {Diff} */ + const diff = new Set(); + const now = Date.now(); + for (const [asset, ts] of oldAssets) { + if (ts >= now) continue; + if (!currentAssets.has(asset)) diff.add(asset); + } + return diff; +}; + +/** + * Processes the provided f. + * @param {OutputFileSystem} fs filesystem + * @param {string} filename path to file + * @param {StatsCallback} callback callback for provided filename + * @returns {void} + */ +const doStat = (fs, filename, callback) => { + if ("lstat" in fs) { + /** @type {NonNullable} */ + (fs.lstat)(filename, callback); + } else { + fs.stat(filename, callback); + } +}; + +/** + * Processes the provided f. + * @param {OutputFileSystem} fs filesystem + * @param {string} outputPath output path + * @param {boolean} dry only log instead of fs modification + * @param {Logger} logger logger + * @param {Diff} diff filenames of the assets that shouldn't be there + * @param {KeepFn} isKept check if the entry is ignored + * @param {(err?: Error, assets?: Assets) => void} callback callback + * @returns {void} + */ +const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => { + /** + * Processes the provided msg. + * @param {string} msg message + */ + const log = (msg) => { + if (dry) { + logger.info(msg); + } else { + logger.log(msg); + } + }; + /** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */ + /** @type {Job[]} */ + const jobs = Array.from(diff.keys(), (filename) => ({ + type: "check", + filename, + parent: undefined + })); + /** @type {Assets} */ + const keptAssets = new Map(); + processAsyncTree( + jobs, + 10, + ({ type, filename, parent }, push, callback) => { + const path = join(fs, outputPath, filename); + /** + * Describes how this handle error operation behaves. + * @param {Error & { code?: string }} err error + * @returns {void} + */ + const handleError = (err) => { + const isAlreadyRemoved = () => + new Promise((resolve) => { + if (err.code === "ENOENT") { + resolve(true); + } else if (err.code === "EPERM") { + // https://github.com/isaacs/rimraf/blob/main/src/fix-eperm.ts#L37 + // fs.existsSync(path) === false https://github.com/webpack/webpack/actions/runs/15493412975/job/43624272783?pr=19586 + doStat(fs, path, (err) => { + if (err) { + resolve(err.code === "ENOENT"); + } else { + resolve(false); + } + }); + } else { + resolve(false); + } + }); + + isAlreadyRemoved().then((isRemoved) => { + if (isRemoved) { + log(`${filename} was removed during cleaning by something else`); + handleParent(); + return callback(); + } + return callback(err); + }); + }; + const handleParent = () => { + if (parent && --parent.remaining === 0) push(parent.job); + }; + switch (type) { + case "check": + if (isKept(filename)) { + keptAssets.set(filename, 0); + // do not decrement parent entry as we don't want to delete the parent + log(`${filename} will be kept`); + return process.nextTick(callback); + } + doStat(fs, path, (err, stats) => { + if (err) return handleError(err); + if (!(/** @type {IStats} */ (stats).isDirectory())) { + push({ + type: "unlink", + filename, + parent + }); + return callback(); + } + + /** @type {NonNullable} */ + (fs.readdir)(path, (err, _entries) => { + if (err) return handleError(err); + /** @type {Job} */ + const deleteJob = { + type: "rmdir", + filename, + parent + }; + const entries = /** @type {string[]} */ (_entries); + if (entries.length === 0) { + push(deleteJob); + } else { + const parentToken = { + remaining: entries.length, + job: deleteJob + }; + for (const entry of entries) { + const file = /** @type {string} */ (entry); + if (file.startsWith(".")) { + log( + `${filename} will be kept (dot-files will never be removed)` + ); + continue; + } + push({ + type: "check", + filename: `${filename}/${file}`, + parent: parentToken + }); + } + } + return callback(); + }); + }); + break; + case "rmdir": + log(`${filename} will be removed`); + if (dry) { + handleParent(); + return process.nextTick(callback); + } + if (!fs.rmdir) { + logger.warn( + `${filename} can't be removed because output file system doesn't support removing directories (rmdir)` + ); + return process.nextTick(callback); + } + fs.rmdir(path, (err) => { + if (err) return handleError(err); + handleParent(); + callback(); + }); + break; + case "unlink": + log(`${filename} will be removed`); + if (dry) { + handleParent(); + return process.nextTick(callback); + } + if (!fs.unlink) { + logger.warn( + `${filename} can't be removed because output file system doesn't support removing files (rmdir)` + ); + return process.nextTick(callback); + } + fs.unlink(path, (err) => { + if (err) return handleError(err); + handleParent(); + callback(); + }); + break; + } + }, + (err) => { + if (err) return callback(err); + callback(undefined, keptAssets); + } + ); +}; + +/** @type {WeakMap} */ +const compilationHooksMap = new WeakMap(); + +const PLUGIN_NAME = "CleanPlugin"; + +class CleanPlugin { + /** + * Returns the attached hooks. + * @param {Compilation} compilation the compilation + * @returns {CleanPluginCompilationHooks} the attached hooks + */ + static getCompilationHooks(compilation) { + if (!(compilation instanceof Compilation)) { + throw new TypeError( + "The 'compilation' argument must be an instance of Compilation" + ); + } + let hooks = compilationHooksMap.get(compilation); + if (hooks === undefined) { + hooks = { + keep: new SyncBailHook(["ignore"]) + }; + compilationHooksMap.set(compilation, hooks); + } + return hooks; + } + + /** @param {CleanOptions} options options */ + constructor(options = {}) { + /** @type {CleanOptions} */ + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => { + const { definitions } = require("../schemas/WebpackOptions.json"); + + return { + definitions, + oneOf: [{ $ref: "#/definitions/CleanOptions" }] + }; + }, + this.options, + { + name: "Clean Plugin", + baseDataPath: "options" + } + ); + }); + + const { keep } = this.options; + + /** @type {boolean} */ + const dry = this.options.dry || false; + /** @type {KeepFn} */ + const keepFn = + typeof keep === "function" + ? keep + : typeof keep === "string" + ? (path) => path.startsWith(keep) + : typeof keep === "object" && keep.test + ? (path) => keep.test(path) + : () => false; + + // We assume that no external modification happens while the compiler is active + // So we can store the old assets and only diff to them to avoid fs access on + // incremental builds + /** @type {undefined | Assets} */ + let oldAssets; + + compiler.hooks.emit.tapAsync( + { + name: PLUGIN_NAME, + stage: 100 + }, + (compilation, callback) => { + const hooks = CleanPlugin.getCompilationHooks(compilation); + const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`); + const fs = /** @type {OutputFileSystem} */ (compiler.outputFileSystem); + + if (!fs.readdir) { + return callback( + new Error( + `${PLUGIN_NAME}: Output filesystem doesn't support listing directories (readdir)` + ) + ); + } + + /** @type {Assets} */ + const currentAssets = new Map(); + const now = Date.now(); + for (const asset of Object.keys(compilation.assets)) { + if (/^[a-z]:\\|^\/|^\\\\/i.test(asset)) continue; + /** @type {string} */ + let normalizedAsset; + let newNormalizedAsset = asset.replace(/\\/g, "/"); + do { + normalizedAsset = newNormalizedAsset; + newNormalizedAsset = normalizedAsset.replace( + /(^|\/)(?!\.\.)[^/]+\/\.\.\//g, + "$1" + ); + } while (newNormalizedAsset !== normalizedAsset); + if (normalizedAsset.startsWith("../")) continue; + const assetInfo = compilation.assetsInfo.get(asset); + if (assetInfo && assetInfo.hotModuleReplacement) { + currentAssets.set(normalizedAsset, now + _10sec); + } else { + currentAssets.set(normalizedAsset, 0); + } + } + + const outputPath = compilation.getPath(compiler.outputPath, {}); + + /** + * Checks whether this clean plugin is kept. + * @param {string} path path + * @returns {boolean | undefined} true, if needs to be kept + */ + const isKept = (path) => { + const result = hooks.keep.call(path); + if (result !== undefined) return result; + return keepFn(path); + }; + + /** + * Processes the provided err. + * @param {(Error | null)=} err err + * @param {Diff=} diff diff + */ + const diffCallback = (err, diff) => { + if (err) { + oldAssets = undefined; + callback(err); + return; + } + applyDiff( + fs, + outputPath, + dry, + logger, + /** @type {Diff} */ (diff), + isKept, + (err, keptAssets) => { + if (err) { + oldAssets = undefined; + } else { + if (oldAssets) mergeAssets(currentAssets, oldAssets); + oldAssets = currentAssets; + if (keptAssets) mergeAssets(oldAssets, keptAssets); + } + callback(err); + } + ); + }; + + if (oldAssets) { + diffCallback(null, getDiffToOldAssets(currentAssets, oldAssets)); + } else { + getDiffToFs(fs, outputPath, currentAssets, diffCallback); + } + } + ); + } +} + +module.exports = CleanPlugin; +module.exports._getDirectories = getDirectories; Index: frontend/node_modules/webpack/lib/CodeGenerationResults.js =================================================================== --- frontend/node_modules/webpack/lib/CodeGenerationResults.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/CodeGenerationResults.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,186 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { DEFAULTS } = require("./config/defaults"); +const { getOrInsert } = require("./util/MapHelpers"); +const { first } = require("./util/SetHelpers"); +const createHash = require("./util/createHash"); +const { RuntimeSpecMap, runtimeToString } = require("./util/runtime"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").SourceType} SourceType */ +/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */ +/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */ +/** @typedef {import("./util/Hash").HashFunction} HashFunction */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** + * Stores code generation results keyed by module and runtime so later stages + * can retrieve emitted sources, metadata, and derived hashes. + */ +class CodeGenerationResults { + /** + * Initializes an empty result store and remembers which hash function should + * be used when a result hash needs to be derived lazily. + * @param {HashFunction} hashFunction the hash function to use + */ + constructor(hashFunction = DEFAULTS.HASH_FUNCTION) { + /** @type {Map>} */ + this.map = new Map(); + /** @type {HashFunction} */ + this._hashFunction = hashFunction; + } + + /** + * Returns the code generation result for a module/runtime pair, rejecting + * ambiguous lookups where no unique runtime-independent result exists. + * @param {Module} module the module + * @param {RuntimeSpec} runtime runtime(s) + * @returns {CodeGenerationResult} the CodeGenerationResult + */ + get(module, runtime) { + const entry = this.map.get(module); + if (entry === undefined) { + throw new Error( + `No code generation entry for ${module.identifier()} (existing entries: ${Array.from( + this.map.keys(), + (m) => m.identifier() + ).join(", ")})` + ); + } + if (runtime === undefined) { + if (entry.size > 1) { + const results = new Set(entry.values()); + if (results.size !== 1) { + throw new Error( + `No unique code generation entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from( + entry.keys(), + (r) => runtimeToString(r) + ).join(", ")}). +Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").` + ); + } + return /** @type {CodeGenerationResult} */ (first(results)); + } + return /** @type {CodeGenerationResult} */ (entry.values().next().value); + } + const result = entry.get(runtime); + if (result === undefined) { + throw new Error( + `No code generation entry for runtime ${runtimeToString( + runtime + )} for ${module.identifier()} (existing runtimes: ${Array.from( + entry.keys(), + (r) => runtimeToString(r) + ).join(", ")})` + ); + } + return result; + } + + /** + * Reports whether a module has a stored result for the requested runtime, or + * a single unambiguous result when no runtime is specified. + * @param {Module} module the module + * @param {RuntimeSpec} runtime runtime(s) + * @returns {boolean} true, when we have data for this + */ + has(module, runtime) { + const entry = this.map.get(module); + if (entry === undefined) { + return false; + } + if (runtime !== undefined) { + return entry.has(runtime); + } else if (entry.size > 1) { + const results = new Set(entry.values()); + return results.size === 1; + } + return entry.size === 1; + } + + /** + * Returns a generated source of the requested source type from a stored code + * generation result. + * @param {Module} module the module + * @param {RuntimeSpec} runtime runtime(s) + * @param {SourceType} sourceType the source type + * @returns {Source} a source + */ + getSource(module, runtime, sourceType) { + return /** @type {Source} */ ( + this.get(module, runtime).sources.get(sourceType) + ); + } + + /** + * Returns the runtime requirements captured during code generation for the + * requested module/runtime pair. + * @param {Module} module the module + * @param {RuntimeSpec} runtime runtime(s) + * @returns {ReadOnlyRuntimeRequirements | null} runtime requirements + */ + getRuntimeRequirements(module, runtime) { + return this.get(module, runtime).runtimeRequirements; + } + + /** + * Returns an arbitrary metadata entry recorded during code generation. + * @param {Module} module the module + * @param {RuntimeSpec} runtime runtime(s) + * @param {string} key data key + * @returns {ReturnType} data generated by code generation + */ + getData(module, runtime, key) { + const data = this.get(module, runtime).data; + return data === undefined ? undefined : data.get(key); + } + + /** + * Returns a stable hash for the generated sources and runtime requirements, + * computing and caching it on first access. + * @param {Module} module the module + * @param {RuntimeSpec} runtime runtime(s) + * @returns {string} hash of the code generation + */ + getHash(module, runtime) { + const info = this.get(module, runtime); + if (info.hash !== undefined) return info.hash; + const hash = createHash(this._hashFunction); + for (const [type, source] of info.sources) { + hash.update(type); + source.updateHash(hash); + } + if (info.runtimeRequirements) { + for (const rr of info.runtimeRequirements) hash.update(rr); + } + return (info.hash = hash.digest("hex")); + } + + /** + * Stores a code generation result for a module/runtime pair, creating the + * per-module runtime map when needed. + * @param {Module} module the module + * @param {RuntimeSpec} runtime runtime(s) + * @param {CodeGenerationResult} result result from module + * @returns {void} + */ + add(module, runtime, result) { + const map = getOrInsert( + this.map, + module, + () => + /** @type {RuntimeSpecMap} */ + new RuntimeSpecMap() + ); + map.set(runtime, result); + } +} + +module.exports = CodeGenerationResults; Index: frontend/node_modules/webpack/lib/CompatibilityPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/CompatibilityPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/CompatibilityPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,255 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const ConstDependency = require("./dependencies/ConstDependency"); + +/** @typedef {import("estree").CallExpression} CallExpression */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ + +/** + * Captures the source range of a renamed compatibility binding so it can be + * rewritten exactly once. + * @typedef {object} CompatibilitySettingsDeclaration + * @property {boolean} updated + * @property {DependencyLocation} loc + * @property {Range} range + */ + +/** + * Stores the replacement variable name and the declaration metadata tracked + * for a compatibility rewrite. + * @typedef {object} CompatibilitySettings + * @property {string} name + * @property {CompatibilitySettingsDeclaration} declaration + */ + +const nestedWebpackIdentifierTag = Symbol("nested webpack identifier"); +const PLUGIN_NAME = "CompatibilityPlugin"; + +/** + * Adds parser-time compatibility rewrites for legacy runtime patterns that + * webpack still needs to recognize in user and generated code. + */ +class CompatibilityPlugin { + /** + * Installs parser hooks that preserve compatibility with legacy patterns + * such as nested `__webpack_require__` bindings and hashbang handling. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyTemplates.set( + ConstDependency, + new ConstDependency.Template() + ); + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, (parser, parserOptions) => { + if ( + parserOptions.browserify !== undefined && + !parserOptions.browserify + ) { + return; + } + + parser.hooks.call.for("require").tap( + PLUGIN_NAME, + /** + * Rewrites browserify-style delegated `require` calls into a + * plain webpack require reference and removes the synthetic + * context dependency created for the delegator pattern. + * @param {CallExpression} expr call expression + * @returns {boolean | void} true when need to handle + */ + (expr) => { + // support for browserify style require delegator: "require(o, !0)" + if (expr.arguments.length !== 2) return; + const second = parser.evaluateExpression(expr.arguments[1]); + if (!second.isBoolean()) return; + if (second.asBool() !== true) return; + const dep = new ConstDependency( + "require", + /** @type {Range} */ (expr.callee.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + if (parser.state.current.dependencies.length > 0) { + const last = + /** @type {ContextDependency} */ + ( + parser.state.current.dependencies[ + parser.state.current.dependencies.length - 1 + ] + ); + if ( + last.critical && + last.options && + last.options.request === "." && + last.userRequest === "." && + last.options.recursive + ) { + parser.state.current.dependencies.pop(); + } + } + parser.state.module.addPresentationalDependency(dep); + return true; + } + ); + }); + + /** + * Attaches the compatibility rewrites for a JavaScript parser + * instance. + * @param {JavascriptParser} parser the parser + * @returns {void} + */ + const handler = (parser) => { + // Handle nested requires + parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => { + if ( + statement.type === "FunctionDeclaration" && + statement.id && + statement.id.name === RuntimeGlobals.require + ) { + const newName = `__nested_webpack_require_${ + /** @type {Range} */ + (statement.range)[0] + }__`; + parser.tagVariable( + statement.id.name, + nestedWebpackIdentifierTag, + { + name: newName, + declaration: { + updated: false, + loc: /** @type {DependencyLocation} */ (statement.id.loc), + range: /** @type {Range} */ (statement.id.range) + } + } + ); + return true; + } + }); + parser.hooks.pattern + .for(RuntimeGlobals.require) + .tap(PLUGIN_NAME, (pattern) => { + const newName = `__nested_webpack_require_${ + /** @type {Range} */ (pattern.range)[0] + }__`; + parser.tagVariable(pattern.name, nestedWebpackIdentifierTag, { + name: newName, + declaration: { + updated: false, + loc: /** @type {DependencyLocation} */ (pattern.loc), + range: /** @type {Range} */ (pattern.range) + } + }); + if (parser.scope.topLevelScope !== true) { + return true; + } + }); + parser.hooks.pattern + .for(RuntimeGlobals.exports) + .tap(PLUGIN_NAME, (pattern) => { + const newName = "__nested_webpack_exports__"; + parser.tagVariable(pattern.name, nestedWebpackIdentifierTag, { + name: newName, + declaration: { + updated: false, + loc: /** @type {DependencyLocation} */ (pattern.loc), + range: /** @type {Range} */ (pattern.range) + } + }); + return true; + }); + // Update single `var __webpack_require__ = {};` and `var __webpack_exports__ = {};` without expression + parser.hooks.declarator.tap(PLUGIN_NAME, (declarator) => { + if ( + declarator.id.type === "Identifier" && + (declarator.id.name === RuntimeGlobals.exports || + declarator.id.name === RuntimeGlobals.require) + ) { + const tagData = /** @type {CompatibilitySettings | undefined} */ ( + parser.getTagData( + declarator.id.name, + nestedWebpackIdentifierTag + ) + ); + if (!tagData) return; + const { name, declaration } = tagData; + if (!declaration.updated) { + const dep = new ConstDependency(name, declaration.range); + dep.loc = declaration.loc; + parser.state.module.addPresentationalDependency(dep); + declaration.updated = true; + } + } + }); + parser.hooks.expression + .for(nestedWebpackIdentifierTag) + .tap(PLUGIN_NAME, (expr) => { + const { name, declaration } = + /** @type {CompatibilitySettings} */ + (parser.currentTagData); + if (!declaration.updated) { + const dep = new ConstDependency(name, declaration.range); + dep.loc = declaration.loc; + parser.state.module.addPresentationalDependency(dep); + declaration.updated = true; + } + const dep = new ConstDependency( + name, + /** @type {Range} */ (expr.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return true; + }); + + // Handle hashbang + parser.hooks.program.tap(PLUGIN_NAME, (program, comments) => { + if (comments.length === 0) return; + const c = comments[0]; + if (c.type === "Line" && /** @type {Range} */ (c.range)[0] === 0) { + if (parser.state.source.slice(0, 2).toString() !== "#!") return; + // this is a hashbang comment + const dep = new ConstDependency("//", 0); + dep.loc = /** @type {DependencyLocation} */ (c.loc); + parser.state.module.addPresentationalDependency(dep); + } + }); + }; + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } +} + +module.exports = CompatibilityPlugin; +module.exports.nestedWebpackIdentifierTag = nestedWebpackIdentifierTag; Index: frontend/node_modules/webpack/lib/Compilation.js =================================================================== --- frontend/node_modules/webpack/lib/Compilation.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Compilation.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,6055 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const asyncLib = require("neo-async"); +const { + AsyncParallelHook, + AsyncSeriesBailHook, + AsyncSeriesHook, + HookMap, + SyncBailHook, + SyncHook, + SyncWaterfallHook +} = require("tapable"); +const { CachedSource } = require("webpack-sources"); +const { MultiItemCache } = require("./CacheFacade"); +const Chunk = require("./Chunk"); +const ChunkGraph = require("./ChunkGraph"); +const ChunkGroup = require("./ChunkGroup"); +const ChunkTemplate = require("./ChunkTemplate"); +const CodeGenerationResults = require("./CodeGenerationResults"); +const Dependency = require("./Dependency"); +const DependencyTemplates = require("./DependencyTemplates"); +const Entrypoint = require("./Entrypoint"); +const ErrorHelpers = require("./ErrorHelpers"); +const FileSystemInfo = require("./FileSystemInfo"); +const MainTemplate = require("./MainTemplate"); +const Module = require("./Module"); +const ModuleGraph = require("./ModuleGraph"); +const ModuleProfile = require("./ModuleProfile"); +const ModuleTemplate = require("./ModuleTemplate"); +const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const RuntimeTemplate = require("./RuntimeTemplate"); +const Stats = require("./Stats"); +const buildChunkGraph = require("./buildChunkGraph"); +const BuildCycleError = require("./errors/BuildCycleError"); +const ChunkRenderError = require("./errors/ChunkRenderError"); +const CodeGenerationError = require("./errors/CodeGenerationError"); +const { + makeWebpackError, + tryRunOrWebpackError +} = require("./errors/HookWebpackError"); +const ModuleDependencyError = require("./errors/ModuleDependencyError"); +const ModuleDependencyWarning = require("./errors/ModuleDependencyWarning"); +const ModuleHashingError = require("./errors/ModuleHashingError"); +const ModuleNotFoundError = require("./errors/ModuleNotFoundError"); +const ModuleRestoreError = require("./errors/ModuleRestoreError"); +const ModuleStoreError = require("./errors/ModuleStoreError"); +const WebpackError = require("./errors/WebpackError"); +const { LogType, Logger } = require("./logging/Logger"); +const StatsFactory = require("./stats/StatsFactory"); +const StatsPrinter = require("./stats/StatsPrinter"); +const { equals: arrayEquals } = require("./util/ArrayHelpers"); +const AsyncQueue = require("./util/AsyncQueue"); +const LazySet = require("./util/LazySet"); +const { getOrInsert } = require("./util/MapHelpers"); +const WeakTupleMap = require("./util/WeakTupleMap"); +const { cachedCleverMerge } = require("./util/cleverMerge"); +const { + compareIds, + compareLocations, + compareModulesByIdentifier, + compareSelect, + compareStringsNumeric, + concatComparators +} = require("./util/comparators"); +const createHash = require("./util/createHash"); +const { + arrayToSetDeprecation, + createFakeHook, + soonFrozenObjectDeprecation +} = require("./util/deprecation"); +const processAsyncTree = require("./util/processAsyncTree"); +const { getRuntimeKey } = require("./util/runtime"); +const { isSourceEqual } = require("./util/source"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */ +/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */ +/** @typedef {import("../declarations/WebpackOptions").HashDigest} HashDigest */ +/** @typedef {import("../declarations/WebpackOptions").HashDigestLength} HashDigestLength */ +/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */ +/** @typedef {import("../declarations/WebpackOptions").Plugins} Plugins */ +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptionsWithDefaults */ +/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */ +/** @typedef {import("./Cache")} Cache */ +/** @typedef {import("./CacheFacade")} CacheFacade */ +/** @typedef {import("./Chunk").ChunkName} ChunkName */ +/** @typedef {import("./Chunk").ChunkId} ChunkId */ +/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Compiler").CompilationParams} CompilationParams */ +/** @typedef {import("./Compiler").MemCache} MemCache */ +/** @typedef {import("./Compiler").WeakReferences} WeakReferences */ +/** @typedef {import("./Compiler").ModuleMemCachesItem} ModuleMemCachesItem */ +/** @typedef {import("./Compiler").Records} Records */ +/** @typedef {import("./DependenciesBlock")} DependenciesBlock */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./Dependency").ReferencedExports} ReferencedExports */ +/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */ +/** @typedef {import("./Module").NameForCondition} NameForCondition */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */ +/** @typedef {import("./Module").FactoryMeta} FactoryMeta */ +/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("./ModuleFactory")} ModuleFactory */ +/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ +/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */ +/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */ +/** @typedef {import("./NormalModule")} NormalModule */ +/** @typedef {import("./NormalModule").AnyLoaderContext} AnyLoaderContext */ +/** @typedef {import("./NormalModule").ParserOptions} ParserOptions */ +/** @typedef {import("./NormalModule").GeneratorOptions} GeneratorOptions */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./RuntimeModule")} RuntimeModule */ +/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */ +/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */ +/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */ +/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */ +/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */ +/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */ +/** @typedef {import("./util/Hash")} Hash */ + +/** + * Defines the shared type used by this module. + * @template T + * @typedef {import("tapable").AsArray} AsArray + */ + +/** + * Defines the shared type used by this module. + * @template T + * @typedef {import("./util/deprecation").FakeHook} FakeHook + */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ + +/** + * Defines the callback callback. + * @callback Callback + * @param {(WebpackError | null)=} err + * @returns {void} + */ + +/** + * Defines the module callback callback. + * @callback ModuleCallback + * @param {WebpackError | null=} err + * @param {Module | null=} result + * @returns {void} + */ + +/** + * Defines the module factory result callback callback. + * @callback ModuleFactoryResultCallback + * @param {WebpackError | null=} err + * @param {ModuleFactoryResult | null=} result + * @returns {void} + */ + +/** + * Defines the module or module factory result callback callback. + * @callback ModuleOrModuleFactoryResultCallback + * @param {WebpackError | null=} err + * @param {Module | ModuleFactoryResult | null=} result + * @returns {void} + */ + +/** + * Defines the execute module callback callback. + * @callback ExecuteModuleCallback + * @param {WebpackError | null=} err + * @param {ExecuteModuleResult | null=} result + * @returns {void} + */ + +/** @typedef {new (...args: EXPECTED_ANY[]) => Dependency} DependencyConstructor */ + +/** @typedef {Record} CompilationAssets */ + +/** + * Defines the available modules chunk group mapping type used by this module. + * @typedef {object} AvailableModulesChunkGroupMapping + * @property {ChunkGroup} chunkGroup + * @property {Set} availableModules + * @property {boolean} needCopy + */ + +/** + * Defines the dependencies block like type used by this module. + * @typedef {object} DependenciesBlockLike + * @property {Dependency[]} dependencies + * @property {AsyncDependenciesBlock[]} blocks + */ + +/** @typedef {Set} Chunks */ + +/** + * Defines the chunk path data type used by this module. + * @typedef {object} ChunkPathData + * @property {string | number} id + * @property {string=} name + * @property {string} hash + * @property {HashWithLengthFunction=} hashWithLength + * @property {(Record)=} contentHash + * @property {(Record)=} contentHashWithLength + */ + +/** + * Defines the chunk hash context type used by this module. + * @typedef {object} ChunkHashContext + * @property {CodeGenerationResults} codeGenerationResults results of code generation + * @property {RuntimeTemplate} runtimeTemplate the runtime template + * @property {ModuleGraph} moduleGraph the module graph + * @property {ChunkGraph} chunkGraph the chunk graph + */ + +/** + * Defines the runtime requirements context type used by this module. + * @typedef {object} RuntimeRequirementsContext + * @property {ChunkGraph} chunkGraph the chunk graph + * @property {CodeGenerationResults} codeGenerationResults the code generation results + */ + +/** + * Defines the execute module options type used by this module. + * @typedef {object} ExecuteModuleOptions + * @property {EntryOptions=} entryOptions + */ + +/** @typedef {LazySet} FileSystemDependencies */ + +/** @typedef {EXPECTED_ANY} ExecuteModuleExports */ + +/** + * Defines the execute module result type used by this module. + * @typedef {object} ExecuteModuleResult + * @property {ExecuteModuleExports} exports + * @property {boolean} cacheable + * @property {ExecuteModuleAssets} assets + * @property {FileSystemDependencies} fileDependencies + * @property {FileSystemDependencies} contextDependencies + * @property {FileSystemDependencies} missingDependencies + * @property {FileSystemDependencies} buildDependencies + */ + +/** + * Defines the execute module object type used by this module. + * @typedef {object} ExecuteModuleObject + * @property {string=} id module id + * @property {ExecuteModuleExports} exports exports + * @property {boolean} loaded is loaded + * @property {Error=} error error + */ + +/** + * Defines the execute module argument type used by this module. + * @typedef {object} ExecuteModuleArgument + * @property {Module} module + * @property {ExecuteModuleObject=} moduleObject + * @property {CodeGenerationResult} codeGenerationResult + */ + +/** @typedef {((id: string) => ExecuteModuleExports) & { i?: ((options: ExecuteOptions) => void)[], c?: Record }} WebpackRequire */ + +/** + * Defines the execute options type used by this module. + * @typedef {object} ExecuteOptions + * @property {string=} id module id + * @property {ExecuteModuleObject} module module + * @property {WebpackRequire} require require function + */ + +/** @typedef {Map} ExecuteModuleAssets */ + +/** + * Defines the execute module context type used by this module. + * @typedef {object} ExecuteModuleContext + * @property {ExecuteModuleAssets} assets + * @property {Chunk} chunk + * @property {ChunkGraph} chunkGraph + * @property {WebpackRequire=} __webpack_require__ + */ + +/** + * Defines the entry data type used by this module. + * @typedef {object} EntryData + * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup + * @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated + * @property {EntryOptions} options options of the entrypoint + */ + +/** + * Defines the log entry type used by this module. + * @typedef {object} LogEntry + * @property {keyof LogType} type + * @property {EXPECTED_ANY[]=} args + * @property {number} time + * @property {string[]=} trace + */ + +/** + * Defines the known asset info type used by this module. + * @typedef {object} KnownAssetInfo + * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash) + * @property {boolean=} minimized whether the asset is minimized + * @property {string | string[]=} fullhash the value(s) of the full hash used for this asset + * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset + * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset + * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset + * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context + * @property {number=} size size in bytes, only set after asset has been emitted + * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets + * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR) + * @property {boolean=} javascriptModule true, when asset is javascript and an ESM + * @property {boolean=} manifest true, when file is a manifest + * @property {Record=} related object of pointers to other assets, keyed by type of relation (only points from parent to child) + */ + +/** @typedef {KnownAssetInfo & Record} AssetInfo */ + +/** @typedef {{ path: string, info: AssetInfo }} InterpolatedPathAndAssetInfo */ + +/** + * Defines the asset type used by this module. + * @typedef {object} Asset + * @property {string} name the filename of the asset + * @property {Source} source source of the asset + * @property {AssetInfo} info info about the asset + */ + +/** @typedef {(length: number) => string} HashWithLengthFunction */ + +/** + * Defines the module path data type used by this module. + * @typedef {object} ModulePathData + * @property {string | number} id + * @property {string} hash + * @property {HashWithLengthFunction=} hashWithLength + */ + +/** @typedef {(id: string | number) => string | number} PrepareIdFunction */ + +/** + * Defines the path data type used by this module. + * @typedef {object} PathData + * @property {ChunkGraph=} chunkGraph + * @property {string=} hash + * @property {HashWithLengthFunction=} hashWithLength + * @property {(Chunk | ChunkPathData)=} chunk + * @property {(Module | ModulePathData)=} module + * @property {RuntimeSpec=} runtime + * @property {string=} filename + * @property {string=} basename + * @property {string=} query + * @property {string=} contentHashType + * @property {string=} contentHash + * @property {HashWithLengthFunction=} contentHashWithLength + * @property {boolean=} noChunkHash + * @property {string=} url + * @property {string=} local + * @property {PrepareIdFunction=} prepareId + */ + +/** + * Path data narrowed for the chunk filename / chunk asset interpolation context, + * where `chunk` is always provided. Use as the type parameter to `TemplatePathFn` + * for callbacks that receive a chunk context (for example `output.filename`, + * `output.chunkFilename`, `output.cssFilename`, `output.cssChunkFilename`, + * `optimization.splitChunks.cacheGroups[*].filename`). + * @typedef {PathData & { chunk: Chunk | ChunkPathData }} PathDataChunk + */ + +/** + * Path data narrowed for the module asset interpolation context, where `module` + * and `chunkGraph` are always provided. Use as the type parameter to + * `TemplatePathFn` for callbacks that receive a module context (for example + * `output.assetModuleFilename`, the per-module `generator.filename` / + * `generator.outputPath`, and `module.parser.css.localIdentName`). + * @typedef {PathData & { module: Module | ModulePathData, chunkGraph: ChunkGraph }} PathDataModule + */ + +/** @typedef {"module" | "chunk" | "root-of-chunk" | "nested"} ExcludeModulesType */ + +/** + * Defines the known normalized stats options type used by this module. + * @typedef {object} KnownNormalizedStatsOptions + * @property {string} context + * @property {RequestShortener} requestShortener + * @property {string | false} chunksSort + * @property {string | false} modulesSort + * @property {string | false} chunkModulesSort + * @property {string | false} nestedModulesSort + * @property {string | false} assetsSort + * @property {boolean} ids + * @property {boolean} cachedAssets + * @property {boolean} groupAssetsByEmitStatus + * @property {boolean} groupAssetsByPath + * @property {boolean} groupAssetsByExtension + * @property {number} assetsSpace + * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets + * @property {((name: string, module: StatsModule, type: ExcludeModulesType) => boolean)[]} excludeModules + * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter + * @property {boolean} cachedModules + * @property {boolean} orphanModules + * @property {boolean} dependentModules + * @property {boolean} runtimeModules + * @property {boolean} groupModulesByCacheStatus + * @property {boolean} groupModulesByLayer + * @property {boolean} groupModulesByAttributes + * @property {boolean} groupModulesByPath + * @property {boolean} groupModulesByExtension + * @property {boolean} groupModulesByType + * @property {boolean | "auto"} entrypoints + * @property {boolean} chunkGroups + * @property {boolean} chunkGroupAuxiliary + * @property {boolean} chunkGroupChildren + * @property {number} chunkGroupMaxAssets + * @property {number} modulesSpace + * @property {number} chunkModulesSpace + * @property {number} nestedModulesSpace + * @property {false | "none" | "error" | "warn" | "info" | "log" | "verbose"} logging + * @property {((value: string) => boolean)[]} loggingDebug + * @property {boolean} loggingTrace + * @property {EXPECTED_ANY} _env + */ + +/** @typedef {KnownNormalizedStatsOptions & Omit & Record} NormalizedStatsOptions */ + +/** + * Defines the known create stats options context type used by this module. + * @typedef {object} KnownCreateStatsOptionsContext + * @property {boolean=} forToString + */ + +/** @typedef {KnownCreateStatsOptionsContext & Record} CreateStatsOptionsContext */ + +/** @typedef {{ module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[] }} CodeGenerationJob */ + +/** @typedef {CodeGenerationJob[]} CodeGenerationJobs */ + +/** @typedef {{ javascript: ModuleTemplate }} ModuleTemplates */ + +/** @typedef {Set} NotCodeGeneratedModules */ + +/** @type {AssetInfo} */ +const EMPTY_ASSET_INFO = Object.freeze({}); + +const esmDependencyCategory = "esm"; + +// TODO webpack 6: remove +const deprecatedNormalModuleLoaderHook = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {Compilation} compilation compilation + * @returns {NormalModuleCompilationHooks["loader"]} hooks + */ + (compilation) => + require("./NormalModule").getCompilationHooks(compilation).loader, + "Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader", + "DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK" +); + +// TODO webpack 6: remove +/** + * Define removed module templates. + * @param {ModuleTemplates | undefined} moduleTemplates module templates + */ +const defineRemovedModuleTemplates = (moduleTemplates) => { + Object.defineProperties(moduleTemplates, { + asset: { + enumerable: false, + configurable: false, + get: () => { + throw new WebpackError( + "Compilation.moduleTemplates.asset has been removed" + ); + } + }, + webassembly: { + enumerable: false, + configurable: false, + get: () => { + throw new WebpackError( + "Compilation.moduleTemplates.webassembly has been removed" + ); + } + } + }); + moduleTemplates = undefined; +}; + +const byId = compareSelect((c) => c.id, compareIds); + +const byNameOrHash = concatComparators( + compareSelect((c) => c.name, compareIds), + compareSelect((c) => c.fullHash, compareIds) +); + +const byMessage = compareSelect( + (err) => `${err.message}`, + compareStringsNumeric +); + +const byModule = compareSelect( + (err) => (err.module && err.module.identifier()) || "", + compareStringsNumeric +); + +const byLocation = compareSelect((err) => err.loc, compareLocations); + +const compareErrors = concatComparators(byModule, byLocation, byMessage); + +/** + * Defines the known unsafe cache data type used by this module. + * @typedef {object} KnownUnsafeCacheData + * @property {FactoryMeta=} factoryMeta factory meta + * @property {ResolveOptions=} resolveOptions resolve options + * @property {ParserOptions=} parserOptions + * @property {GeneratorOptions=} generatorOptions + */ + +/** @typedef {KnownUnsafeCacheData & Record} UnsafeCacheData */ + +/** + * Defines the module with restore from unsafe cache type used by this module. + * @typedef {Module & { restoreFromUnsafeCache?: (unsafeCacheData: UnsafeCacheData, moduleFactory: ModuleFactory, compilationParams: CompilationParams) => void }} ModuleWithRestoreFromUnsafeCache + */ + +/** @typedef {(module: Module) => boolean} UnsafeCachePredicate */ + +/** @type {WeakMap} */ +const unsafeCacheDependencies = new WeakMap(); + +/** @type {WeakMap} */ +const unsafeCacheData = new WeakMap(); + +/** @typedef {{ id: ModuleId, modules?: Map, blocks?: (ChunkId | null)[] }} References */ +/** @typedef {Map>} ModuleMemCaches */ + +class Compilation { + /** + * Creates an instance of Compilation. + * @param {Compiler} compiler the compiler which created the compilation + * @param {CompilationParams} params the compilation parameters + */ + constructor(compiler, params) { + this._backCompat = compiler._backCompat; + + const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this); + /** @typedef {{ additionalAssets?: boolean | ((assets: CompilationAssets) => void) }} ProcessAssetsAdditionalOptions */ + /** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */ + const processAssetsHook = new AsyncSeriesHook(["assets"]); + + /** @type {Set} */ + let savedAssets = new Set(); + /** + * Returns new assets. + * @param {CompilationAssets} assets assets + * @returns {CompilationAssets} new assets + */ + const popNewAssets = (assets) => { + /** @type {undefined | CompilationAssets} */ + let newAssets; + for (const file of Object.keys(assets)) { + if (savedAssets.has(file)) continue; + if (newAssets === undefined) { + newAssets = Object.create(null); + } + /** @type {CompilationAssets} */ + (newAssets)[file] = assets[file]; + savedAssets.add(file); + } + return /** @type {CompilationAssets} */ (newAssets); + }; + processAssetsHook.intercept({ + name: "Compilation", + call: () => { + savedAssets = new Set(Object.keys(this.assets)); + }, + register: (tap) => { + const { type, name } = tap; + const { fn, additionalAssets, ...remainingTap } = tap; + const additionalAssetsFn = + additionalAssets === true ? fn : additionalAssets; + /** @typedef {WeakSet} ProcessedAssets */ + + /** @type {ProcessedAssets | undefined} */ + const processedAssets = additionalAssetsFn ? new WeakSet() : undefined; + /** + * Gets available assets. + * @param {CompilationAssets} assets to be processed by additionalAssetsFn + * @returns {CompilationAssets} available assets + */ + const getAvailableAssets = (assets) => { + /** @type {CompilationAssets} */ + const availableAssets = {}; + for (const file of Object.keys(assets)) { + // https://github.com/webpack-contrib/compression-webpack-plugin/issues/390 + if (this.assets[file]) { + availableAssets[file] = assets[file]; + } + } + return availableAssets; + }; + switch (type) { + case "sync": + if (additionalAssetsFn) { + this.hooks.processAdditionalAssets.tap(name, (assets) => { + if ( + /** @type {ProcessedAssets} */ + (processedAssets).has(this.assets) + ) { + additionalAssetsFn(getAvailableAssets(assets)); + } + }); + } + return { + ...remainingTap, + type: "async", + /** + * Processes the provided asset. + * @param {CompilationAssets} assets assets + * @param {(err?: Error | null, result?: void) => void} callback callback + * @returns {void} + */ + fn: (assets, callback) => { + try { + fn(assets); + } catch (err) { + return callback(/** @type {Error} */ (err)); + } + if (processedAssets !== undefined) { + processedAssets.add(this.assets); + } + const newAssets = popNewAssets(assets); + if (newAssets !== undefined) { + this.hooks.processAdditionalAssets.callAsync( + newAssets, + callback + ); + return; + } + callback(); + } + }; + case "async": + if (additionalAssetsFn) { + this.hooks.processAdditionalAssets.tapAsync( + name, + (assets, callback) => { + if ( + /** @type {ProcessedAssets} */ + (processedAssets).has(this.assets) + ) { + return additionalAssetsFn( + getAvailableAssets(assets), + callback + ); + } + callback(); + } + ); + } + return { + ...remainingTap, + /** + * Processes the provided asset. + * @param {CompilationAssets} assets assets + * @param {(err?: Error | null, result?: void) => void} callback callback + * @returns {void} + */ + fn: (assets, callback) => { + fn( + assets, + /** + * Handles the callback logic for this hook. + * @param {Error} err err + * @returns {void} + */ + (err) => { + if (err) return callback(err); + if (processedAssets !== undefined) { + processedAssets.add(this.assets); + } + const newAssets = popNewAssets(assets); + if (newAssets !== undefined) { + this.hooks.processAdditionalAssets.callAsync( + newAssets, + callback + ); + return; + } + callback(); + } + ); + } + }; + case "promise": + if (additionalAssetsFn) { + this.hooks.processAdditionalAssets.tapPromise(name, (assets) => { + if ( + /** @type {ProcessedAssets} */ + (processedAssets).has(this.assets) + ) { + return additionalAssetsFn(getAvailableAssets(assets)); + } + return Promise.resolve(); + }); + } + return { + ...remainingTap, + /** + * Returns result. + * @param {CompilationAssets} assets assets + * @returns {Promise} result + */ + fn: (assets) => { + const p = fn(assets); + if (!p || !p.then) return p; + return p.then(() => { + if (processedAssets !== undefined) { + processedAssets.add(this.assets); + } + const newAssets = popNewAssets(assets); + if (newAssets !== undefined) { + return this.hooks.processAdditionalAssets.promise( + newAssets + ); + } + }); + } + }; + } + } + }); + + /** @type {SyncHook<[CompilationAssets]>} */ + const afterProcessAssetsHook = new SyncHook(["assets"]); + + /** + * Creates a process assets hook. + * @template T + * @param {string} name name of the hook + * @param {number} stage new stage + * @param {() => AsArray} getArgs get old hook function args + * @param {string=} code deprecation code (not deprecated when unset) + * @returns {FakeHook, "tap" | "tapAsync" | "tapPromise" | "name">> | undefined} fake hook which redirects + */ + const createProcessAssetsHook = (name, stage, getArgs, code) => { + if (!this._backCompat && code) return; + /** + * Returns error message. + * @param {string} reason reason + * @returns {string} error message + */ + const errorMessage = ( + reason + ) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}. +BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`; + /** + * Normalizes tap options for migrated process-assets hooks. + * @param {string | (import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions)} options hook options + * @returns {import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions} modified options + */ + const getOptions = (options) => { + if (typeof options === "string") options = { name: options }; + if (options.stage) { + throw new Error(errorMessage("it's using the 'stage' option")); + } + return { ...options, stage }; + }; + return createFakeHook( + { + name, + /** @type {AsyncSeriesHook["intercept"]} */ + intercept(_interceptor) { + throw new Error(errorMessage("it's using 'intercept'")); + }, + /** @type {AsyncSeriesHook["tap"]} */ + tap: (options, fn) => { + processAssetsHook.tap(getOptions(options), () => fn(...getArgs())); + }, + /** @type {AsyncSeriesHook["tapAsync"]} */ + tapAsync: (options, fn) => { + processAssetsHook.tapAsync( + getOptions(options), + (assets, callback) => + /** @type {EXPECTED_ANY} */ (fn)(...getArgs(), callback) + ); + }, + /** @type {AsyncSeriesHook["tapPromise"]} */ + tapPromise: (options, fn) => { + processAssetsHook.tapPromise(getOptions(options), () => + fn(...getArgs()) + ); + } + }, + `${name} is deprecated (use Compilation.hooks.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`, + code + ); + }; + this.hooks = Object.freeze({ + /** @type {SyncHook<[Module]>} */ + buildModule: new SyncHook(["module"]), + /** @type {SyncHook<[Module]>} */ + rebuildModule: new SyncHook(["module"]), + /** @type {SyncHook<[Module, WebpackError]>} */ + failedModule: new SyncHook(["module", "error"]), + /** @type {SyncHook<[Module]>} */ + succeedModule: new SyncHook(["module"]), + /** @type {SyncHook<[Module]>} */ + stillValidModule: new SyncHook(["module"]), + + /** @type {SyncHook<[Dependency, EntryOptions]>} */ + addEntry: new SyncHook(["entry", "options"]), + /** @type {SyncHook<[Dependency, EntryOptions, Error]>} */ + failedEntry: new SyncHook(["entry", "options", "error"]), + /** @type {SyncHook<[Dependency, EntryOptions, Module]>} */ + succeedEntry: new SyncHook(["entry", "options", "module"]), + + /** @type {SyncWaterfallHook<[ReferencedExports, Dependency, RuntimeSpec]>} */ + dependencyReferencedExports: new SyncWaterfallHook([ + "referencedExports", + "dependency", + "runtime" + ]), + + /** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */ + executeModule: new SyncHook(["options", "context"]), + /** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */ + prepareModuleExecution: new AsyncParallelHook(["options", "context"]), + + /** @type {AsyncSeriesHook<[Iterable]>} */ + finishModules: new AsyncSeriesHook(["modules"]), + /** @type {AsyncSeriesHook<[Module]>} */ + finishRebuildingModule: new AsyncSeriesHook(["module"]), + /** @type {SyncHook<[]>} */ + unseal: new SyncHook([]), + /** @type {SyncHook<[]>} */ + seal: new SyncHook([]), + + /** @type {SyncHook<[]>} */ + beforeChunks: new SyncHook([]), + /** + * The `afterChunks` hook is called directly after the chunks and module graph have + * been created and before the chunks and modules have been optimized. This hook is useful to + * inspect, analyze, and/or modify the chunk graph. + * @type {SyncHook<[Iterable]>} + */ + afterChunks: new SyncHook(["chunks"]), + + /** @type {SyncBailHook<[Iterable], boolean | void>} */ + optimizeDependencies: new SyncBailHook(["modules"]), + /** @type {SyncHook<[Iterable]>} */ + afterOptimizeDependencies: new SyncHook(["modules"]), + + /** @type {SyncHook<[]>} */ + optimize: new SyncHook([]), + /** @type {SyncBailHook<[Iterable], boolean | void>} */ + optimizeModules: new SyncBailHook(["modules"]), + /** @type {SyncHook<[Iterable]>} */ + afterOptimizeModules: new SyncHook(["modules"]), + + /** @type {SyncBailHook<[Iterable, ChunkGroup[]], boolean | void>} */ + optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]), + /** @type {SyncHook<[Iterable, ChunkGroup[]]>} */ + afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]), + + /** @type {AsyncSeriesHook<[Iterable, Iterable]>} */ + optimizeTree: new AsyncSeriesHook(["chunks", "modules"]), + /** @type {SyncHook<[Iterable, Iterable]>} */ + afterOptimizeTree: new SyncHook(["chunks", "modules"]), + + /** @type {AsyncSeriesBailHook<[Iterable, Iterable], void>} */ + optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]), + /** @type {SyncHook<[Iterable, Iterable]>} */ + afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]), + /** @type {SyncBailHook<[], boolean | void>} */ + shouldRecord: new SyncBailHook([]), + + /** @type {SyncHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext]>} */ + additionalChunkRuntimeRequirements: new SyncHook([ + "chunk", + "runtimeRequirements", + "context" + ]), + /** @type {HookMap>} */ + runtimeRequirementInChunk: new HookMap( + () => new SyncBailHook(["chunk", "runtimeRequirements", "context"]) + ), + /** @type {SyncHook<[Module, RuntimeRequirements, RuntimeRequirementsContext]>} */ + additionalModuleRuntimeRequirements: new SyncHook([ + "module", + "runtimeRequirements", + "context" + ]), + /** @type {HookMap>} */ + runtimeRequirementInModule: new HookMap( + () => new SyncBailHook(["module", "runtimeRequirements", "context"]) + ), + /** @type {SyncHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext]>} */ + additionalTreeRuntimeRequirements: new SyncHook([ + "chunk", + "runtimeRequirements", + "context" + ]), + /** @type {HookMap>} */ + runtimeRequirementInTree: new HookMap( + () => new SyncBailHook(["chunk", "runtimeRequirements", "context"]) + ), + + /** @type {SyncHook<[RuntimeModule, Chunk]>} */ + runtimeModule: new SyncHook(["module", "chunk"]), + + /** @type {SyncHook<[Iterable, Records]>} */ + reviveModules: new SyncHook(["modules", "records"]), + /** @type {SyncHook<[Iterable]>} */ + beforeModuleIds: new SyncHook(["modules"]), + /** @type {SyncHook<[Iterable]>} */ + moduleIds: new SyncHook(["modules"]), + /** @type {SyncHook<[Iterable]>} */ + optimizeModuleIds: new SyncHook(["modules"]), + /** @type {SyncHook<[Iterable]>} */ + afterOptimizeModuleIds: new SyncHook(["modules"]), + + /** @type {SyncHook<[Iterable, Records]>} */ + reviveChunks: new SyncHook(["chunks", "records"]), + /** @type {SyncHook<[Iterable]>} */ + beforeChunkIds: new SyncHook(["chunks"]), + /** @type {SyncHook<[Iterable]>} */ + chunkIds: new SyncHook(["chunks"]), + /** @type {SyncHook<[Iterable]>} */ + optimizeChunkIds: new SyncHook(["chunks"]), + /** @type {SyncHook<[Iterable]>} */ + afterOptimizeChunkIds: new SyncHook(["chunks"]), + + /** @type {SyncHook<[Iterable, Records]>} */ + recordModules: new SyncHook(["modules", "records"]), + /** @type {SyncHook<[Iterable, Records]>} */ + recordChunks: new SyncHook(["chunks", "records"]), + + /** @type {SyncHook<[Iterable]>} */ + optimizeCodeGeneration: new SyncHook(["modules"]), + + /** @type {SyncHook<[]>} */ + beforeModuleHash: new SyncHook([]), + /** @type {SyncHook<[]>} */ + afterModuleHash: new SyncHook([]), + + /** @type {SyncHook<[]>} */ + beforeCodeGeneration: new SyncHook([]), + /** @type {SyncHook<[]>} */ + afterCodeGeneration: new SyncHook([]), + + /** @type {SyncHook<[]>} */ + beforeRuntimeRequirements: new SyncHook([]), + /** @type {SyncHook<[]>} */ + afterRuntimeRequirements: new SyncHook([]), + + /** @type {SyncHook<[]>} */ + beforeHash: new SyncHook([]), + /** @type {SyncHook<[Chunk]>} */ + contentHash: new SyncHook(["chunk"]), + /** @type {SyncHook<[]>} */ + afterHash: new SyncHook([]), + /** @type {SyncHook<[Records]>} */ + recordHash: new SyncHook(["records"]), + /** @type {SyncHook<[Compilation, Records]>} */ + record: new SyncHook(["compilation", "records"]), + + /** @type {SyncHook<[]>} */ + beforeModuleAssets: new SyncHook([]), + /** @type {SyncBailHook<[], boolean | void>} */ + shouldGenerateChunkAssets: new SyncBailHook([]), + /** @type {SyncHook<[]>} */ + beforeChunkAssets: new SyncHook([]), + // TODO webpack 6 remove + /** @deprecated */ + additionalChunkAssets: + /** @type {FakeHook, "tap" | "tapAsync" | "tapPromise" | "name">>} */ + ( + createProcessAssetsHook( + "additionalChunkAssets", + Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, + () => [this.chunks], + "DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS" + ) + ), + + // TODO webpack 6 deprecate + /** @deprecated */ + additionalAssets: + /** @type {FakeHook, "tap" | "tapAsync" | "tapPromise" | "name">>} */ + ( + createProcessAssetsHook( + "additionalAssets", + Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, + () => [] + ) + ), + // TODO webpack 6 remove + /** @deprecated */ + optimizeChunkAssets: + /** @type {FakeHook, "tap" | "tapAsync" | "tapPromise" | "name">>} */ + ( + createProcessAssetsHook( + "optimizeChunkAssets", + Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE, + () => [this.chunks], + "DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS" + ) + ), + // TODO webpack 6 remove + /** @deprecated */ + afterOptimizeChunkAssets: + /** @type {FakeHook, "tap" | "tapAsync" | "tapPromise" | "name">>} */ + ( + createProcessAssetsHook( + "afterOptimizeChunkAssets", + Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1, + () => [this.chunks], + "DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS" + ) + ), + // TODO webpack 6 deprecate + /** @deprecated */ + optimizeAssets: processAssetsHook, + // TODO webpack 6 deprecate + /** @deprecated */ + afterOptimizeAssets: afterProcessAssetsHook, + + processAssets: processAssetsHook, + afterProcessAssets: afterProcessAssetsHook, + /** @type {AsyncSeriesHook<[CompilationAssets]>} */ + processAdditionalAssets: new AsyncSeriesHook(["assets"]), + + /** @type {SyncBailHook<[], boolean | void>} */ + needAdditionalSeal: new SyncBailHook([]), + /** @type {AsyncSeriesHook<[]>} */ + afterSeal: new AsyncSeriesHook([]), + + /** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */ + renderManifest: new SyncWaterfallHook(["result", "options"]), + + /** @type {SyncHook<[Hash]>} */ + fullHash: new SyncHook(["hash"]), + /** @type {SyncHook<[Chunk, Hash, ChunkHashContext]>} */ + chunkHash: new SyncHook(["chunk", "chunkHash", "ChunkHashContext"]), + + /** @type {SyncHook<[Module, string]>} */ + moduleAsset: new SyncHook(["module", "filename"]), + /** @type {SyncHook<[Chunk, string]>} */ + chunkAsset: new SyncHook(["chunk", "filename"]), + + /** @type {SyncWaterfallHook<[string, PathData, AssetInfo | undefined]>} */ + assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]), + + /** @type {SyncBailHook<[], boolean | void>} */ + needAdditionalPass: new SyncBailHook([]), + + /** @type {SyncHook<[Compiler, string, number]>} */ + childCompiler: new SyncHook([ + "childCompiler", + "compilerName", + "compilerIndex" + ]), + + /** @type {SyncBailHook<[string, LogEntry], boolean | void>} */ + log: new SyncBailHook(["origin", "logEntry"]), + + /** @type {SyncWaterfallHook<[Error[]]>} */ + processWarnings: new SyncWaterfallHook(["warnings"]), + /** @type {SyncWaterfallHook<[Error[]]>} */ + processErrors: new SyncWaterfallHook(["errors"]), + + /** @type {HookMap, CreateStatsOptionsContext]>>} */ + statsPreset: new HookMap(() => new SyncHook(["options", "context"])), + /** @type {SyncHook<[Partial, CreateStatsOptionsContext]>} */ + statsNormalize: new SyncHook(["options", "context"]), + /** @type {SyncHook<[StatsFactory, NormalizedStatsOptions]>} */ + statsFactory: new SyncHook(["statsFactory", "options"]), + /** @type {SyncHook<[StatsPrinter, NormalizedStatsOptions]>} */ + statsPrinter: new SyncHook(["statsPrinter", "options"]), + + /** + * Gets normal module loader. + * @deprecated + * @returns {SyncHook<[AnyLoaderContext, NormalModule]>} normal module loader hook + */ + get normalModuleLoader() { + return getNormalModuleLoader(); + } + }); + /** @type {string=} */ + this.name = undefined; + /** @type {number | undefined} */ + this.startTime = undefined; + /** @type {number | undefined} */ + this.endTime = undefined; + /** @type {Compiler} */ + this.compiler = compiler; + this.resolverFactory = compiler.resolverFactory; + /** @type {InputFileSystem} */ + this.inputFileSystem = + /** @type {InputFileSystem} */ + (compiler.inputFileSystem); + this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, { + unmanagedPaths: compiler.unmanagedPaths, + managedPaths: compiler.managedPaths, + immutablePaths: compiler.immutablePaths, + logger: this.getLogger("webpack.FileSystemInfo"), + hashFunction: compiler.options.output.hashFunction + }); + if (compiler.fileTimestamps) { + this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true); + } + if (compiler.contextTimestamps) { + this.fileSystemInfo.addContextTimestamps( + compiler.contextTimestamps, + true + ); + } + /** @type {ValueCacheVersions} */ + this.valueCacheVersions = new Map(); + this.requestShortener = compiler.requestShortener; + this.compilerPath = compiler.compilerPath; + + this.logger = this.getLogger("webpack.Compilation"); + + const options = /** @type {WebpackOptions} */ (compiler.options); + this.options = options; + this.outputOptions = + /** @type {OutputOptionsWithDefaults} */ + (options && options.output); + /** @type {boolean} */ + this.bail = (options && options.bail) || false; + /** @type {boolean} */ + this.profile = (options && options.profile) || false; + + this.params = params; + this.mainTemplate = new MainTemplate(this.outputOptions, this); + this.chunkTemplate = new ChunkTemplate(this.outputOptions, this); + this.runtimeTemplate = new RuntimeTemplate( + this, + this.outputOptions, + this.requestShortener + ); + /** @type {ModuleTemplates} */ + this.moduleTemplates = { + javascript: new ModuleTemplate(this.runtimeTemplate, this) + }; + defineRemovedModuleTemplates(this.moduleTemplates); + + // We need to think how implement types here + /** @type {ModuleMemCaches | undefined} */ + this.moduleMemCaches = undefined; + /** @type {ModuleMemCaches | undefined} */ + this.moduleMemCaches2 = undefined; + /** @type {ModuleGraph} */ + this.moduleGraph = new ModuleGraph(); + /** @type {ChunkGraph} */ + this.chunkGraph = new ChunkGraph( + this.moduleGraph, + this.outputOptions.hashFunction + ); + /** @type {CodeGenerationResults | undefined} */ + this.codeGenerationResults = undefined; + + /** @type {AsyncQueue} */ + this.processDependenciesQueue = new AsyncQueue({ + name: "processDependencies", + parallelism: options.parallelism || 100, + processor: this._processModuleDependencies.bind(this) + }); + /** @type {AsyncQueue} */ + this.addModuleQueue = new AsyncQueue({ + name: "addModule", + parent: this.processDependenciesQueue, + getKey: (module) => module.identifier(), + processor: this._addModule.bind(this) + }); + /** @type {AsyncQueue} */ + this.factorizeQueue = new AsyncQueue({ + name: "factorize", + parent: this.addModuleQueue, + processor: this._factorizeModule.bind(this) + }); + /** @type {AsyncQueue} */ + this.buildQueue = new AsyncQueue({ + name: "build", + parent: this.factorizeQueue, + processor: this._buildModule.bind(this) + }); + /** @type {AsyncQueue} */ + this.rebuildQueue = new AsyncQueue({ + name: "rebuild", + parallelism: options.parallelism || 100, + processor: this._rebuildModule.bind(this) + }); + + /** + * Modules in value are building during the build of Module in key. + * Means value blocking key from finishing. + * Needed to detect build cycles. + * @type {WeakMap>} + */ + this.creatingModuleDuringBuild = new WeakMap(); + + /** @type {Map, EntryData>} */ + this.entries = new Map(); + /** @type {EntryData} */ + this.globalEntry = { + dependencies: [], + includeDependencies: [], + options: { + name: undefined + } + }; + /** @type {Map} */ + this.entrypoints = new Map(); + /** @type {Entrypoint[]} */ + this.asyncEntrypoints = []; + /** @type {Chunks} */ + this.chunks = new Set(); + /** @type {ChunkGroup[]} */ + this.chunkGroups = []; + /** @type {Map} */ + this.namedChunkGroups = new Map(); + /** @type {Map} */ + this.namedChunks = new Map(); + /** @type {Set} */ + this.modules = new Set(); + if (this._backCompat) { + arrayToSetDeprecation(this.chunks, "Compilation.chunks"); + arrayToSetDeprecation(this.modules, "Compilation.modules"); + } + /** + * @private + * @type {Map} + */ + this._modules = new Map(); + /** @type {Records | null} */ + this.records = null; + /** @type {string[]} */ + this.additionalChunkAssets = []; + /** @type {CompilationAssets} */ + this.assets = {}; + /** @type {Map} */ + this.assetsInfo = new Map(); + /** @type {Map>>} */ + this._assetsRelatedIn = new Map(); + /** @type {Error[]} */ + this.errors = []; + /** @type {Error[]} */ + this.warnings = []; + /** @type {Compilation[]} */ + this.children = []; + /** @type {Map} */ + this.logging = new Map(); + /** @type {Map} */ + this.dependencyFactories = new Map(); + /** @type {DependencyTemplates} */ + this.dependencyTemplates = new DependencyTemplates( + this.outputOptions.hashFunction + ); + /** @type {Record} */ + this.childrenCounters = {}; + /** @type {Set | null} */ + this.usedChunkIds = null; + /** @type {Set | null} */ + this.usedModuleIds = null; + /** @type {boolean} */ + this.needAdditionalPass = false; + /** @type {Set} */ + this._restoredUnsafeCacheModuleEntries = new Set(); + /** @type {Map} */ + this._restoredUnsafeCacheEntries = new Map(); + /** @type {WeakSet} */ + this.builtModules = new WeakSet(); + /** @type {WeakSet} */ + this.codeGeneratedModules = new WeakSet(); + /** @type {WeakSet} */ + this.buildTimeExecutedModules = new WeakSet(); + /** @type {Set} */ + this.emittedAssets = new Set(); + /** @type {Set} */ + this.comparedForEmitAssets = new Set(); + /** @type {FileSystemDependencies} */ + this.fileDependencies = new LazySet(); + /** @type {FileSystemDependencies} */ + this.contextDependencies = new LazySet(); + /** @type {FileSystemDependencies} */ + this.missingDependencies = new LazySet(); + /** @type {FileSystemDependencies} */ + this.buildDependencies = new LazySet(); + // TODO webpack 6 remove + /** + * @deprecated + * @type {{ add: (item: string) => FileSystemDependencies }} + */ + this.compilationDependencies = { + add: util.deprecate( + /** + * Handles the add callback for this hook. + * @param {string} item item + * @returns {FileSystemDependencies} file dependencies + */ + (item) => this.fileDependencies.add(item), + "Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)", + "DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES" + ) + }; + + this._modulesCache = this.getCache("Compilation/modules"); + this._assetsCache = this.getCache("Compilation/assets"); + this._codeGenerationCache = this.getCache("Compilation/codeGeneration"); + + const unsafeCache = options.module.unsafeCache; + /** @type {boolean} */ + this._unsafeCache = Boolean(unsafeCache); + /** @type {UnsafeCachePredicate} */ + this._unsafeCachePredicate = + typeof unsafeCache === "function" ? unsafeCache : () => true; + } + + getStats() { + return new Stats(this); + } + + /** + * Creates a stats options. + * @param {string | boolean | StatsOptions | undefined} optionsOrPreset stats option value + * @param {CreateStatsOptionsContext=} context context + * @returns {NormalizedStatsOptions} normalized options + */ + createStatsOptions(optionsOrPreset, context = {}) { + if (typeof optionsOrPreset === "boolean") { + optionsOrPreset = { + preset: optionsOrPreset === false ? "none" : "normal" + }; + } else if (typeof optionsOrPreset === "string") { + optionsOrPreset = { preset: optionsOrPreset }; + } + if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) { + // We use this method of shallow cloning this object to include + // properties in the prototype chain + /** @type {Partial} */ + const options = {}; + for (const key in optionsOrPreset) { + options[key] = optionsOrPreset[/** @type {keyof StatsOptions} */ (key)]; + } + if (options.preset !== undefined) { + this.hooks.statsPreset.for(options.preset).call(options, context); + } + this.hooks.statsNormalize.call(options, context); + return /** @type {NormalizedStatsOptions} */ (options); + } + /** @type {Partial} */ + const options = {}; + this.hooks.statsNormalize.call(options, context); + return /** @type {NormalizedStatsOptions} */ (options); + } + + /** + * Creates a stats factory. + * @param {NormalizedStatsOptions} options options + * @returns {StatsFactory} the stats factory + */ + createStatsFactory(options) { + const statsFactory = new StatsFactory(); + this.hooks.statsFactory.call(statsFactory, options); + return statsFactory; + } + + /** + * Creates a stats printer. + * @param {NormalizedStatsOptions} options options + * @returns {StatsPrinter} the stats printer + */ + createStatsPrinter(options) { + const statsPrinter = new StatsPrinter(); + this.hooks.statsPrinter.call(statsPrinter, options); + return statsPrinter; + } + + /** + * Returns the cache facade instance. + * @param {string} name cache name + * @returns {CacheFacade} the cache facade instance + */ + getCache(name) { + return this.compiler.getCache(name); + } + + /** + * Returns a logger with that name. + * @param {string | (() => string)} name name of the logger, or function called once to get the logger name + * @returns {Logger} a logger with that name + */ + getLogger(name) { + if (!name) { + throw new TypeError("Compilation.getLogger(name) called without a name"); + } + /** @type {LogEntry[] | undefined} */ + let logEntries; + return new Logger( + (type, args) => { + if (typeof name === "function") { + name = name(); + if (!name) { + throw new TypeError( + "Compilation.getLogger(name) called with a function not returning a name" + ); + } + } + /** @type {LogEntry["trace"]} */ + let trace; + switch (type) { + case LogType.warn: + case LogType.error: + case LogType.trace: + trace = ErrorHelpers.cutOffLoaderExecution( + /** @type {string} */ (new Error("Trace").stack) + ) + .split("\n") + .slice(3); + break; + } + /** @type {LogEntry} */ + const logEntry = { + time: Date.now(), + type, + args, + trace + }; + /* eslint-disable no-console */ + if (this.hooks.log.call(name, logEntry) === undefined) { + if ( + logEntry.type === LogType.profileEnd && + typeof console.profileEnd === "function" + ) { + console.profileEnd( + `[${name}] ${/** @type {NonNullable} */ (logEntry.args)[0]}` + ); + } + if (logEntries === undefined) { + logEntries = this.logging.get(name); + if (logEntries === undefined) { + logEntries = []; + this.logging.set(name, logEntries); + } + } + logEntries.push(logEntry); + if ( + logEntry.type === LogType.profile && + typeof console.profile === "function" + ) { + console.profile( + `[${name}] ${ + /** @type {NonNullable} */ + (logEntry.args)[0] + }` + ); + } + /* eslint-enable no-console */ + } + }, + (childName) => { + if (typeof name === "function") { + if (typeof childName === "function") { + return this.getLogger(() => { + if (typeof name === "function") { + name = name(); + if (!name) { + throw new TypeError( + "Compilation.getLogger(name) called with a function not returning a name" + ); + } + } + if (typeof childName === "function") { + childName = childName(); + if (!childName) { + throw new TypeError( + "Logger.getChildLogger(name) called with a function not returning a name" + ); + } + } + return `${name}/${childName}`; + }); + } + return this.getLogger(() => { + if (typeof name === "function") { + name = name(); + if (!name) { + throw new TypeError( + "Compilation.getLogger(name) called with a function not returning a name" + ); + } + } + return `${name}/${childName}`; + }); + } + if (typeof childName === "function") { + return this.getLogger(() => { + if (typeof childName === "function") { + childName = childName(); + if (!childName) { + throw new TypeError( + "Logger.getChildLogger(name) called with a function not returning a name" + ); + } + } + return `${name}/${childName}`; + }); + } + return this.getLogger(`${name}/${childName}`); + } + ); + } + + /** + * Adds the provided module to the compilation. + * @param {Module} module module to be added that was created + * @param {ModuleCallback} callback returns the module in the compilation, + * it could be the passed one (if new), or an already existing in the compilation + * @returns {void} + */ + addModule(module, callback) { + this.addModuleQueue.add(module, callback); + } + + /** + * Adds the provided module to the compilation. + * @param {Module} module module to be added that was created + * @param {ModuleCallback} callback returns the module in the compilation, + * it could be the passed one (if new), or an already existing in the compilation + * @returns {void} + */ + _addModule(module, callback) { + const identifier = module.identifier(); + const alreadyAddedModule = this._modules.get(identifier); + if (alreadyAddedModule) { + return callback(null, alreadyAddedModule); + } + + const currentProfile = this.profile + ? this.moduleGraph.getProfile(module) + : undefined; + if (currentProfile !== undefined) { + currentProfile.markRestoringStart(); + } + + this._modulesCache.get(identifier, null, (err, cacheModule) => { + if (err) return callback(new ModuleRestoreError(module, err)); + + if (currentProfile !== undefined) { + currentProfile.markRestoringEnd(); + currentProfile.markIntegrationStart(); + } + + if (cacheModule) { + cacheModule.updateCacheModule(module); + + module = cacheModule; + } + this._modules.set(identifier, module); + this.modules.add(module); + if (this._backCompat) { + ModuleGraph.setModuleGraphForModule(module, this.moduleGraph); + } + if (currentProfile !== undefined) { + currentProfile.markIntegrationEnd(); + } + callback(null, module); + }); + } + + /** + * Fetches a module from a compilation by its identifier + * @param {Module} module the module provided + * @returns {Module} the module requested + */ + getModule(module) { + const identifier = module.identifier(); + return /** @type {Module} */ (this._modules.get(identifier)); + } + + /** + * Attempts to search for a module by its identifier + * @param {string} identifier identifier (usually path) for module + * @returns {Module | undefined} attempt to search for module and return it, else undefined + */ + findModule(identifier) { + return this._modules.get(identifier); + } + + /** + * Schedules a build of the module object + * @param {Module} module module to be built + * @param {ModuleCallback} callback the callback + * @returns {void} + */ + buildModule(module, callback) { + this.buildQueue.add(module, callback); + } + + /** + * Builds the module object + * @param {Module} module module to be built + * @param {ModuleCallback} callback the callback + * @returns {void} + */ + _buildModule(module, callback) { + const currentProfile = this.profile + ? this.moduleGraph.getProfile(module) + : undefined; + if (currentProfile !== undefined) { + currentProfile.markBuildingStart(); + } + + module.needBuild( + { + compilation: this, + fileSystemInfo: this.fileSystemInfo, + valueCacheVersions: this.valueCacheVersions + }, + (err, needBuild) => { + if (err) return callback(err); + + if (!needBuild) { + if (currentProfile !== undefined) { + currentProfile.markBuildingEnd(); + } + this.hooks.stillValidModule.call(module); + return callback(); + } + + this.hooks.buildModule.call(module); + this.builtModules.add(module); + module.build( + this.options, + this, + this.resolverFactory.get("normal", module.resolveOptions), + /** @type {InputFileSystem} */ + (this.inputFileSystem), + (err) => { + if (currentProfile !== undefined) { + currentProfile.markBuildingEnd(); + } + if (err) { + this.hooks.failedModule.call(module, err); + return callback(err); + } + if (currentProfile !== undefined) { + currentProfile.markStoringStart(); + } + this._modulesCache.store( + module.identifier(), + null, + module, + (err) => { + if (currentProfile !== undefined) { + currentProfile.markStoringEnd(); + } + if (err) { + this.hooks.failedModule.call( + module, + /** @type {WebpackError} */ (err) + ); + return callback(new ModuleStoreError(module, err)); + } + this.hooks.succeedModule.call(module); + return callback(); + } + ); + } + ); + } + ); + } + + /** + * Process module dependencies. + * @param {Module} module to be processed for deps + * @param {ModuleCallback} callback callback to be triggered + * @returns {void} + */ + processModuleDependencies(module, callback) { + this.processDependenciesQueue.add(module, callback); + } + + /** + * Process module dependencies non recursive. + * @param {Module} module to be processed for deps + * @returns {void} + */ + processModuleDependenciesNonRecursive(module) { + /** + * Process dependencies block. + * @param {DependenciesBlock} block block + */ + const processDependenciesBlock = (block) => { + if (block.dependencies) { + let i = 0; + for (const dep of block.dependencies) { + this.moduleGraph.setParents(dep, block, module, i++); + } + } + if (block.blocks) { + for (const b of block.blocks) processDependenciesBlock(b); + } + }; + + processDependenciesBlock(module); + } + + /** + * Process module dependencies. + * @param {Module} module to be processed for deps + * @param {ModuleCallback} callback callback to be triggered + * @returns {void} + */ + _processModuleDependencies(module, callback) { + /** @type {{ factory: ModuleFactory, dependencies: Dependency[], context: string | undefined, originModule: Module | null }[]} */ + const sortedDependencies = []; + /** @type {boolean} */ + const hasLowPriorityDependencies = module.dependencies.some( + Dependency.isLowPriorityDependency + ); + + /** @type {DependenciesBlock} */ + let currentBlock; + + /** @type {Map>} */ + let dependencies; + /** @type {DependencyConstructor} */ + let factoryCacheKey; + /** @type {ModuleFactory} */ + let factoryCacheKey2; + /** @typedef {Map} FactoryCacheValue */ + /** @type {FactoryCacheValue | undefined} */ + let factoryCacheValue; + /** @type {string} */ + let listCacheKey1; + /** @type {string} */ + let listCacheKey2; + /** @type {Dependency[]} */ + let listCacheValue; + + let inProgressSorting = 1; + let inProgressTransitive = 1; + + /** + * On dependencies sorted. + * @param {WebpackError=} err error + * @returns {void} + */ + const onDependenciesSorted = (err) => { + if (err) return callback(err); + + // early exit without changing parallelism back and forth + if (sortedDependencies.length === 0 && inProgressTransitive === 1) { + return callback(); + } + + // This is nested so we need to allow one additional task + this.processDependenciesQueue.increaseParallelism(); + + for (const item of sortedDependencies) { + inProgressTransitive++; + // eslint-disable-next-line no-loop-func + this.handleModuleCreation(item, (err) => { + // In V8, the Error objects keep a reference to the functions on the stack. These warnings & + // errors are created inside closures that keep a reference to the Compilation, so errors are + // leaking the Compilation object. + if (err && this.bail) { + if (inProgressTransitive <= 0) return; + inProgressTransitive = -1; + // eslint-disable-next-line no-self-assign + err.stack = err.stack; + onTransitiveTasksFinished(err); + return; + } + if (--inProgressTransitive === 0) onTransitiveTasksFinished(); + }); + } + if (--inProgressTransitive === 0) onTransitiveTasksFinished(); + }; + + /** + * On transitive tasks finished. + * @param {WebpackError=} err error + * @returns {void} + */ + const onTransitiveTasksFinished = (err) => { + if (err) return callback(err); + this.processDependenciesQueue.decreaseParallelism(); + + return callback(); + }; + + /** + * Process dependency. + * @param {Dependency} dep dependency + * @param {number} index index in block + * @returns {void} + */ + const processDependency = (dep, index) => { + this.moduleGraph.setParents(dep, currentBlock, module, index); + if (this._unsafeCache) { + try { + const unsafeCachedModule = unsafeCacheDependencies.get(dep); + if (unsafeCachedModule === null) return; + if (unsafeCachedModule !== undefined) { + if ( + this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule) + ) { + this._handleExistingModuleFromUnsafeCache( + module, + dep, + unsafeCachedModule + ); + return; + } + const identifier = unsafeCachedModule.identifier(); + const cachedModule = + this._restoredUnsafeCacheEntries.get(identifier); + if (cachedModule !== undefined) { + // update unsafe cache to new module + unsafeCacheDependencies.set(dep, cachedModule); + this._handleExistingModuleFromUnsafeCache( + module, + dep, + cachedModule + ); + return; + } + inProgressSorting++; + this._modulesCache.get(identifier, null, (err, cachedModule) => { + if (err) { + if (inProgressSorting <= 0) return; + inProgressSorting = -1; + onDependenciesSorted(/** @type {WebpackError} */ (err)); + return; + } + try { + if (!this._restoredUnsafeCacheEntries.has(identifier)) { + const data = unsafeCacheData.get(cachedModule); + if (data === undefined) { + processDependencyForResolving(dep); + if (--inProgressSorting === 0) onDependenciesSorted(); + return; + } + if (cachedModule !== unsafeCachedModule) { + unsafeCacheDependencies.set(dep, cachedModule); + } + cachedModule.restoreFromUnsafeCache( + data, + this.params.normalModuleFactory, + this.params + ); + this._restoredUnsafeCacheEntries.set( + identifier, + cachedModule + ); + this._restoredUnsafeCacheModuleEntries.add(cachedModule); + if (!this.modules.has(cachedModule)) { + inProgressTransitive++; + this._handleNewModuleFromUnsafeCache( + module, + dep, + cachedModule, + (err) => { + if (err) { + if (inProgressTransitive <= 0) return; + inProgressTransitive = -1; + onTransitiveTasksFinished(err); + } + if (--inProgressTransitive === 0) { + return onTransitiveTasksFinished(); + } + } + ); + if (--inProgressSorting === 0) onDependenciesSorted(); + return; + } + } + if (unsafeCachedModule !== cachedModule) { + unsafeCacheDependencies.set(dep, cachedModule); + } + this._handleExistingModuleFromUnsafeCache( + module, + dep, + cachedModule + ); // a3 + } catch (err) { + if (inProgressSorting <= 0) return; + inProgressSorting = -1; + onDependenciesSorted(/** @type {WebpackError} */ (err)); + return; + } + if (--inProgressSorting === 0) onDependenciesSorted(); + }); + return; + } + } catch (err) { + // eslint-disable-next-line no-console + console.error(err); + } + } + processDependencyForResolving(dep); + }; + + /** + * Process dependency for resolving. + * @param {Dependency} dep dependency + * @returns {void} + */ + const processDependencyForResolving = (dep) => { + const resourceIdent = dep.getResourceIdentifier(); + if (resourceIdent !== undefined && resourceIdent !== null) { + const category = dep.category; + const constructor = + /** @type {DependencyConstructor} */ + (dep.constructor); + if (factoryCacheKey === constructor) { + // Fast path 1: same constructor as prev item + if (listCacheKey1 === category && listCacheKey2 === resourceIdent) { + // Super fast path 1: also same resource + listCacheValue.push(dep); + return; + } + } else { + const factory = this.dependencyFactories.get(constructor); + if (factory === undefined) { + throw new Error( + `No module factory available for dependency type: ${constructor.name}` + ); + } + if (factoryCacheKey2 === factory) { + // Fast path 2: same factory as prev item + factoryCacheKey = constructor; + if (listCacheKey1 === category && listCacheKey2 === resourceIdent) { + // Super fast path 2: also same resource + listCacheValue.push(dep); + return; + } + } else { + // Slow path + if (factoryCacheKey2 !== undefined) { + // Archive last cache entry + if (dependencies === undefined) dependencies = new Map(); + dependencies.set( + factoryCacheKey2, + /** @type {FactoryCacheValue} */ (factoryCacheValue) + ); + factoryCacheValue = dependencies.get(factory); + if (factoryCacheValue === undefined) { + factoryCacheValue = new Map(); + } + } else { + factoryCacheValue = new Map(); + } + factoryCacheKey = constructor; + factoryCacheKey2 = factory; + } + } + // Here webpack is using heuristic that assumes + // mostly esm dependencies would be used + // so we don't allocate extra string for them + const cacheKey = + category === esmDependencyCategory + ? resourceIdent + : `${category}${resourceIdent}`; + let list = /** @type {FactoryCacheValue} */ (factoryCacheValue).get( + cacheKey + ); + if (list === undefined) { + /** @type {FactoryCacheValue} */ + (factoryCacheValue).set(cacheKey, (list = [])); + const newItem = { + factory: factoryCacheKey2, + dependencies: list, + context: dep.getContext(), + originModule: module + }; + if (hasLowPriorityDependencies) { + let insertIndex = sortedDependencies.length; + while (insertIndex > 0) { + const item = sortedDependencies[insertIndex - 1]; + const isAllLowPriorityDependencies = item.dependencies.every( + Dependency.isLowPriorityDependency + ); + if (isAllLowPriorityDependencies) { + insertIndex--; + } else { + break; + } + } + sortedDependencies.splice(insertIndex, 0, newItem); + } else { + sortedDependencies.push(newItem); + } + } + list.push(dep); + listCacheKey1 = category; + listCacheKey2 = resourceIdent; + listCacheValue = list; + } + }; + + try { + /** @type {DependenciesBlock[]} */ + const queue = [module]; + do { + const block = /** @type {DependenciesBlock} */ (queue.pop()); + if (block.dependencies) { + currentBlock = block; + let i = 0; + for (const dep of block.dependencies) processDependency(dep, i++); + } + if (block.blocks) { + for (const b of block.blocks) queue.push(b); + } + } while (queue.length !== 0); + } catch (err) { + return callback(/** @type {WebpackError} */ (err)); + } + + if (--inProgressSorting === 0) onDependenciesSorted(); + } + + /** + * Handle new module from unsafe cache. + * @private + * @param {Module} originModule original module + * @param {Dependency} dependency dependency + * @param {Module} module cached module + * @param {Callback} callback callback + */ + _handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) { + const moduleGraph = this.moduleGraph; + + moduleGraph.setResolvedModule(originModule, dependency, module); + + moduleGraph.setIssuerIfUnset( + module, + originModule !== undefined ? originModule : null + ); + + this._modules.set(module.identifier(), module); + this.modules.add(module); + if (this._backCompat) { + ModuleGraph.setModuleGraphForModule(module, this.moduleGraph); + } + + this._handleModuleBuildAndDependencies( + originModule, + module, + true, + false, + callback + ); + } + + /** + * Handle existing module from unsafe cache. + * @private + * @param {Module} originModule original modules + * @param {Dependency} dependency dependency + * @param {Module} module cached module + */ + _handleExistingModuleFromUnsafeCache(originModule, dependency, module) { + const moduleGraph = this.moduleGraph; + + moduleGraph.setResolvedModule(originModule, dependency, module); + } + + /** + * Processes the provided factorize module option. + * @param {FactorizeModuleOptions} options options + * @param {ModuleOrModuleFactoryResultCallback} callback callback + * @returns {void} + */ + _factorizeModule( + { + currentProfile, + factory, + dependencies, + originModule, + factoryResult, + contextInfo, + context + }, + callback + ) { + if (currentProfile !== undefined) { + currentProfile.markFactoryStart(); + } + factory.create( + { + contextInfo: { + issuer: originModule + ? /** @type {NameForCondition} */ (originModule.nameForCondition()) + : "", + issuerLayer: originModule ? originModule.layer : null, + compiler: this.compiler.name, + ...contextInfo + }, + resolveOptions: originModule ? originModule.resolveOptions : undefined, + context: + context || + (originModule + ? /** @type {string} */ (originModule.context) + : this.compiler.context), + dependencies + }, + (err, result) => { + if (result) { + // TODO webpack 6: remove + // For backward-compat + if (result.module === undefined && result instanceof Module) { + result = { + module: result + }; + } + if (!factoryResult) { + const { + fileDependencies, + contextDependencies, + missingDependencies + } = result; + if (fileDependencies) { + this.fileDependencies.addAll(fileDependencies); + } + if (contextDependencies) { + this.contextDependencies.addAll(contextDependencies); + } + if (missingDependencies) { + this.missingDependencies.addAll(missingDependencies); + } + } + } + if (err) { + const notFoundError = new ModuleNotFoundError( + originModule, + err, + /** @type {DependencyLocation} */ + (dependencies.map((d) => d.loc).find(Boolean)) + ); + return callback(notFoundError, factoryResult ? result : undefined); + } + if (!result) { + return callback(); + } + + if (currentProfile !== undefined) { + currentProfile.markFactoryEnd(); + } + + callback(null, factoryResult ? result : result.module); + } + ); + } + + /** + * Processes the provided module callback. + * @overload + * @param {FactorizeModuleOptions & { factoryResult?: false }} options options + * @param {ModuleCallback} callback callback + * @returns {void} + */ + /** + * Processes the provided module factory result callback. + * @overload + * @param {FactorizeModuleOptions & { factoryResult: true }} options options + * @param {ModuleFactoryResultCallback} callback callback + * @returns {void} + */ + /** + * Processes the provided |. + * @param {FactorizeModuleOptions & { factoryResult?: false } | FactorizeModuleOptions & { factoryResult: true }} options options + * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback + */ + factorizeModule(options, callback) { + this.factorizeQueue.add( + options, + /** @type {ModuleOrModuleFactoryResultCallback} */ + (callback) + ); + } + + /** + * Defines the handle module creation options type used by this module. + * @typedef {object} HandleModuleCreationOptions + * @property {ModuleFactory} factory + * @property {Dependency[]} dependencies + * @property {Module | null} originModule + * @property {Partial=} contextInfo + * @property {string=} context + * @property {boolean=} recursive recurse into dependencies of the created module + * @property {boolean=} connectOrigin connect the resolved module with the origin module + * @property {boolean=} checkCycle check the cycle dependencies of the created module + */ + + /** + * Handle module creation. + * @param {HandleModuleCreationOptions} options options object + * @param {ModuleCallback} callback callback + * @returns {void} + */ + handleModuleCreation( + { + factory, + dependencies, + originModule, + contextInfo, + context, + recursive = true, + connectOrigin = recursive, + checkCycle = !recursive + }, + callback + ) { + const moduleGraph = this.moduleGraph; + + const currentProfile = this.profile ? new ModuleProfile() : undefined; + + this.factorizeModule( + { + currentProfile, + factory, + dependencies, + factoryResult: true, + originModule, + contextInfo, + context + }, + (err, factoryResult) => { + const applyFactoryResultDependencies = () => { + const { fileDependencies, contextDependencies, missingDependencies } = + /** @type {ModuleFactoryResult} */ (factoryResult); + if (fileDependencies) { + this.fileDependencies.addAll(fileDependencies); + } + if (contextDependencies) { + this.contextDependencies.addAll(contextDependencies); + } + if (missingDependencies) { + this.missingDependencies.addAll(missingDependencies); + } + }; + if (err) { + if (factoryResult) applyFactoryResultDependencies(); + if (dependencies.every((d) => d.optional)) { + this.warnings.push(err); + return callback(); + } + this.errors.push(err); + return callback(err); + } + + const newModule = + /** @type {ModuleFactoryResult} */ + (factoryResult).module; + + if (!newModule) { + applyFactoryResultDependencies(); + return callback(); + } + + if (currentProfile !== undefined) { + moduleGraph.setProfile(newModule, currentProfile); + } + + this.addModule(newModule, (err, _module) => { + if (err) { + applyFactoryResultDependencies(); + if (!err.module) { + err.module = _module; + } + this.errors.push(err); + + return callback(err); + } + + const module = + /** @type {ModuleWithRestoreFromUnsafeCache} */ + (_module); + + if ( + this._unsafeCache && + /** @type {ModuleFactoryResult} */ + (factoryResult).cacheable !== false && + module.restoreFromUnsafeCache && + this._unsafeCachePredicate(module) + ) { + const unsafeCacheableModule = + /** @type {ModuleWithRestoreFromUnsafeCache} */ + (module); + for (const dependency of dependencies) { + moduleGraph.setResolvedModule( + connectOrigin ? originModule : null, + dependency, + unsafeCacheableModule + ); + unsafeCacheDependencies.set(dependency, unsafeCacheableModule); + } + if (!unsafeCacheData.has(unsafeCacheableModule)) { + unsafeCacheData.set( + unsafeCacheableModule, + unsafeCacheableModule.getUnsafeCacheData() + ); + } + } else { + applyFactoryResultDependencies(); + for (const dependency of dependencies) { + moduleGraph.setResolvedModule( + connectOrigin ? originModule : null, + dependency, + module + ); + } + } + + moduleGraph.setIssuerIfUnset( + module, + originModule !== undefined ? originModule : null + ); + if (module !== newModule && currentProfile !== undefined) { + const otherProfile = moduleGraph.getProfile(module); + if (otherProfile !== undefined) { + currentProfile.mergeInto(otherProfile); + } else { + moduleGraph.setProfile(module, currentProfile); + } + } + + this._handleModuleBuildAndDependencies( + originModule, + module, + recursive, + checkCycle, + callback + ); + }); + } + ); + } + + /** + * Handle module build and dependencies. + * @private + * @param {Module | null} originModule original module + * @param {Module} module module + * @param {boolean} recursive true if make it recursive, otherwise false + * @param {boolean} checkCycle true if need to check cycle, otherwise false + * @param {ModuleCallback} callback callback + * @returns {void} + */ + _handleModuleBuildAndDependencies( + originModule, + module, + recursive, + checkCycle, + callback + ) { + // Check for cycles when build is trigger inside another build + /** @type {Set | undefined} */ + let creatingModuleDuringBuildSet; + if ( + checkCycle && + this.buildQueue.isProcessing(/** @type {Module} */ (originModule)) + ) { + // Track build dependency + creatingModuleDuringBuildSet = this.creatingModuleDuringBuild.get( + /** @type {Module} */ + (originModule) + ); + if (creatingModuleDuringBuildSet === undefined) { + /** @type {Set} */ + creatingModuleDuringBuildSet = new Set(); + this.creatingModuleDuringBuild.set( + /** @type {Module} */ + (originModule), + creatingModuleDuringBuildSet + ); + } + creatingModuleDuringBuildSet.add(module); + + // When building is blocked by another module + // search for a cycle, cancel the cycle by throwing + // an error (otherwise this would deadlock) + const blockReasons = this.creatingModuleDuringBuild.get(module); + if (blockReasons !== undefined) { + const set = new Set(blockReasons); + for (const item of set) { + const blockReasons = this.creatingModuleDuringBuild.get(item); + if (blockReasons !== undefined) { + for (const m of blockReasons) { + if (m === module) { + return callback(new BuildCycleError(module)); + } + set.add(m); + } + } + } + } + } + + this.buildModule(module, (err) => { + if (creatingModuleDuringBuildSet !== undefined) { + creatingModuleDuringBuildSet.delete(module); + } + if (err) { + if (!err.module) { + err.module = module; + } + this.errors.push(err); + + return callback(err); + } + + if (!recursive) { + this.processModuleDependenciesNonRecursive(module); + callback(null, module); + return; + } + + // This avoids deadlocks for circular dependencies + if (this.processDependenciesQueue.isProcessing(module)) { + return callback(null, module); + } + + this.processModuleDependencies(module, (err) => { + if (err) { + return callback(err); + } + callback(null, module); + }); + }); + } + + /** + * Adds the provided string to the compilation. + * @param {string} context context string path + * @param {Dependency} dependency dependency used to create Module chain + * @param {ModuleCallback} callback callback for when module chain is complete + * @returns {void} will throw if dependency instance is not a valid Dependency + */ + addModuleChain(context, dependency, callback) { + return this.addModuleTree({ context, dependency }, callback); + } + + /** + * Adds the provided object to the compilation. + * @param {object} options options + * @param {string} options.context context string path + * @param {Dependency} options.dependency dependency used to create Module chain + * @param {Partial=} options.contextInfo additional context info for the root module + * @param {ModuleCallback} callback callback for when module chain is complete + * @returns {void} will throw if dependency instance is not a valid Dependency + */ + addModuleTree({ context, dependency, contextInfo }, callback) { + if ( + typeof dependency !== "object" || + dependency === null || + !dependency.constructor + ) { + return callback( + new WebpackError("Parameter 'dependency' must be a Dependency") + ); + } + const Dep = + /** @type {DependencyConstructor} */ + (dependency.constructor); + const moduleFactory = this.dependencyFactories.get(Dep); + if (!moduleFactory) { + return callback( + new WebpackError( + `No dependency factory available for this dependency type: ${dependency.constructor.name}` + ) + ); + } + + this.handleModuleCreation( + { + factory: moduleFactory, + dependencies: [dependency], + originModule: null, + contextInfo, + context + }, + (err, result) => { + if (err && this.bail) { + callback(err); + this.buildQueue.stop(); + this.rebuildQueue.stop(); + this.processDependenciesQueue.stop(); + this.factorizeQueue.stop(); + } else if (!err && result) { + callback(null, result); + } else { + callback(); + } + } + ); + } + + /** + * Adds the provided string to the compilation. + * @param {string} context context path for entry + * @param {Dependency} entry entry dependency that should be followed + * @param {string | EntryOptions} optionsOrName options or deprecated name of entry + * @param {ModuleCallback} callback callback function + * @returns {void} returns + */ + addEntry(context, entry, optionsOrName, callback) { + // TODO webpack 6 remove + const options = + typeof optionsOrName === "object" + ? optionsOrName + : { name: optionsOrName }; + + this._addEntryItem(context, entry, "dependencies", options, callback); + } + + /** + * Adds the provided string to the compilation. + * @param {string} context context path for entry + * @param {Dependency} dependency dependency that should be followed + * @param {EntryOptions} options options + * @param {ModuleCallback} callback callback function + * @returns {void} returns + */ + addInclude(context, dependency, options, callback) { + this._addEntryItem( + context, + dependency, + "includeDependencies", + options, + callback + ); + } + + /** + * Adds the provided string to the compilation. + * @param {string} context context path for entry + * @param {Dependency} entry entry dependency that should be followed + * @param {"dependencies" | "includeDependencies"} target type of entry + * @param {EntryOptions} options options + * @param {ModuleCallback} callback callback function + * @returns {void} returns + */ + _addEntryItem(context, entry, target, options, callback) { + const { name } = options; + /** @type {EntryData | undefined} */ + let entryData = + name !== undefined ? this.entries.get(name) : this.globalEntry; + if (entryData === undefined) { + entryData = { + dependencies: [], + includeDependencies: [], + options: { + name: undefined, + ...options + } + }; + entryData[target].push(entry); + this.entries.set( + /** @type {NonNullable} */ + (name), + entryData + ); + } else { + entryData[target].push(entry); + for (const key_ of Object.keys(options)) { + const key = /** @type {keyof EntryOptions} */ (key_); + if (options[key] === undefined) continue; + if (entryData.options[key] === options[key]) continue; + if ( + Array.isArray(entryData.options[key]) && + Array.isArray(options[key]) && + arrayEquals(entryData.options[key], options[key]) + ) { + continue; + } + if (entryData.options[key] === undefined) { + /** @type {EntryOptions[keyof EntryOptions]} */ + (entryData.options[key]) = options[key]; + } else { + return callback( + new WebpackError( + `Conflicting entry option ${key} = ${entryData.options[key]} vs ${options[key]}` + ) + ); + } + } + } + + this.hooks.addEntry.call(entry, options); + + this.addModuleTree( + { + context, + dependency: entry, + contextInfo: entryData.options.layer + ? { issuerLayer: entryData.options.layer } + : undefined + }, + (err, module) => { + if (err) { + this.hooks.failedEntry.call(entry, options, err); + return callback(err); + } + this.hooks.succeedEntry.call( + entry, + options, + /** @type {Module} */ + (module) + ); + return callback(null, module); + } + ); + } + + /** + * Processes the provided module. + * @param {Module} module module to be rebuilt + * @param {ModuleCallback} callback callback when module finishes rebuilding + * @returns {void} + */ + rebuildModule(module, callback) { + this.rebuildQueue.add(module, callback); + } + + /** + * Processes the provided module. + * @param {Module} module module to be rebuilt + * @param {ModuleCallback} callback callback when module finishes rebuilding + * @returns {void} + */ + _rebuildModule(module, callback) { + this.hooks.rebuildModule.call(module); + const oldDependencies = [...module.dependencies]; + const oldBlocks = [...module.blocks]; + module.invalidateBuild(); + this.buildQueue.invalidate(module); + this.buildModule(module, (err) => { + if (err) { + return this.hooks.finishRebuildingModule.callAsync(module, (err2) => { + if (err2) { + callback( + makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule") + ); + return; + } + callback(err); + }); + } + + this.processDependenciesQueue.invalidate(module); + this.moduleGraph.unfreeze(); + this.processModuleDependencies(module, (err) => { + if (err) return callback(err); + this.removeReasonsOfDependencyBlock(module, { + dependencies: oldDependencies, + blocks: oldBlocks + }); + this.hooks.finishRebuildingModule.callAsync(module, (err2) => { + if (err2) { + callback( + makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule") + ); + return; + } + callback(null, module); + }); + }); + }); + } + + /** + * Compute affected modules. + * @private + * @param {Set} modules modules + */ + _computeAffectedModules(modules) { + const moduleMemCacheCache = this.compiler.moduleMemCaches; + if (!moduleMemCacheCache) return; + if (!this.moduleMemCaches) { + this.moduleMemCaches = new Map(); + this.moduleGraph.setModuleMemCaches(this.moduleMemCaches); + } + const { moduleGraph, moduleMemCaches } = this; + /** @type {Set} */ + const affectedModules = new Set(); + /** @type {Set} */ + const infectedModules = new Set(); + let statNew = 0; + let statChanged = 0; + let statUnchanged = 0; + let statReferencesChanged = 0; + let statWithoutBuild = 0; + + /** + * Compute references. + * @param {Module} module module + * @returns {WeakReferences | undefined} references + */ + const computeReferences = (module) => { + /** @type {WeakReferences | undefined} */ + let references; + for (const connection of moduleGraph.getOutgoingConnections(module)) { + const d = connection.dependency; + const m = connection.module; + if (!d || !m || unsafeCacheDependencies.has(d)) continue; + if (references === undefined) references = new WeakMap(); + references.set(d, m); + } + return references; + }; + + /** + * Compares references. + * @param {Module} module the module + * @param {WeakReferences | undefined} references references + * @returns {boolean} true, when the references differ + */ + const compareReferences = (module, references) => { + if (references === undefined) return true; + for (const connection of moduleGraph.getOutgoingConnections(module)) { + const d = connection.dependency; + if (!d) continue; + const entry = references.get(d); + if (entry === undefined) continue; + if (entry !== connection.module) return false; + } + return true; + }; + + const modulesWithoutCache = new Set(modules); + for (const [module, cachedMemCache] of moduleMemCacheCache) { + if (modulesWithoutCache.has(module)) { + const buildInfo = module.buildInfo; + if (buildInfo) { + if (cachedMemCache.buildInfo !== buildInfo) { + // use a new one + /** @type {MemCache} */ + const memCache = new WeakTupleMap(); + moduleMemCaches.set(module, memCache); + affectedModules.add(module); + cachedMemCache.buildInfo = buildInfo; + cachedMemCache.references = computeReferences(module); + cachedMemCache.memCache = memCache; + statChanged++; + } else if (!compareReferences(module, cachedMemCache.references)) { + // use a new one + /** @type {MemCache} */ + const memCache = new WeakTupleMap(); + moduleMemCaches.set(module, memCache); + affectedModules.add(module); + cachedMemCache.references = computeReferences(module); + cachedMemCache.memCache = memCache; + statReferencesChanged++; + } else { + // keep the old mem cache + moduleMemCaches.set(module, cachedMemCache.memCache); + statUnchanged++; + } + } else { + infectedModules.add(module); + moduleMemCacheCache.delete(module); + statWithoutBuild++; + } + modulesWithoutCache.delete(module); + } else { + moduleMemCacheCache.delete(module); + } + } + + for (const module of modulesWithoutCache) { + const buildInfo = module.buildInfo; + if (buildInfo) { + // create a new entry + const memCache = new WeakTupleMap(); + moduleMemCacheCache.set(module, { + buildInfo, + references: computeReferences(module), + memCache + }); + moduleMemCaches.set(module, memCache); + affectedModules.add(module); + statNew++; + } else { + infectedModules.add(module); + statWithoutBuild++; + } + } + + /** + * Reduce affect type. + * @param {Readonly} connections connections + * @returns {symbol | boolean} result + */ + const reduceAffectType = (connections) => { + let affected = false; + for (const { dependency } of connections) { + if (!dependency) continue; + const type = dependency.couldAffectReferencingModule(); + if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE; + if (type === false) continue; + affected = true; + } + return affected; + }; + /** @type {Set} */ + const directOnlyInfectedModules = new Set(); + for (const module of infectedModules) { + for (const [ + referencingModule, + connections + ] of moduleGraph.getIncomingConnectionsByOriginModule(module)) { + if (!referencingModule) continue; + if (infectedModules.has(referencingModule)) continue; + const type = reduceAffectType(connections); + if (!type) continue; + if (type === true) { + directOnlyInfectedModules.add(referencingModule); + } else { + infectedModules.add(referencingModule); + } + } + } + for (const module of directOnlyInfectedModules) infectedModules.add(module); + /** @type {Set} */ + const directOnlyAffectModules = new Set(); + for (const module of affectedModules) { + for (const [ + referencingModule, + connections + ] of moduleGraph.getIncomingConnectionsByOriginModule(module)) { + if (!referencingModule) continue; + if (infectedModules.has(referencingModule)) continue; + if (affectedModules.has(referencingModule)) continue; + const type = reduceAffectType(connections); + if (!type) continue; + if (type === true) { + directOnlyAffectModules.add(referencingModule); + } else { + affectedModules.add(referencingModule); + } + /** @type {MemCache} */ + const memCache = new WeakTupleMap(); + const cache = + /** @type {ModuleMemCachesItem} */ + (moduleMemCacheCache.get(referencingModule)); + cache.memCache = memCache; + moduleMemCaches.set(referencingModule, memCache); + } + } + for (const module of directOnlyAffectModules) affectedModules.add(module); + this.logger.log( + `${Math.round( + (100 * (affectedModules.size + infectedModules.size)) / + this.modules.size + )}% (${affectedModules.size} affected + ${ + infectedModules.size + } infected of ${ + this.modules.size + }) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)` + ); + } + + _computeAffectedModulesWithChunkGraph() { + const { moduleMemCaches } = this; + if (!moduleMemCaches) return; + const moduleMemCaches2 = (this.moduleMemCaches2 = new Map()); + const { moduleGraph, chunkGraph } = this; + const key = "memCache2"; + let statUnchanged = 0; + let statChanged = 0; + let statNew = 0; + /** + * Compute references. + * @param {Module} module module + * @returns {References} references + */ + const computeReferences = (module) => { + const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module)); + /** @type {Map | undefined} */ + let modules; + /** @type {(ChunkId | null)[] | undefined} */ + let blocks; + const outgoing = moduleGraph.getOutgoingConnectionsByModule(module); + if (outgoing !== undefined) { + for (const m of outgoing.keys()) { + if (!m) continue; + if (modules === undefined) modules = new Map(); + modules.set(m, /** @type {ModuleId} */ (chunkGraph.getModuleId(m))); + } + } + if (module.blocks.length > 0) { + blocks = []; + const queue = [...module.blocks]; + for (const block of queue) { + const chunkGroup = chunkGraph.getBlockChunkGroup(block); + if (chunkGroup) { + for (const chunk of chunkGroup.chunks) { + blocks.push(chunk.id); + } + } else { + blocks.push(null); + } + // eslint-disable-next-line prefer-spread + queue.push.apply(queue, block.blocks); + } + } + return { id, modules, blocks }; + }; + /** + * Compares references. + * @param {Module} module module + * @param {object} references references + * @param {string | number} references.id id + * @param {Map=} references.modules modules + * @param {(string | number | null)[]=} references.blocks blocks + * @returns {boolean} ok? + */ + const compareReferences = (module, { id, modules, blocks }) => { + if (id !== chunkGraph.getModuleId(module)) return false; + if (modules !== undefined) { + for (const [module, id] of modules) { + if (chunkGraph.getModuleId(module) !== id) return false; + } + } + if (blocks !== undefined) { + const queue = [...module.blocks]; + let i = 0; + for (const block of queue) { + const chunkGroup = chunkGraph.getBlockChunkGroup(block); + if (chunkGroup) { + for (const chunk of chunkGroup.chunks) { + if (i >= blocks.length || blocks[i++] !== chunk.id) return false; + } + } else if (i >= blocks.length || blocks[i++] !== null) { + return false; + } + // eslint-disable-next-line prefer-spread + queue.push.apply(queue, block.blocks); + } + if (i !== blocks.length) return false; + } + return true; + }; + + for (const [module, memCache] of moduleMemCaches) { + /** @type {{ references: References, memCache: MemCache } | undefined} */ + const cache = memCache.get(key); + if (cache === undefined) { + /** @type {WeakTupleMap | undefined} */ + const memCache2 = new WeakTupleMap(); + memCache.set(key, { + references: computeReferences(module), + memCache: memCache2 + }); + moduleMemCaches2.set(module, memCache2); + statNew++; + } else if (!compareReferences(module, cache.references)) { + /** @type {WeakTupleMap | undefined} */ + const memCache = new WeakTupleMap(); + cache.references = computeReferences(module); + cache.memCache = memCache; + moduleMemCaches2.set(module, memCache); + statChanged++; + } else { + moduleMemCaches2.set(module, cache.memCache); + statUnchanged++; + } + } + + this.logger.log( + `${Math.round( + (100 * statChanged) / (statNew + statChanged + statUnchanged) + )}% modules flagged as affected by chunk graph (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged)` + ); + } + + /** + * Processes the provided callback. + * @param {Callback} callback callback + */ + finish(callback) { + this.factorizeQueue.clear(); + if (this.profile) { + this.logger.time("finish module profiles"); + + const ParallelismFactorCalculator = require("./util/ParallelismFactorCalculator"); + + const p = new ParallelismFactorCalculator(); + const moduleGraph = this.moduleGraph; + /** @type {Map} */ + const modulesWithProfiles = new Map(); + for (const module of this.modules) { + const profile = moduleGraph.getProfile(module); + if (!profile) continue; + modulesWithProfiles.set(module, profile); + p.range( + profile.buildingStartTime, + profile.buildingEndTime, + (f) => (profile.buildingParallelismFactor = f) + ); + p.range( + profile.factoryStartTime, + profile.factoryEndTime, + (f) => (profile.factoryParallelismFactor = f) + ); + p.range( + profile.integrationStartTime, + profile.integrationEndTime, + (f) => (profile.integrationParallelismFactor = f) + ); + p.range( + profile.storingStartTime, + profile.storingEndTime, + (f) => (profile.storingParallelismFactor = f) + ); + p.range( + profile.restoringStartTime, + profile.restoringEndTime, + (f) => (profile.restoringParallelismFactor = f) + ); + if (profile.additionalFactoryTimes) { + for (const { start, end } of profile.additionalFactoryTimes) { + const influence = (end - start) / profile.additionalFactories; + p.range( + start, + end, + (f) => + (profile.additionalFactoriesParallelismFactor += f * influence) + ); + } + } + } + p.calculate(); + + const logger = this.getLogger("webpack.Compilation.ModuleProfile"); + // Avoid coverage problems due indirect changes + /** + * Processes the provided value. + * @param {number} value value + * @param {string} msg message + */ + /* istanbul ignore next */ + const logByValue = (value, msg) => { + if (value > 1000) { + logger.error(msg); + } else if (value > 500) { + logger.warn(msg); + } else if (value > 200) { + logger.info(msg); + } else if (value > 30) { + logger.log(msg); + } else { + logger.debug(msg); + } + }; + /** + * Log normal summary. + * @param {string} category a category + * @param {(profile: ModuleProfile) => number} getDuration get duration callback + * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback + */ + const logNormalSummary = (category, getDuration, getParallelism) => { + let sum = 0; + let max = 0; + for (const [module, profile] of modulesWithProfiles) { + const p = getParallelism(profile); + const d = getDuration(profile); + if (d === 0 || p === 0) continue; + const t = d / p; + sum += t; + if (t <= 10) continue; + logByValue( + t, + ` | ${Math.round(t)} ms${ + p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : "" + } ${category} > ${module.readableIdentifier(this.requestShortener)}` + ); + max = Math.max(max, t); + } + if (sum <= 10) return; + logByValue( + Math.max(sum / 10, max), + `${Math.round(sum)} ms ${category}` + ); + }; + /** + * Log by loaders summary. + * @param {string} category a category + * @param {(profile: ModuleProfile) => number} getDuration get duration callback + * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback + */ + const logByLoadersSummary = (category, getDuration, getParallelism) => { + /** @type {Map} */ + const map = new Map(); + for (const [module, profile] of modulesWithProfiles) { + const list = getOrInsert( + map, + `${module.type}!${module.identifier().replace(/(!|^)[^!]*$/, "")}`, + () => [] + ); + list.push({ module, profile }); + } + + let sum = 0; + let max = 0; + for (const [key, modules] of map) { + let innerSum = 0; + let innerMax = 0; + for (const { module, profile } of modules) { + const p = getParallelism(profile); + const d = getDuration(profile); + if (d === 0 || p === 0) continue; + const t = d / p; + innerSum += t; + if (t <= 10) continue; + logByValue( + t, + ` | | ${Math.round(t)} ms${ + p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : "" + } ${category} > ${module.readableIdentifier( + this.requestShortener + )}` + ); + innerMax = Math.max(innerMax, t); + } + sum += innerSum; + if (innerSum <= 10) continue; + const idx = key.indexOf("!"); + const loaders = key.slice(idx + 1); + const moduleType = key.slice(0, idx); + const t = Math.max(innerSum / 10, innerMax); + logByValue( + t, + ` | ${Math.round(innerSum)} ms ${category} > ${ + loaders + ? `${ + modules.length + } x ${moduleType} with ${this.requestShortener.shorten( + loaders + )}` + : `${modules.length} x ${moduleType}` + }` + ); + max = Math.max(max, t); + } + if (sum <= 10) return; + logByValue( + Math.max(sum / 10, max), + `${Math.round(sum)} ms ${category}` + ); + }; + logNormalSummary( + "resolve to new modules", + (p) => p.factory, + (p) => p.factoryParallelismFactor + ); + logNormalSummary( + "resolve to existing modules", + (p) => p.additionalFactories, + (p) => p.additionalFactoriesParallelismFactor + ); + logNormalSummary( + "integrate modules", + (p) => p.restoring, + (p) => p.restoringParallelismFactor + ); + logByLoadersSummary( + "build modules", + (p) => p.building, + (p) => p.buildingParallelismFactor + ); + logNormalSummary( + "store modules", + (p) => p.storing, + (p) => p.storingParallelismFactor + ); + logNormalSummary( + "restore modules", + (p) => p.restoring, + (p) => p.restoringParallelismFactor + ); + this.logger.timeEnd("finish module profiles"); + } + this.logger.time("compute affected modules"); + this._computeAffectedModules(this.modules); + this.logger.timeEnd("compute affected modules"); + this.logger.time("finish modules"); + const { modules, moduleMemCaches } = this; + this.hooks.finishModules.callAsync(modules, (err) => { + this.logger.timeEnd("finish modules"); + if (err) return callback(/** @type {WebpackError} */ (err)); + + // extract warnings and errors from modules + this.moduleGraph.freeze("dependency errors"); + // TODO keep a cacheToken (= {}) for each module in the graph + // create a new one per compilation and flag all updated files + // and parents with it + this.logger.time("report dependency errors and warnings"); + for (const module of modules) { + // TODO only run for modules with changed cacheToken + // global WeakMap> to keep modules without errors/warnings + const memCache = moduleMemCaches && moduleMemCaches.get(module); + if (memCache && memCache.get("noWarningsOrErrors")) continue; + let hasProblems = this.reportDependencyErrorsAndWarnings(module, [ + module + ]); + const errors = /** @type {WebpackError[]} */ (module.getErrors()); + if (errors !== undefined) { + for (const error of errors) { + if (!error.module) { + error.module = module; + } + this.errors.push(error); + hasProblems = true; + } + } + const warnings = /** @type {WebpackError[]} */ (module.getWarnings()); + if (warnings !== undefined) { + for (const warning of warnings) { + if (!warning.module) { + warning.module = module; + } + this.warnings.push(warning); + hasProblems = true; + } + } + if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true); + } + this.moduleGraph.unfreeze(); + this.logger.timeEnd("report dependency errors and warnings"); + + callback(); + }); + } + + unseal() { + this.hooks.unseal.call(); + this.chunks.clear(); + this.chunkGroups.length = 0; + this.namedChunks.clear(); + this.namedChunkGroups.clear(); + this.entrypoints.clear(); + this.additionalChunkAssets.length = 0; + this.assets = {}; + this.assetsInfo.clear(); + this.moduleGraph.removeAllModuleAttributes(); + this.moduleGraph.unfreeze(); + this.moduleMemCaches2 = undefined; + } + + /** + * Processes the provided callback. + * @param {Callback} callback signals when the call finishes + * @returns {void} + */ + seal(callback) { + /** + * Processes the provided err. + * @param {WebpackError=} err err + * @returns {void} + */ + const finalCallback = (err) => { + this.factorizeQueue.clear(); + this.buildQueue.clear(); + this.rebuildQueue.clear(); + this.processDependenciesQueue.clear(); + this.addModuleQueue.clear(); + return callback(err); + }; + + if (this._backCompat) { + for (const module of this.modules) { + ChunkGraph.setChunkGraphForModule(module, this.chunkGraph); + } + } + + this.hooks.seal.call(); + + this.logger.time("optimize dependencies"); + while (this.hooks.optimizeDependencies.call(this.modules)) { + /* empty */ + } + this.hooks.afterOptimizeDependencies.call(this.modules); + this.logger.timeEnd("optimize dependencies"); + + this.logger.time("create chunks"); + this.hooks.beforeChunks.call(); + this.moduleGraph.freeze("seal"); + /** @type {Map} */ + const chunkGraphInit = new Map(); + for (const [name, { dependencies, includeDependencies, options }] of this + .entries) { + const chunk = this.addChunk(name); + if (options.filename) { + chunk.filenameTemplate = options.filename; + } + const entrypoint = new Entrypoint(options); + if (!options.dependOn && !options.runtime) { + entrypoint.setRuntimeChunk(chunk); + } + entrypoint.setEntrypointChunk(chunk); + this.namedChunkGroups.set(name, entrypoint); + this.entrypoints.set(name, entrypoint); + this.chunkGroups.push(entrypoint); + + if (entrypoint.pushChunk(chunk)) { + chunk.addGroup(entrypoint); + } + + /** @type {Set} */ + const entryModules = new Set(); + for (const dep of [...this.globalEntry.dependencies, ...dependencies]) { + entrypoint.addOrigin( + null, + { name }, + /** @type {Dependency & { request: string }} */ + (dep).request + ); + + const module = this.moduleGraph.getModule(dep); + if (module) { + this.chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint); + entryModules.add(module); + const modulesList = chunkGraphInit.get(entrypoint); + if (modulesList === undefined) { + chunkGraphInit.set(entrypoint, [module]); + } else { + modulesList.push(module); + } + } + } + + this.assignDepths(entryModules); + + /** + * Returns sorted deps. + * @param {Dependency[]} deps deps + * @returns {Module[]} sorted deps + */ + const mapAndSort = (deps) => + /** @type {Module[]} */ + ( + deps.map((dep) => this.moduleGraph.getModule(dep)).filter(Boolean) + ).sort(compareModulesByIdentifier); + const includedModules = [ + ...mapAndSort(this.globalEntry.includeDependencies), + ...mapAndSort(includeDependencies) + ]; + + let modulesList = chunkGraphInit.get(entrypoint); + if (modulesList === undefined) { + chunkGraphInit.set(entrypoint, (modulesList = [])); + } + for (const module of includedModules) { + this.assignDepths([module]); + modulesList.push(module); + } + } + /** @type {Set} */ + const runtimeChunks = new Set(); + outer: for (const [ + name, + { + options: { dependOn, runtime } + } + ] of this.entries) { + if (dependOn && runtime) { + const err = + new WebpackError(`Entrypoint '${name}' has 'dependOn' and 'runtime' specified. This is not valid. +Entrypoints that depend on other entrypoints do not have their own runtime. +They will use the runtime(s) from referenced entrypoints instead. +Remove the 'runtime' option from the entrypoint.`); + const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name)); + err.chunk = entry.getEntrypointChunk(); + this.errors.push(err); + } + if (dependOn) { + const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name)); + const referencedChunks = entry + .getEntrypointChunk() + .getAllReferencedChunks(); + for (const dep of dependOn) { + const dependency = this.entrypoints.get(dep); + if (!dependency) { + throw new Error( + `Entry ${name} depends on ${dep}, but this entry was not found` + ); + } + if (referencedChunks.has(dependency.getEntrypointChunk())) { + const err = new WebpackError( + `Entrypoints '${name}' and '${dep}' use 'dependOn' to depend on each other in a circular way.` + ); + const entryChunk = entry.getEntrypointChunk(); + err.chunk = entryChunk; + this.errors.push(err); + entry.setRuntimeChunk(entryChunk); + continue outer; + } + + entry.addDependOn(dependency); + + if (dependency.addChild(entry)) { + entry.addParent(dependency); + } + } + } else if (runtime) { + const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name)); + let chunk = this.namedChunks.get(runtime); + if (chunk) { + if (!runtimeChunks.has(chunk)) { + const err = + new WebpackError(`Entrypoint '${name}' has a 'runtime' option which points to another entrypoint named '${runtime}'. +It's not valid to use other entrypoints as runtime chunk. +Did you mean to use 'dependOn: ${JSON.stringify( + runtime + )}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used. +Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`); + const entryChunk = + /** @type {Chunk} */ + (entry.getEntrypointChunk()); + err.chunk = entryChunk; + this.errors.push(err); + entry.setRuntimeChunk(entryChunk); + continue; + } + } else { + chunk = this.addChunk(runtime); + chunk.preventIntegration = true; + runtimeChunks.add(chunk); + } + entry.unshiftChunk(chunk); + chunk.addGroup(entry); + entry.setRuntimeChunk(chunk); + } + } + + buildChunkGraph(this, chunkGraphInit); + this.hooks.afterChunks.call(this.chunks); + this.logger.timeEnd("create chunks"); + + this.logger.time("optimize"); + this.hooks.optimize.call(); + + while (this.hooks.optimizeModules.call(this.modules)) { + /* empty */ + } + this.hooks.afterOptimizeModules.call(this.modules); + + while (this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups)) { + /* empty */ + } + this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups); + + this.hooks.optimizeTree.callAsync(this.chunks, this.modules, (err) => { + if (err) { + return finalCallback( + makeWebpackError(err, "Compilation.hooks.optimizeTree") + ); + } + + this.hooks.afterOptimizeTree.call(this.chunks, this.modules); + + this.hooks.optimizeChunkModules.callAsync( + this.chunks, + this.modules, + (err) => { + if (err) { + return finalCallback( + makeWebpackError(err, "Compilation.hooks.optimizeChunkModules") + ); + } + + this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules); + + const shouldRecord = this.hooks.shouldRecord.call() !== false; + + this.hooks.reviveModules.call( + this.modules, + /** @type {Records} */ + (this.records) + ); + this.hooks.beforeModuleIds.call(this.modules); + this.hooks.moduleIds.call(this.modules); + this.hooks.optimizeModuleIds.call(this.modules); + this.hooks.afterOptimizeModuleIds.call(this.modules); + + this.hooks.reviveChunks.call( + this.chunks, + /** @type {Records} */ + (this.records) + ); + this.hooks.beforeChunkIds.call(this.chunks); + this.hooks.chunkIds.call(this.chunks); + this.hooks.optimizeChunkIds.call(this.chunks); + this.hooks.afterOptimizeChunkIds.call(this.chunks); + + this.assignRuntimeIds(); + + this.logger.time("compute affected modules with chunk graph"); + this._computeAffectedModulesWithChunkGraph(); + this.logger.timeEnd("compute affected modules with chunk graph"); + + this.sortItemsWithChunkIds(); + + if (shouldRecord) { + this.hooks.recordModules.call( + this.modules, + /** @type {Records} */ + (this.records) + ); + this.hooks.recordChunks.call( + this.chunks, + /** @type {Records} */ + (this.records) + ); + } + + this.hooks.optimizeCodeGeneration.call(this.modules); + this.logger.timeEnd("optimize"); + + this.logger.time("module hashing"); + this.hooks.beforeModuleHash.call(); + this.createModuleHashes(); + this.hooks.afterModuleHash.call(); + this.logger.timeEnd("module hashing"); + + this.logger.time("code generation"); + this.hooks.beforeCodeGeneration.call(); + this.codeGeneration((err) => { + if (err) { + return finalCallback(err); + } + this.hooks.afterCodeGeneration.call(); + this.logger.timeEnd("code generation"); + + this.logger.time("runtime requirements"); + this.hooks.beforeRuntimeRequirements.call(); + this.processRuntimeRequirements(); + this.hooks.afterRuntimeRequirements.call(); + this.logger.timeEnd("runtime requirements"); + + this.logger.time("hashing"); + this.hooks.beforeHash.call(); + const codeGenerationJobs = this.createHash(); + this.hooks.afterHash.call(); + this.logger.timeEnd("hashing"); + + this._runCodeGenerationJobs(codeGenerationJobs, (err) => { + if (err) { + return finalCallback(err); + } + + if (shouldRecord) { + this.logger.time("record hash"); + this.hooks.recordHash.call( + /** @type {Records} */ + (this.records) + ); + this.logger.timeEnd("record hash"); + } + + this.logger.time("module assets"); + this.clearAssets(); + + this.hooks.beforeModuleAssets.call(); + this.createModuleAssets(); + this.logger.timeEnd("module assets"); + + const cont = () => { + this.logger.time("process assets"); + this.hooks.processAssets.callAsync(this.assets, (err) => { + if (err) { + return finalCallback( + makeWebpackError(err, "Compilation.hooks.processAssets") + ); + } + this.hooks.afterProcessAssets.call(this.assets); + this.logger.timeEnd("process assets"); + this.assets = + /** @type {CompilationAssets} */ + ( + this._backCompat + ? soonFrozenObjectDeprecation( + this.assets, + "Compilation.assets", + "DEP_WEBPACK_COMPILATION_ASSETS", + `BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation. + Do changes to assets earlier, e. g. in Compilation.hooks.processAssets. + Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.` + ) + : Object.freeze(this.assets) + ); + + this.summarizeDependencies(); + if (shouldRecord) { + this.hooks.record.call( + this, + /** @type {Records} */ + (this.records) + ); + } + + if (this.hooks.needAdditionalSeal.call()) { + this.unseal(); + return this.seal(callback); + } + return this.hooks.afterSeal.callAsync((err) => { + if (err) { + return finalCallback( + makeWebpackError(err, "Compilation.hooks.afterSeal") + ); + } + this.fileSystemInfo.logStatistics(); + finalCallback(); + }); + }); + }; + + this.logger.time("create chunk assets"); + if (this.hooks.shouldGenerateChunkAssets.call() !== false) { + this.hooks.beforeChunkAssets.call(); + this.createChunkAssets((err) => { + this.logger.timeEnd("create chunk assets"); + if (err) { + return finalCallback(err); + } + cont(); + }); + } else { + this.logger.timeEnd("create chunk assets"); + cont(); + } + }); + }); + } + ); + }); + } + + /** + * Report dependency errors and warnings. + * @param {Module} module module to report from + * @param {DependenciesBlock[]} blocks blocks to report from + * @returns {boolean} true, when it has warnings or errors + */ + reportDependencyErrorsAndWarnings(module, blocks) { + let hasProblems = false; + for (const block of blocks) { + const dependencies = block.dependencies; + + for (const d of dependencies) { + const warnings = d.getWarnings(this.moduleGraph); + if (warnings) { + for (const w of warnings) { + const warning = new ModuleDependencyWarning(module, w, d.loc); + this.warnings.push(warning); + hasProblems = true; + } + } + const errors = d.getErrors(this.moduleGraph); + if (errors) { + for (const e of errors) { + const error = new ModuleDependencyError(module, e, d.loc); + this.errors.push(error); + hasProblems = true; + } + } + } + + if (this.reportDependencyErrorsAndWarnings(module, block.blocks)) { + hasProblems = true; + } + } + return hasProblems; + } + + /** + * Generates code and runtime requirements for this module. + * @param {Callback} callback callback + */ + codeGeneration(callback) { + const { chunkGraph } = this; + this.codeGenerationResults = new CodeGenerationResults( + this.outputOptions.hashFunction + ); + /** @type {CodeGenerationJobs} */ + const jobs = []; + for (const module of this.modules) { + const runtimes = chunkGraph.getModuleRuntimes(module); + if (runtimes.size === 1) { + for (const runtime of runtimes) { + const hash = chunkGraph.getModuleHash(module, runtime); + jobs.push({ module, hash, runtime, runtimes: [runtime] }); + } + } else if (runtimes.size > 1) { + /** @type {Map} */ + const map = new Map(); + for (const runtime of runtimes) { + const hash = chunkGraph.getModuleHash(module, runtime); + const job = map.get(hash); + if (job === undefined) { + const newJob = { module, hash, runtime, runtimes: [runtime] }; + jobs.push(newJob); + map.set(hash, newJob); + } else { + job.runtimes.push(runtime); + } + } + } + } + + this._runCodeGenerationJobs(jobs, callback); + } + + /** + * Run code generation jobs. + * @private + * @param {CodeGenerationJobs} jobs code generation jobs + * @param {Callback} callback callback + * @returns {void} + */ + _runCodeGenerationJobs(jobs, callback) { + if (jobs.length === 0) { + return callback(); + } + let statModulesFromCache = 0; + let statModulesGenerated = 0; + const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } = + this; + const results = + /** @type {CodeGenerationResults} */ + (this.codeGenerationResults); + /** @type {WebpackError[]} */ + const errors = []; + /** @type {NotCodeGeneratedModules | undefined} */ + let notCodeGeneratedModules; + const runIteration = () => { + /** @type {CodeGenerationJobs} */ + let delayedJobs = []; + /** @type {Set} */ + let delayedModules = new Set(); + asyncLib.eachLimit( + jobs, + this.options.parallelism, + (job, callback) => { + const { module } = job; + const { codeGenerationDependencies } = module; + if ( + codeGenerationDependencies !== undefined && + (notCodeGeneratedModules === undefined || + codeGenerationDependencies.some((dep) => { + const referencedModule = /** @type {Module} */ ( + moduleGraph.getModule(dep) + ); + return /** @type {NotCodeGeneratedModules} */ ( + notCodeGeneratedModules + ).has(referencedModule); + })) + ) { + delayedJobs.push(job); + delayedModules.add(module); + return callback(); + } + const { hash, runtime, runtimes } = job; + this._codeGenerationModule( + module, + runtime, + runtimes, + hash, + dependencyTemplates, + chunkGraph, + moduleGraph, + runtimeTemplate, + errors, + results, + (err, codeGenerated) => { + if (codeGenerated) statModulesGenerated++; + else statModulesFromCache++; + callback(err); + } + ); + }, + (err) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + if (delayedJobs.length > 0) { + if (delayedJobs.length === jobs.length) { + return callback( + /** @type {WebpackError} */ ( + new Error( + `Unable to make progress during code generation because of circular code generation dependency: ${Array.from( + delayedModules, + (m) => m.identifier() + ).join(", ")}` + ) + ) + ); + } + jobs = delayedJobs; + delayedJobs = []; + notCodeGeneratedModules = delayedModules; + delayedModules = new Set(); + return runIteration(); + } + if (errors.length > 0) { + errors.sort( + compareSelect((err) => err.module, compareModulesByIdentifier) + ); + for (const error of errors) { + this.errors.push(error); + } + } + this.logger.log( + `${Math.round( + (100 * statModulesGenerated) / + (statModulesGenerated + statModulesFromCache) + )}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)` + ); + callback(); + } + ); + }; + runIteration(); + } + + /** + * Code generation module. + * @param {Module} module module + * @param {RuntimeSpec} runtime runtime + * @param {RuntimeSpec[]} runtimes runtimes + * @param {string} hash hash + * @param {DependencyTemplates} dependencyTemplates dependencyTemplates + * @param {ChunkGraph} chunkGraph chunkGraph + * @param {ModuleGraph} moduleGraph moduleGraph + * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate + * @param {WebpackError[]} errors errors + * @param {CodeGenerationResults} results results + * @param {(err?: WebpackError | null, result?: boolean) => void} callback callback + */ + _codeGenerationModule( + module, + runtime, + runtimes, + hash, + dependencyTemplates, + chunkGraph, + moduleGraph, + runtimeTemplate, + errors, + results, + callback + ) { + let codeGenerated = false; + const cache = new MultiItemCache( + runtimes.map((runtime) => + this._codeGenerationCache.getItemCache( + `${module.identifier()}|${getRuntimeKey(runtime)}`, + `${hash}|${dependencyTemplates.getHash()}` + ) + ) + ); + cache.get((err, cachedResult) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + /** @type {CodeGenerationResult} */ + let result; + if (!cachedResult) { + try { + codeGenerated = true; + this.codeGeneratedModules.add(module); + result = module.codeGeneration({ + chunkGraph, + moduleGraph, + dependencyTemplates, + runtimeTemplate, + runtime, + runtimes, + codeGenerationResults: results, + compilation: this + }); + } catch (err) { + errors.push( + new CodeGenerationError(module, /** @type {Error} */ (err)) + ); + result = cachedResult = { + sources: new Map(), + runtimeRequirements: null + }; + } + } else { + result = cachedResult; + } + for (const runtime of runtimes) { + results.add(module, runtime, result); + } + if (!cachedResult) { + cache.store(result, (err) => + callback(/** @type {WebpackError} */ (err), codeGenerated) + ); + } else { + callback(null, codeGenerated); + } + }); + } + + _getChunkGraphEntries() { + /** @type {Set} */ + const treeEntries = new Set(); + for (const ep of this.entrypoints.values()) { + const chunk = ep.getRuntimeChunk(); + if (chunk) treeEntries.add(chunk); + } + for (const ep of this.asyncEntrypoints) { + const chunk = ep.getRuntimeChunk(); + if (chunk) treeEntries.add(chunk); + } + return treeEntries; + } + + /** + * Process runtime requirements. + * @param {object} options options + * @param {ChunkGraph=} options.chunkGraph the chunk graph + * @param {Iterable=} options.modules modules + * @param {Iterable=} options.chunks chunks + * @param {CodeGenerationResults=} options.codeGenerationResults codeGenerationResults + * @param {Iterable=} options.chunkGraphEntries chunkGraphEntries + * @returns {void} + */ + processRuntimeRequirements({ + chunkGraph = this.chunkGraph, + modules = this.modules, + chunks = this.chunks, + codeGenerationResults = /** @type {CodeGenerationResults} */ ( + this.codeGenerationResults + ), + chunkGraphEntries = this._getChunkGraphEntries() + } = {}) { + const context = { chunkGraph, codeGenerationResults }; + const { moduleMemCaches2 } = this; + this.logger.time("runtime requirements.modules"); + const additionalModuleRuntimeRequirements = + this.hooks.additionalModuleRuntimeRequirements; + const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule; + for (const module of modules) { + if (chunkGraph.getNumberOfModuleChunks(module) > 0) { + const memCache = moduleMemCaches2 && moduleMemCaches2.get(module); + for (const runtime of chunkGraph.getModuleRuntimes(module)) { + if (memCache) { + const cached = memCache.get( + `moduleRuntimeRequirements-${getRuntimeKey(runtime)}` + ); + if (cached !== undefined) { + if (cached !== null) { + chunkGraph.addModuleRuntimeRequirements( + module, + runtime, + /** @type {RuntimeRequirements} */ + (cached), + false + ); + } + continue; + } + } + /** @type {RuntimeRequirements} */ + let set; + const runtimeRequirements = + codeGenerationResults.getRuntimeRequirements(module, runtime); + if (runtimeRequirements && runtimeRequirements.size > 0) { + set = new Set(runtimeRequirements); + } else if (additionalModuleRuntimeRequirements.isUsed()) { + set = new Set(); + } else { + if (memCache) { + memCache.set( + `moduleRuntimeRequirements-${getRuntimeKey(runtime)}`, + null + ); + } + continue; + } + additionalModuleRuntimeRequirements.call(module, set, context); + + for (const r of set) { + const hook = runtimeRequirementInModule.get(r); + if (hook !== undefined) hook.call(module, set, context); + } + if (set.size === 0) { + if (memCache) { + memCache.set( + `moduleRuntimeRequirements-${getRuntimeKey(runtime)}`, + null + ); + } + } else if (memCache) { + memCache.set( + `moduleRuntimeRequirements-${getRuntimeKey(runtime)}`, + set + ); + chunkGraph.addModuleRuntimeRequirements( + module, + runtime, + set, + false + ); + } else { + chunkGraph.addModuleRuntimeRequirements(module, runtime, set); + } + } + } + } + this.logger.timeEnd("runtime requirements.modules"); + + this.logger.time("runtime requirements.chunks"); + for (const chunk of chunks) { + /** @type {RuntimeRequirements} */ + const set = new Set(); + for (const module of chunkGraph.getChunkModulesIterable(chunk)) { + const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements( + module, + chunk.runtime + ); + for (const r of runtimeRequirements) set.add(r); + } + this.hooks.additionalChunkRuntimeRequirements.call(chunk, set, context); + + for (const r of set) { + this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set, context); + } + + chunkGraph.addChunkRuntimeRequirements(chunk, set); + } + this.logger.timeEnd("runtime requirements.chunks"); + + this.logger.time("runtime requirements.entries"); + for (const treeEntry of chunkGraphEntries) { + /** @type {RuntimeRequirements} */ + const set = new Set(); + for (const chunk of treeEntry.getAllReferencedChunks()) { + const runtimeRequirements = + chunkGraph.getChunkRuntimeRequirements(chunk); + for (const r of runtimeRequirements) set.add(r); + } + + this.hooks.additionalTreeRuntimeRequirements.call( + treeEntry, + set, + context + ); + + for (const r of set) { + this.hooks.runtimeRequirementInTree + .for(r) + .call(treeEntry, set, context); + } + + chunkGraph.addTreeRuntimeRequirements(treeEntry, set); + } + this.logger.timeEnd("runtime requirements.entries"); + } + + // TODO webpack 6 make chunkGraph argument non-optional + /** + * Adds runtime module. + * @param {Chunk} chunk target chunk + * @param {RuntimeModule} module runtime module + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {void} + */ + addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) { + // Deprecated ModuleGraph association + if (this._backCompat) { + ModuleGraph.setModuleGraphForModule(module, this.moduleGraph); + } + + // add it to the list + this.modules.add(module); + this._modules.set(module.identifier(), module); + + // connect to the chunk graph + chunkGraph.connectChunkAndModule(chunk, module); + chunkGraph.connectChunkAndRuntimeModule(chunk, module); + if (module.fullHash) { + chunkGraph.addFullHashModuleToChunk(chunk, module); + } else if (module.dependentHash) { + chunkGraph.addDependentHashModuleToChunk(chunk, module); + } + + // attach runtime module + module.attach(this, chunk, chunkGraph); + + // Setup internals + const exportsInfo = this.moduleGraph.getExportsInfo(module); + exportsInfo.setHasProvideInfo(); + if (typeof chunk.runtime === "string") { + exportsInfo.setUsedForSideEffectsOnly(chunk.runtime); + } else if (chunk.runtime === undefined) { + exportsInfo.setUsedForSideEffectsOnly(undefined); + } else { + for (const runtime of chunk.runtime) { + exportsInfo.setUsedForSideEffectsOnly(runtime); + } + } + chunkGraph.addModuleRuntimeRequirements( + module, + chunk.runtime, + new Set([RuntimeGlobals.requireScope]) + ); + + // runtime modules don't need ids + chunkGraph.setModuleId(module, ""); + + // Call hook + this.hooks.runtimeModule.call(module, chunk); + } + + /** + * If `module` is passed, `loc` and `request` must also be passed. + * @param {string | ChunkGroupOptions} groupOptions options for the chunk group + * @param {Module=} module the module the references the chunk group + * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module) + * @param {string=} request the request from which the chunk group is referenced + * @returns {ChunkGroup} the new or existing chunk group + */ + addChunkInGroup(groupOptions, module, loc, request) { + if (typeof groupOptions === "string") { + groupOptions = { name: groupOptions }; + } + const name = groupOptions.name; + if (name) { + const chunkGroup = this.namedChunkGroups.get(name); + if (chunkGroup !== undefined) { + if (module) { + chunkGroup.addOrigin( + module, + /** @type {DependencyLocation} */ + (loc), + /** @type {string} */ + (request) + ); + } + return chunkGroup; + } + } + const chunkGroup = new ChunkGroup(groupOptions); + if (module) { + chunkGroup.addOrigin( + module, + /** @type {DependencyLocation} */ + (loc), + /** @type {string} */ + (request) + ); + } + const chunk = this.addChunk(name); + + if (chunkGroup.pushChunk(chunk)) { + chunk.addGroup(chunkGroup); + } + + this.chunkGroups.push(chunkGroup); + if (name) { + this.namedChunkGroups.set(name, chunkGroup); + } + return chunkGroup; + } + + /** + * Adds the provided async entrypoint to this chunk group. + * @param {EntryOptions} options options for the entrypoint + * @param {Module} module the module the references the chunk group + * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module) + * @param {string} request the request from which the chunk group is referenced + * @returns {Entrypoint} the new or existing entrypoint + */ + addAsyncEntrypoint(options, module, loc, request) { + const name = options.name; + if (name) { + const entrypoint = this.namedChunkGroups.get(name); + if (entrypoint instanceof Entrypoint) { + if (module) { + entrypoint.addOrigin(module, loc, request); + } + return entrypoint; + } else if (entrypoint) { + throw new Error( + `Cannot add an async entrypoint with the name '${name}', because there is already an chunk group with this name` + ); + } + } + const chunk = this.addChunk(name); + if (options.filename) { + chunk.filenameTemplate = options.filename; + } + const entrypoint = new Entrypoint(options, false); + entrypoint.setRuntimeChunk(chunk); + entrypoint.setEntrypointChunk(chunk); + if (name) { + this.namedChunkGroups.set(name, entrypoint); + } + this.chunkGroups.push(entrypoint); + this.asyncEntrypoints.push(entrypoint); + if (entrypoint.pushChunk(chunk)) { + chunk.addGroup(entrypoint); + } + if (module) { + entrypoint.addOrigin(module, loc, request); + } + return entrypoint; + } + + /** + * This method first looks to see if a name is provided for a new chunk, + * and first looks to see if any named chunks already exist and reuse that chunk instead. + * @param {ChunkName=} name optional chunk name to be provided + * @returns {Chunk} create a chunk (invoked during seal event) + */ + addChunk(name) { + if (name) { + const chunk = this.namedChunks.get(name); + if (chunk !== undefined) { + return chunk; + } + } + const chunk = new Chunk(name, this._backCompat); + this.chunks.add(chunk); + if (this._backCompat) { + ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph); + } + if (name) { + this.namedChunks.set(name, chunk); + } + return chunk; + } + + /** + * Processes the provided module. + * @deprecated + * @param {Module} module module to assign depth + * @returns {void} + */ + assignDepth(module) { + const moduleGraph = this.moduleGraph; + + const queue = new Set([module]); + /** @type {number} */ + let depth; + + moduleGraph.setDepth(module, 0); + + /** + * Processes the provided module. + * @param {Module} module module for processing + * @returns {void} + */ + const processModule = (module) => { + if (!moduleGraph.setDepthIfLower(module, depth)) return; + queue.add(module); + }; + + for (module of queue) { + queue.delete(module); + depth = /** @type {number} */ (moduleGraph.getDepth(module)) + 1; + + for (const connection of moduleGraph.getOutgoingConnections(module)) { + const refModule = connection.module; + if (refModule) { + processModule(refModule); + } + } + } + } + + /** + * Assigns depth values to the provided modules. + * @param {Module[] | Set} modules modules to assign depth + * @returns {void} + */ + assignDepths(modules) { + const moduleGraph = this.moduleGraph; + + /** @type {Set} */ + const queue = new Set(modules); + // Track these in local variables so that queue only has one data type + let nextDepthAt = queue.size; + let depth = 0; + + let i = 0; + for (const module of queue) { + moduleGraph.setDepth(module, depth); + // Some of these results come from cache, which speeds this up + const connections = moduleGraph.getOutgoingConnectionsByModule(module); + // connections will be undefined if there are no outgoing connections + if (connections) { + for (const refModule of connections.keys()) { + if (refModule) queue.add(refModule); + } + } + i++; + // Since this is a breadth-first search, all modules added to the queue + // while at depth N will be depth N+1 + if (i >= nextDepthAt) { + depth++; + nextDepthAt = queue.size; + } + } + } + + /** + * Gets dependency referenced exports. + * @param {Dependency} dependency the dependency + * @param {RuntimeSpec} runtime the runtime + * @returns {ReferencedExports} referenced exports + */ + getDependencyReferencedExports(dependency, runtime) { + const referencedExports = dependency.getReferencedExports( + this.moduleGraph, + runtime + ); + return this.hooks.dependencyReferencedExports.call( + referencedExports, + dependency, + runtime + ); + } + + /** + * Removes reasons of dependency block. + * @param {Module} module module relationship for removal + * @param {DependenciesBlockLike} block dependencies block + * @returns {void} + */ + removeReasonsOfDependencyBlock(module, block) { + if (block.blocks) { + for (const b of block.blocks) { + this.removeReasonsOfDependencyBlock(module, b); + } + } + + if (block.dependencies) { + for (const dep of block.dependencies) { + const originalModule = this.moduleGraph.getModule(dep); + if (originalModule) { + this.moduleGraph.removeConnection(dep); + + if (this.chunkGraph) { + for (const chunk of this.chunkGraph.getModuleChunks( + originalModule + )) { + this.patchChunksAfterReasonRemoval(originalModule, chunk); + } + } + } + } + } + } + + /** + * Patch chunks after reason removal. + * @param {Module} module module to patch tie + * @param {Chunk} chunk chunk to patch tie + * @returns {void} + */ + patchChunksAfterReasonRemoval(module, chunk) { + if (!module.hasReasons(this.moduleGraph, chunk.runtime)) { + this.removeReasonsOfDependencyBlock(module, module); + } + if ( + !module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph) && + this.chunkGraph.isModuleInChunk(module, chunk) + ) { + this.chunkGraph.disconnectChunkAndModule(chunk, module); + this.removeChunkFromDependencies(module, chunk); + } + } + + /** + * Removes chunk from dependencies. + * @param {DependenciesBlock} block block tie for Chunk + * @param {Chunk} chunk chunk to remove from dep + * @returns {void} + */ + removeChunkFromDependencies(block, chunk) { + /** + * Iterator dependency. + * @param {Dependency} d dependency to (maybe) patch up + */ + const iteratorDependency = (d) => { + const depModule = this.moduleGraph.getModule(d); + if (!depModule) { + return; + } + this.patchChunksAfterReasonRemoval(depModule, chunk); + }; + + const blocks = block.blocks; + for (const asyncBlock of blocks) { + const chunkGroup = + /** @type {ChunkGroup} */ + (this.chunkGraph.getBlockChunkGroup(asyncBlock)); + // Grab all chunks from the first Block's AsyncDepBlock + const chunks = chunkGroup.chunks; + // For each chunk in chunkGroup + for (const iteratedChunk of chunks) { + chunkGroup.removeChunk(iteratedChunk); + // Recurse + this.removeChunkFromDependencies(block, iteratedChunk); + } + } + + if (block.dependencies) { + for (const dep of block.dependencies) iteratorDependency(dep); + } + } + + assignRuntimeIds() { + const { chunkGraph } = this; + /** + * Process entrypoint. + * @param {Entrypoint} ep an entrypoint + */ + const processEntrypoint = (ep) => { + const runtime = /** @type {string} */ (ep.options.runtime || ep.name); + const chunk = /** @type {Chunk} */ (ep.getRuntimeChunk()); + chunkGraph.setRuntimeId(runtime, /** @type {ChunkId} */ (chunk.id)); + }; + for (const ep of this.entrypoints.values()) { + processEntrypoint(ep); + } + for (const ep of this.asyncEntrypoints) { + processEntrypoint(ep); + } + } + + sortItemsWithChunkIds() { + for (const chunkGroup of this.chunkGroups) { + chunkGroup.sortItems(); + } + + this.errors.sort(compareErrors); + this.warnings.sort(compareErrors); + this.children.sort(byNameOrHash); + } + + summarizeDependencies() { + for (const child of this.children) { + this.fileDependencies.addAll(child.fileDependencies); + this.contextDependencies.addAll(child.contextDependencies); + this.missingDependencies.addAll(child.missingDependencies); + this.buildDependencies.addAll(child.buildDependencies); + } + + for (const module of this.modules) { + module.addCacheDependencies( + this.fileDependencies, + this.contextDependencies, + this.missingDependencies, + this.buildDependencies + ); + } + } + + createModuleHashes() { + let statModulesHashed = 0; + let statModulesFromCache = 0; + const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this; + const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions; + /** @type {WebpackError[]} */ + const errors = []; + for (const module of this.modules) { + const memCache = moduleMemCaches2 && moduleMemCaches2.get(module); + for (const runtime of chunkGraph.getModuleRuntimes(module)) { + if (memCache) { + const digest = + /** @type {string} */ + (memCache.get(`moduleHash-${getRuntimeKey(runtime)}`)); + if (digest !== undefined) { + chunkGraph.setModuleHashes( + module, + runtime, + digest, + digest.slice(0, hashDigestLength) + ); + statModulesFromCache++; + continue; + } + } + statModulesHashed++; + const digest = this._createModuleHash( + module, + chunkGraph, + runtime, + hashFunction, + runtimeTemplate, + hashDigest, + hashDigestLength, + errors + ); + if (memCache) { + memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest); + } + } + } + if (errors.length > 0) { + errors.sort( + compareSelect((err) => err.module, compareModulesByIdentifier) + ); + for (const error of errors) { + this.errors.push(error); + } + } + this.logger.log( + `${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${ + Math.round( + (100 * (statModulesHashed + statModulesFromCache)) / this.modules.size + ) / 100 + } variants per module in average)` + ); + } + + /** + * Create module hash. + * @private + * @param {Module} module module + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {RuntimeSpec} runtime runtime + * @param {HashFunction} hashFunction hash function + * @param {RuntimeTemplate} runtimeTemplate runtime template + * @param {HashDigest} hashDigest hash digest + * @param {HashDigestLength} hashDigestLength hash digest length + * @param {WebpackError[]} errors errors + * @returns {string} module hash digest + */ + _createModuleHash( + module, + chunkGraph, + runtime, + hashFunction, + runtimeTemplate, + hashDigest, + hashDigestLength, + errors + ) { + /** @type {string} */ + let moduleHashDigest; + try { + const moduleHash = createHash(hashFunction); + module.updateHash(moduleHash, { + chunkGraph, + runtime, + runtimeTemplate + }); + moduleHashDigest = moduleHash.digest(hashDigest); + } catch (err) { + errors.push(new ModuleHashingError(module, /** @type {Error} */ (err))); + moduleHashDigest = "XXXXXX"; + } + chunkGraph.setModuleHashes( + module, + runtime, + moduleHashDigest, + moduleHashDigest.slice(0, hashDigestLength) + ); + return moduleHashDigest; + } + + createHash() { + this.logger.time("hashing: initialize hash"); + const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph); + const runtimeTemplate = this.runtimeTemplate; + const outputOptions = this.outputOptions; + const hashFunction = outputOptions.hashFunction; + const hashDigest = outputOptions.hashDigest; + const hashDigestLength = outputOptions.hashDigestLength; + const hash = createHash(hashFunction); + if (outputOptions.hashSalt) { + hash.update(outputOptions.hashSalt); + } + this.logger.timeEnd("hashing: initialize hash"); + if (this.children.length > 0) { + this.logger.time("hashing: hash child compilations"); + for (const child of this.children) { + hash.update(/** @type {string} */ (child.hash)); + } + this.logger.timeEnd("hashing: hash child compilations"); + } + if (this.warnings.length > 0) { + this.logger.time("hashing: hash warnings"); + for (const warning of this.warnings) { + hash.update(`${warning.message}`); + } + this.logger.timeEnd("hashing: hash warnings"); + } + if (this.errors.length > 0) { + this.logger.time("hashing: hash errors"); + for (const error of this.errors) { + hash.update(`${error.message}`); + } + this.logger.timeEnd("hashing: hash errors"); + } + + this.logger.time("hashing: sort chunks"); + /* + * Chunks are hashed in 4 categories, in this order: + * 1. Async chunks - no hash dependencies on other chunks + * 2. Non-entry initial chunks (e.g. shared split chunks) - no hash + * dependencies on other chunks, but runtime chunks may read their + * hashes via GetChunkFilenameRuntimeModule (dependentHash) + * 3. Runtime chunks - may use hashes of async and non-entry initial + * chunks (via GetChunkFilenameRuntimeModule). Ordered by references + * between each other (for async entrypoints) + * 4. Entry chunks - may depend on runtimeChunk.hash (via + * createChunkHashHandler for ESM/CJS entry importing runtime) + * + * This ordering ensures all hash dependencies flow in one direction: + * async/initial → runtime → entry, with no circular dependencies. + * Chunks within each category are sorted by id for determinism. + */ + /** @type {Chunk[]} */ + const unorderedRuntimeChunks = []; + /** @type {Chunk[]} */ + const initialChunks = []; + /** @type {Chunk[]} */ + const entryChunks = []; + /** @type {Chunk[]} */ + const asyncChunks = []; + for (const c of this.chunks) { + if (c.hasRuntime()) { + unorderedRuntimeChunks.push(c); + } else if (chunkGraph.getNumberOfEntryModules(c) > 0) { + entryChunks.push(c); + } else if (c.canBeInitial()) { + initialChunks.push(c); + } else { + asyncChunks.push(c); + } + } + unorderedRuntimeChunks.sort(byId); + entryChunks.sort(byId); + initialChunks.sort(byId); + asyncChunks.sort(byId); + + /** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */ + /** @type {Map} */ + const runtimeChunksMap = new Map(); + for (const chunk of unorderedRuntimeChunks) { + runtimeChunksMap.set(chunk, { + chunk, + referencedBy: [], + remaining: 0 + }); + } + let remaining = 0; + for (const info of runtimeChunksMap.values()) { + for (const other of new Set( + [...info.chunk.getAllReferencedAsyncEntrypoints()].map( + (e) => e.chunks[e.chunks.length - 1] + ) + )) { + const otherInfo = runtimeChunksMap.get(other); + // other may be a non-runtime chunk (e.g. worker chunk) + // when you have a worker chunk in your app.js (new Worker(...)) and as a separate entry point + if (otherInfo) { + otherInfo.referencedBy.push(info); + info.remaining++; + remaining++; + } + } + } + /** @type {Chunk[]} */ + const runtimeChunks = []; + for (const info of runtimeChunksMap.values()) { + if (info.remaining === 0) { + runtimeChunks.push(info.chunk); + } + } + // If there are any references between chunks + // make sure to follow these chains + if (remaining > 0) { + /** @type {Chunk[]} */ + const readyChunks = []; + for (const chunk of runtimeChunks) { + const hasFullHashModules = + chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0; + const info = + /** @type {RuntimeChunkInfo} */ + (runtimeChunksMap.get(chunk)); + for (const otherInfo of info.referencedBy) { + if (hasFullHashModules) { + chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk); + } + remaining--; + if (--otherInfo.remaining === 0) { + readyChunks.push(otherInfo.chunk); + } + } + if (readyChunks.length > 0) { + // This ensures deterministic ordering, since referencedBy is non-deterministic + readyChunks.sort(byId); + for (const c of readyChunks) runtimeChunks.push(c); + readyChunks.length = 0; + } + } + } + // If there are still remaining references we have cycles and want to create a warning + if (remaining > 0) { + /** @type {RuntimeChunkInfo[]} */ + const circularRuntimeChunkInfo = []; + for (const info of runtimeChunksMap.values()) { + if (info.remaining !== 0) { + circularRuntimeChunkInfo.push(info); + } + } + circularRuntimeChunkInfo.sort(compareSelect((i) => i.chunk, byId)); + const err = + new WebpackError(`Circular dependency between chunks with runtime (${Array.from( + circularRuntimeChunkInfo, + (c) => c.chunk.name || c.chunk.id + ).join(", ")}) +This prevents using hashes of each other and should be avoided.`); + err.chunk = circularRuntimeChunkInfo[0].chunk; + this.warnings.push(err); + for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk); + } + this.logger.timeEnd("hashing: sort chunks"); + + /** @type {Set} */ + const fullHashChunks = new Set(); + /** @type {CodeGenerationJobs} */ + const codeGenerationJobs = []; + /** @type {Map>} */ + const codeGenerationJobsMap = new Map(); + /** @type {WebpackError[]} */ + const errors = []; + + /** + * Processes the provided chunk. + * @param {Chunk} chunk chunk + */ + const processChunk = (chunk) => { + // Last minute module hash generation for modules that depend on chunk hashes + this.logger.time("hashing: hash runtime modules"); + const runtime = chunk.runtime; + for (const module of chunkGraph.getChunkModulesIterable(chunk)) { + if (!chunkGraph.hasModuleHashes(module, runtime)) { + const hash = this._createModuleHash( + module, + chunkGraph, + runtime, + hashFunction, + runtimeTemplate, + hashDigest, + hashDigestLength, + errors + ); + let hashMap = codeGenerationJobsMap.get(hash); + if (hashMap) { + const moduleJob = hashMap.get(module); + if (moduleJob) { + moduleJob.runtimes.push(runtime); + continue; + } + } else { + hashMap = new Map(); + codeGenerationJobsMap.set(hash, hashMap); + } + const job = { + module, + hash, + runtime, + runtimes: [runtime] + }; + hashMap.set(module, job); + codeGenerationJobs.push(job); + } + } + this.logger.timeAggregate("hashing: hash runtime modules"); + try { + this.logger.time("hashing: hash chunks"); + const chunkHash = createHash(hashFunction); + if (outputOptions.hashSalt) { + chunkHash.update(outputOptions.hashSalt); + } + chunk.updateHash(chunkHash, chunkGraph); + this.hooks.chunkHash.call(chunk, chunkHash, { + chunkGraph, + codeGenerationResults: + /** @type {CodeGenerationResults} */ + (this.codeGenerationResults), + moduleGraph: this.moduleGraph, + runtimeTemplate: this.runtimeTemplate + }); + const chunkHashDigest = chunkHash.digest(hashDigest); + hash.update(chunkHashDigest); + chunk.hash = chunkHashDigest; + chunk.renderedHash = chunk.hash.slice(0, hashDigestLength); + const fullHashModules = + chunkGraph.getChunkFullHashModulesIterable(chunk); + if (fullHashModules) { + fullHashChunks.add(chunk); + } else { + this.hooks.contentHash.call(chunk); + } + } catch (err) { + this.errors.push( + new ChunkRenderError(chunk, "", /** @type {Error} */ (err)) + ); + } + this.logger.timeAggregate("hashing: hash chunks"); + }; + for (const chunk of asyncChunks) processChunk(chunk); + for (const chunk of initialChunks) processChunk(chunk); + for (const chunk of runtimeChunks) processChunk(chunk); + for (const chunk of entryChunks) processChunk(chunk); + if (errors.length > 0) { + errors.sort( + compareSelect((err) => err.module, compareModulesByIdentifier) + ); + for (const error of errors) { + this.errors.push(error); + } + } + + this.logger.timeAggregateEnd("hashing: hash runtime modules"); + this.logger.timeAggregateEnd("hashing: hash chunks"); + this.logger.time("hashing: hash digest"); + this.hooks.fullHash.call(hash); + this.fullHash = hash.digest(hashDigest); + this.hash = this.fullHash.slice(0, hashDigestLength); + this.logger.timeEnd("hashing: hash digest"); + + this.logger.time("hashing: process full hash modules"); + for (const chunk of fullHashChunks) { + for (const module of /** @type {Iterable} */ ( + chunkGraph.getChunkFullHashModulesIterable(chunk) + )) { + const moduleHash = createHash(hashFunction); + module.updateHash(moduleHash, { + chunkGraph, + runtime: chunk.runtime, + runtimeTemplate + }); + const moduleHashDigest = moduleHash.digest(hashDigest); + const oldHash = chunkGraph.getModuleHash(module, chunk.runtime); + chunkGraph.setModuleHashes( + module, + chunk.runtime, + moduleHashDigest, + moduleHashDigest.slice(0, hashDigestLength) + ); + /** @type {CodeGenerationJob} */ + ( + /** @type {Map} */ + (codeGenerationJobsMap.get(oldHash)).get(module) + ).hash = moduleHashDigest; + } + const chunkHash = createHash(hashFunction); + chunkHash.update(/** @type {string} */ (chunk.hash)); + chunkHash.update(this.hash); + const chunkHashDigest = chunkHash.digest(hashDigest); + chunk.hash = chunkHashDigest; + chunk.renderedHash = chunk.hash.slice(0, hashDigestLength); + this.hooks.contentHash.call(chunk); + } + this.logger.timeEnd("hashing: process full hash modules"); + return codeGenerationJobs; + } + + /** + * Processes the provided file. + * @param {string} file file name + * @param {Source} source asset source + * @param {AssetInfo} assetInfo extra asset information + * @returns {void} + */ + emitAsset(file, source, assetInfo = {}) { + if (this.assets[file]) { + if (!isSourceEqual(this.assets[file], source)) { + this.errors.push( + new WebpackError( + `Conflict: Multiple assets emit different content to the same filename ${file}${ + assetInfo.sourceFilename + ? `. Original source ${assetInfo.sourceFilename}` + : "" + }` + ) + ); + this.assets[file] = source; + this._setAssetInfo(file, assetInfo); + return; + } + const oldInfo = this.assetsInfo.get(file); + const newInfo = { ...oldInfo, ...assetInfo }; + this._setAssetInfo(file, newInfo, oldInfo); + return; + } + this.assets[file] = source; + this._setAssetInfo(file, assetInfo, undefined); + } + + /** + * Processes the provided file. + * @private + * @param {string} file file name + * @param {AssetInfo=} newInfo new asset information + * @param {AssetInfo=} oldInfo old asset information + */ + _setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) { + if (newInfo === undefined) { + this.assetsInfo.delete(file); + } else { + this.assetsInfo.set(file, newInfo); + } + const oldRelated = oldInfo && oldInfo.related; + const newRelated = newInfo && newInfo.related; + if (oldRelated) { + for (const key of Object.keys(oldRelated)) { + /** + * Processes the provided name. + * @param {string} name name + */ + const remove = (name) => { + const relatedIn = this._assetsRelatedIn.get(name); + if (relatedIn === undefined) return; + const entry = relatedIn.get(key); + if (entry === undefined) return; + entry.delete(file); + if (entry.size !== 0) return; + relatedIn.delete(key); + if (relatedIn.size === 0) this._assetsRelatedIn.delete(name); + }; + const entry = oldRelated[key]; + if (Array.isArray(entry)) { + for (const name of entry) { + remove(name); + } + } else if (entry) { + remove(entry); + } + } + } + if (newRelated) { + for (const key of Object.keys(newRelated)) { + /** + * Processes the provided name. + * @param {string} name name + */ + const add = (name) => { + let relatedIn = this._assetsRelatedIn.get(name); + if (relatedIn === undefined) { + this._assetsRelatedIn.set(name, (relatedIn = new Map())); + } + let entry = relatedIn.get(key); + if (entry === undefined) { + relatedIn.set(key, (entry = new Set())); + } + entry.add(file); + }; + const entry = newRelated[key]; + if (Array.isArray(entry)) { + for (const name of entry) { + add(name); + } + } else if (entry) { + add(entry); + } + } + } + } + + /** + * Updates asset using the provided file. + * @param {string} file file name + * @param {Source | ((source: Source) => Source)} newSourceOrFunction new asset source or function converting old to new + * @param {(AssetInfo | ((assetInfo?: AssetInfo) => AssetInfo | undefined)) | undefined} assetInfoUpdateOrFunction new asset info or function converting old to new + */ + updateAsset( + file, + newSourceOrFunction, + assetInfoUpdateOrFunction = undefined + ) { + if (!this.assets[file]) { + throw new Error( + `Called Compilation.updateAsset for not existing filename ${file}` + ); + } + this.assets[file] = + typeof newSourceOrFunction === "function" + ? newSourceOrFunction(this.assets[file]) + : newSourceOrFunction; + if (assetInfoUpdateOrFunction !== undefined) { + const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO; + if (typeof assetInfoUpdateOrFunction === "function") { + this._setAssetInfo(file, assetInfoUpdateOrFunction(oldInfo), oldInfo); + } else { + this._setAssetInfo( + file, + cachedCleverMerge(oldInfo, assetInfoUpdateOrFunction), + oldInfo + ); + } + } + } + + /** + * Processes the provided file. + * @param {string} file file name + * @param {string} newFile the new name of file + */ + renameAsset(file, newFile) { + const source = this.assets[file]; + if (!source) { + throw new Error( + `Called Compilation.renameAsset for not existing filename ${file}` + ); + } + if (this.assets[newFile] && !isSourceEqual(this.assets[file], source)) { + this.errors.push( + new WebpackError( + `Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content` + ) + ); + } + const assetInfo = this.assetsInfo.get(file); + // Update related in all other assets + const relatedInInfo = this._assetsRelatedIn.get(file); + if (relatedInInfo) { + for (const [key, assets] of relatedInInfo) { + for (const name of assets) { + const info = this.assetsInfo.get(name); + if (!info) continue; + const related = info.related; + if (!related) continue; + const entry = related[key]; + /** @type {string | string[]} */ + let newEntry; + if (Array.isArray(entry)) { + newEntry = entry.map((x) => (x === file ? newFile : x)); + } else if (entry === file) { + newEntry = newFile; + } else { + continue; + } + this.assetsInfo.set(name, { + ...info, + related: { + ...related, + [key]: newEntry + } + }); + } + } + } + this._setAssetInfo(file, undefined, assetInfo); + this._setAssetInfo(newFile, assetInfo); + delete this.assets[file]; + this.assets[newFile] = source; + for (const chunk of this.chunks) { + { + const size = chunk.files.size; + chunk.files.delete(file); + if (size !== chunk.files.size) { + chunk.files.add(newFile); + } + } + { + const size = chunk.auxiliaryFiles.size; + chunk.auxiliaryFiles.delete(file); + if (size !== chunk.auxiliaryFiles.size) { + chunk.auxiliaryFiles.add(newFile); + } + } + } + } + + /** + * Processes the provided file. + * @param {string} file file name + */ + deleteAsset(file) { + if (!this.assets[file]) { + return; + } + delete this.assets[file]; + const assetInfo = this.assetsInfo.get(file); + this._setAssetInfo(file, undefined, assetInfo); + const related = assetInfo && assetInfo.related; + if (related) { + for (const key of Object.keys(related)) { + /** + * Checks used and delete. + * @param {string} file file + */ + const checkUsedAndDelete = (file) => { + if (!this._assetsRelatedIn.has(file)) { + this.deleteAsset(file); + } + }; + const items = related[key]; + if (Array.isArray(items)) { + for (const file of items) { + checkUsedAndDelete(file); + } + } else if (items) { + checkUsedAndDelete(items); + } + } + } + // TODO If this becomes a performance problem + // store a reverse mapping from asset to chunk + for (const chunk of this.chunks) { + chunk.files.delete(file); + chunk.auxiliaryFiles.delete(file); + } + } + + getAssets() { + /** @type {Readonly[]} */ + const array = []; + for (const assetName of Object.keys(this.assets)) { + if (Object.prototype.hasOwnProperty.call(this.assets, assetName)) { + array.push({ + name: assetName, + source: this.assets[assetName], + info: this.assetsInfo.get(assetName) || EMPTY_ASSET_INFO + }); + } + } + return array; + } + + /** + * Returns the asset or undefined when not found. + * @param {string} name the name of the asset + * @returns {Readonly | undefined} the asset or undefined when not found + */ + getAsset(name) { + if (!Object.prototype.hasOwnProperty.call(this.assets, name)) return; + return { + name, + source: this.assets[name], + info: this.assetsInfo.get(name) || EMPTY_ASSET_INFO + }; + } + + clearAssets() { + for (const chunk of this.chunks) { + chunk.files.clear(); + chunk.auxiliaryFiles.clear(); + } + } + + createModuleAssets() { + const { chunkGraph } = this; + for (const module of this.modules) { + const buildInfo = /** @type {BuildInfo} */ (module.buildInfo); + if (buildInfo.assets) { + const assetsInfo = buildInfo.assetsInfo; + for (const assetName of Object.keys(buildInfo.assets)) { + const fileName = this.getPath(assetName, { + chunkGraph: this.chunkGraph, + module + }); + for (const chunk of chunkGraph.getModuleChunksIterable(module)) { + chunk.auxiliaryFiles.add(fileName); + } + this.emitAsset( + fileName, + buildInfo.assets[assetName], + assetsInfo ? assetsInfo.get(assetName) : undefined + ); + this.hooks.moduleAsset.call(module, fileName); + } + } + } + } + + /** + * Gets render manifest. + * @param {RenderManifestOptions} options options object + * @returns {RenderManifestEntry[]} manifest entries + */ + getRenderManifest(options) { + return this.hooks.renderManifest.call([], options); + } + + /** + * Creates a chunk assets. + * @param {Callback} callback signals when the call finishes + * @returns {void} + */ + createChunkAssets(callback) { + const outputOptions = this.outputOptions; + /** @type {WeakMap} */ + const cachedSourceMap = new WeakMap(); + /** @type {Map} */ + const alreadyWrittenFiles = new Map(); + + asyncLib.forEachLimit( + this.chunks, + 15, + (chunk, callback) => { + /** @type {RenderManifestEntry[]} */ + let manifest; + try { + manifest = this.getRenderManifest({ + chunk, + hash: /** @type {string} */ (this.hash), + fullHash: /** @type {string} */ (this.fullHash), + outputOptions, + codeGenerationResults: + /** @type {CodeGenerationResults} */ + (this.codeGenerationResults), + moduleTemplates: this.moduleTemplates, + dependencyTemplates: this.dependencyTemplates, + chunkGraph: this.chunkGraph, + moduleGraph: this.moduleGraph, + runtimeTemplate: this.runtimeTemplate + }); + } catch (err) { + this.errors.push( + new ChunkRenderError(chunk, "", /** @type {Error} */ (err)) + ); + return callback(); + } + asyncLib.each( + manifest, + (fileManifest, callback) => { + const ident = fileManifest.identifier; + const usedHash = /** @type {string} */ (fileManifest.hash); + + const assetCacheItem = this._assetsCache.getItemCache( + ident, + usedHash + ); + + assetCacheItem.get((err, sourceFromCache) => { + /** @type {string | import("./TemplatedPathPlugin").TemplatePathFn} */ + let filenameTemplate; + /** @type {string} */ + let file; + /** @type {AssetInfo} */ + let assetInfo; + + let inTry = true; + /** + * Error and callback. + * @param {Error} err error + * @returns {void} + */ + const errorAndCallback = (err) => { + const filename = + file || + (typeof file === "string" + ? file + : typeof filenameTemplate === "string" + ? filenameTemplate + : ""); + + this.errors.push(new ChunkRenderError(chunk, filename, err)); + inTry = false; + return callback(); + }; + + try { + if ("filename" in fileManifest) { + file = fileManifest.filename; + assetInfo = fileManifest.info; + } else { + filenameTemplate = fileManifest.filenameTemplate; + const pathAndInfo = this.getPathWithInfo( + filenameTemplate, + fileManifest.pathOptions + ); + file = pathAndInfo.path; + assetInfo = fileManifest.info + ? { + ...pathAndInfo.info, + ...fileManifest.info + } + : pathAndInfo.info; + } + + if (err) { + return errorAndCallback(err); + } + + let source = sourceFromCache; + + // check if the same filename was already written by another chunk + const alreadyWritten = alreadyWrittenFiles.get(file); + if (alreadyWritten !== undefined) { + if (alreadyWritten.hash !== usedHash) { + inTry = false; + return callback( + new WebpackError( + `Conflict: Multiple chunks emit assets to the same filename ${file}` + + ` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})` + ) + ); + } + source = alreadyWritten.source; + } else if (!source) { + // render the asset + source = fileManifest.render(); + + // Ensure that source is a cached source to avoid additional cost because of repeated access + if (!(source instanceof CachedSource)) { + const cacheEntry = cachedSourceMap.get(source); + if (cacheEntry) { + source = cacheEntry; + } else { + const cachedSource = new CachedSource(source); + cachedSourceMap.set(source, cachedSource); + source = cachedSource; + } + } + } + this.emitAsset(file, source, assetInfo); + if (fileManifest.auxiliary) { + chunk.auxiliaryFiles.add(file); + } else { + chunk.files.add(file); + } + this.hooks.chunkAsset.call(chunk, file); + alreadyWrittenFiles.set(file, { + hash: usedHash, + source, + chunk + }); + if (source !== sourceFromCache) { + assetCacheItem.store(source, (err) => { + if (err) return errorAndCallback(err); + inTry = false; + return callback(); + }); + } else { + inTry = false; + callback(); + } + } catch (err) { + if (!inTry) throw err; + errorAndCallback(/** @type {Error} */ (err)); + } + }); + }, + callback + ); + }, + callback + ); + } + + /** + * Returns interpolated path. + * @template {PathData} [T=PathData] + * @param {string | import("./TemplatedPathPlugin").TemplatePathFn} filename used to get asset path with hash + * @param {T=} data context data + * @returns {string} interpolated path + */ + getPath(filename, data = /** @type {T} */ ({})) { + if (!data.hash) { + data = { + hash: this.hash, + ...data + }; + } + return this.getAssetPath(filename, data); + } + + /** + * Gets path with info. + * @template {PathData} [T=PathData] + * @param {string | import("./TemplatedPathPlugin").TemplatePathFn} filename used to get asset path with hash + * @param {T=} data context data + * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info + */ + getPathWithInfo(filename, data = /** @type {T} */ ({})) { + if (!data.hash) { + data = { + hash: this.hash, + ...data + }; + } + return this.getAssetPathWithInfo(filename, data); + } + + /** + * Returns interpolated path. + * @template {PathData} [T=PathData] + * @param {string | import("./TemplatedPathPlugin").TemplatePathFn} filename used to get asset path with hash + * @param {T} data context data + * @returns {string} interpolated path + */ + getAssetPath(filename, data) { + return this.hooks.assetPath.call( + typeof filename === "function" ? filename(data) : filename, + data, + undefined + ); + } + + /** + * Gets asset path with info. + * @template {PathData} [T=PathData] + * @param {string | import("./TemplatedPathPlugin").TemplatePathFn} filename used to get asset path with hash + * @param {T} data context data + * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info + */ + getAssetPathWithInfo(filename, data) { + const assetInfo = {}; + // TODO webpack 5: refactor assetPath hook to receive { path, info } object + const newPath = this.hooks.assetPath.call( + typeof filename === "function" ? filename(data, assetInfo) : filename, + data, + assetInfo + ); + return { path: newPath, info: assetInfo }; + } + + getWarnings() { + return this.hooks.processWarnings.call(this.warnings); + } + + getErrors() { + return this.hooks.processErrors.call(this.errors); + } + + /** + * This function allows you to run another instance of webpack inside of webpack however as + * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins + * from parent (or top level compiler) and creates a child Compilation + * @param {string} name name of the child compiler + * @param {Partial=} outputOptions // Need to convert config schema to types for this + * @param {Plugins=} plugins webpack plugins that will be applied + * @returns {Compiler} creates a child Compiler instance + */ + createChildCompiler(name, outputOptions, plugins) { + const idx = this.childrenCounters[name] || 0; + this.childrenCounters[name] = idx + 1; + return this.compiler.createChildCompiler( + this, + name, + idx, + outputOptions, + plugins + ); + } + + /** + * Processes the provided module. + * @param {Module} module the module + * @param {ExecuteModuleOptions} options options + * @param {ExecuteModuleCallback} callback callback + */ + executeModule(module, options, callback) { + // Aggregate all referenced modules and ensure they are ready + const modules = new Set([module]); + processAsyncTree( + modules, + 10, + (module, push, callback) => { + this.buildQueue.waitFor(module, (err) => { + if (err) return callback(err); + this.processDependenciesQueue.waitFor(module, (err) => { + if (err) return callback(err); + for (const { module: m } of this.moduleGraph.getOutgoingConnections( + module + )) { + const size = modules.size; + modules.add(m); + if (modules.size !== size) push(m); + } + callback(); + }); + }); + }, + (err) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + + // Create new chunk graph, chunk and entrypoint for the build time execution + const chunkGraph = new ChunkGraph( + this.moduleGraph, + this.outputOptions.hashFunction + ); + const runtime = "build time"; + const { hashFunction, hashDigest, hashDigestLength } = + this.outputOptions; + const runtimeTemplate = this.runtimeTemplate; + + const chunk = new Chunk("build time chunk", this._backCompat); + chunk.id = /** @type {ChunkId} */ (chunk.name); + chunk.ids = [chunk.id]; + chunk.runtime = runtime; + + const entrypoint = new Entrypoint({ + runtime, + chunkLoading: false, + ...options.entryOptions + }); + chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint); + if (entrypoint.pushChunk(chunk)) { + chunk.addGroup(entrypoint); + } + entrypoint.setRuntimeChunk(chunk); + entrypoint.setEntrypointChunk(chunk); + + const chunks = new Set([chunk]); + + // Assign ids to modules and modules to the chunk + for (const module of modules) { + const id = module.identifier(); + chunkGraph.setModuleId(module, id); + chunkGraph.connectChunkAndModule(chunk, module); + } + + /** @type {WebpackError[]} */ + const errors = []; + + // Hash modules + for (const module of modules) { + this._createModuleHash( + module, + chunkGraph, + runtime, + hashFunction, + runtimeTemplate, + hashDigest, + hashDigestLength, + errors + ); + } + + const codeGenerationResults = new CodeGenerationResults( + this.outputOptions.hashFunction + ); + /** + * Processes the provided module. + * @param {Module} module the module + * @param {Callback} callback callback + * @returns {void} + */ + const codeGen = (module, callback) => { + this._codeGenerationModule( + module, + runtime, + [runtime], + chunkGraph.getModuleHash(module, runtime), + this.dependencyTemplates, + chunkGraph, + this.moduleGraph, + runtimeTemplate, + errors, + codeGenerationResults, + (err, _codeGenerated) => { + callback(err); + } + ); + }; + + const reportErrors = () => { + if (errors.length > 0) { + errors.sort( + compareSelect((err) => err.module, compareModulesByIdentifier) + ); + for (const error of errors) { + this.errors.push(error); + } + errors.length = 0; + } + }; + + // Generate code for all aggregated modules + asyncLib.eachLimit( + /** @type {import("neo-async").IterableCollection} */ ( + /** @type {unknown} */ (modules) + ), + 10, + codeGen, + (err) => { + if (err) return callback(err); + reportErrors(); + + // for backward-compat temporary set the chunk graph + // TODO webpack 6 + const old = this.chunkGraph; + this.chunkGraph = chunkGraph; + this.processRuntimeRequirements({ + chunkGraph, + modules, + chunks, + codeGenerationResults, + chunkGraphEntries: chunks + }); + this.chunkGraph = old; + + const runtimeModules = + chunkGraph.getChunkRuntimeModulesIterable(chunk); + + // Hash runtime modules + for (const module of runtimeModules) { + modules.add(module); + this._createModuleHash( + module, + chunkGraph, + runtime, + hashFunction, + runtimeTemplate, + hashDigest, + hashDigestLength, + errors + ); + } + + // Generate code for all runtime modules + asyncLib.eachLimit( + /** @type {import("neo-async").IterableCollection} */ ( + runtimeModules + ), + 10, + codeGen, + (err) => { + if (err) return callback(err); + reportErrors(); + + /** @type {Map} */ + const moduleArgumentsMap = new Map(); + /** @type {Map} */ + const moduleArgumentsById = new Map(); + + /** @type {ExecuteModuleResult["fileDependencies"]} */ + const fileDependencies = new LazySet(); + /** @type {ExecuteModuleResult["contextDependencies"]} */ + const contextDependencies = new LazySet(); + /** @type {ExecuteModuleResult["missingDependencies"]} */ + const missingDependencies = new LazySet(); + /** @type {ExecuteModuleResult["buildDependencies"]} */ + const buildDependencies = new LazySet(); + + /** @type {ExecuteModuleResult["assets"]} */ + const assets = new Map(); + + let cacheable = true; + + /** @type {ExecuteModuleContext} */ + const context = { + assets, + __webpack_require__: undefined, + chunk, + chunkGraph + }; + + // Prepare execution + asyncLib.eachLimit( + modules, + 10, + (module, callback) => { + const codeGenerationResult = codeGenerationResults.get( + module, + runtime + ); + /** @type {ExecuteModuleArgument} */ + const moduleArgument = { + module, + codeGenerationResult, + moduleObject: undefined + }; + moduleArgumentsMap.set(module, moduleArgument); + moduleArgumentsById.set( + module.identifier(), + moduleArgument + ); + module.addCacheDependencies( + fileDependencies, + contextDependencies, + missingDependencies, + buildDependencies + ); + if ( + /** @type {BuildInfo} */ (module.buildInfo).cacheable === + false + ) { + cacheable = false; + } + if (module.buildInfo && module.buildInfo.assets) { + const { assets: moduleAssets, assetsInfo } = + module.buildInfo; + for (const assetName of Object.keys(moduleAssets)) { + assets.set(assetName, { + source: moduleAssets[assetName], + info: assetsInfo + ? assetsInfo.get(assetName) + : undefined + }); + } + } + this.hooks.prepareModuleExecution.callAsync( + moduleArgument, + context, + callback + ); + }, + (err) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + + /** @type {ExecuteModuleExports | undefined} */ + let exports; + try { + const { + strictModuleErrorHandling, + strictModuleExceptionHandling + } = this.outputOptions; + + /** @type {WebpackRequire} */ + const __webpack_require__ = (id) => { + const cached = moduleCache[id]; + if (cached !== undefined) { + if (cached.error) throw cached.error; + return cached.exports; + } + const moduleArgument = moduleArgumentsById.get(id); + return __webpack_require_module__( + /** @type {ExecuteModuleArgument} */ + (moduleArgument), + id + ); + }; + const interceptModuleExecution = (__webpack_require__[ + /** @type {"i"} */ + ( + RuntimeGlobals.interceptModuleExecution.replace( + `${RuntimeGlobals.require}.`, + "" + ) + ) + ] = /** @type {NonNullable} */ ([])); + const moduleCache = (__webpack_require__[ + /** @type {"c"} */ ( + RuntimeGlobals.moduleCache.replace( + `${RuntimeGlobals.require}.`, + "" + ) + ) + ] = /** @type {NonNullable} */ ({})); + + context.__webpack_require__ = __webpack_require__; + + /** + * Webpack require module. + * @param {ExecuteModuleArgument} moduleArgument the module argument + * @param {string=} id id + * @returns {ExecuteModuleExports} exports + */ + const __webpack_require_module__ = ( + moduleArgument, + id + ) => { + /** @type {ExecuteOptions} */ + const execOptions = { + id, + module: { + id, + exports: {}, + loaded: false, + error: undefined + }, + require: __webpack_require__ + }; + for (const handler of interceptModuleExecution) { + handler(execOptions); + } + const module = moduleArgument.module; + this.buildTimeExecutedModules.add(module); + const moduleObject = execOptions.module; + moduleArgument.moduleObject = moduleObject; + try { + if (id) moduleCache[id] = moduleObject; + + tryRunOrWebpackError( + () => + this.hooks.executeModule.call( + moduleArgument, + context + ), + "Compilation.hooks.executeModule" + ); + moduleObject.loaded = true; + return moduleObject.exports; + } catch (execErr) { + if (strictModuleExceptionHandling) { + if (id) delete moduleCache[id]; + } else if (strictModuleErrorHandling) { + moduleObject.error = + /** @type {WebpackError} */ + (execErr); + } + if (!(/** @type {WebpackError} */ (execErr).module)) { + /** @type {WebpackError} */ + (execErr).module = module; + } + throw execErr; + } + }; + + for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder( + chunk + )) { + __webpack_require_module__( + /** @type {ExecuteModuleArgument} */ + (moduleArgumentsMap.get(runtimeModule)) + ); + } + + exports = __webpack_require__(module.identifier()); + } catch (execErr) { + const { message, stack, module } = + /** @type {WebpackError} */ + (execErr); + const err = new WebpackError( + `Execution of module code from module graph (${ + /** @type {Module} */ + (module).readableIdentifier(this.requestShortener) + }) failed: ${message}`, + { cause: execErr } + ); + err.stack = stack; + err.module = module; + return callback(err); + } + + callback(null, { + exports, + assets, + cacheable, + fileDependencies, + contextDependencies, + missingDependencies, + buildDependencies + }); + } + ); + } + ); + } + ); + } + ); + } + + checkConstraints() { + const chunkGraph = this.chunkGraph; + + /** @type {Set} */ + const usedIds = new Set(); + + for (const module of this.modules) { + if (module.type === WEBPACK_MODULE_TYPE_RUNTIME) continue; + const moduleId = chunkGraph.getModuleId(module); + if (moduleId === null) continue; + if (usedIds.has(moduleId)) { + throw new Error(`checkConstraints: duplicate module id ${moduleId}`); + } + usedIds.add(moduleId); + } + + for (const chunk of this.chunks) { + for (const module of chunkGraph.getChunkModulesIterable(chunk)) { + if (!this.modules.has(module)) { + throw new Error( + "checkConstraints: module in chunk but not in compilation " + + ` ${chunk.debugId} ${module.debugId}` + ); + } + } + for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) { + if (!this.modules.has(module)) { + throw new Error( + "checkConstraints: entry module in chunk but not in compilation " + + ` ${chunk.debugId} ${module.debugId}` + ); + } + } + } + + for (const chunkGroup of this.chunkGroups) { + chunkGroup.checkConstraints(); + } + } +} + +/** + * Defines the factorize module options type used by this module. + * @typedef {object} FactorizeModuleOptions + * @property {ModuleProfile=} currentProfile + * @property {ModuleFactory} factory + * @property {Dependency[]} dependencies + * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module + * @property {Module | null} originModule + * @property {Partial=} contextInfo + * @property {string=} context + */ + +/** + * Processes the provided factorize module option. + * @param {FactorizeModuleOptions} options options object + * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback + * @returns {void} + */ + +// Hide from typescript +const compilationPrototype = Compilation.prototype; + +// TODO webpack 6 remove +Object.defineProperty(compilationPrototype, "modifyHash", { + writable: false, + enumerable: false, + configurable: false, + value: () => { + throw new Error( + "Compilation.modifyHash was removed in favor of Compilation.hooks.fullHash" + ); + } +}); + +// TODO webpack 6 remove +Object.defineProperty(compilationPrototype, "cache", { + enumerable: false, + configurable: false, + get: util.deprecate( + /** + * Returns the cache. + * @this {Compilation} the compilation + * @returns {Cache} the cache + */ + function cache() { + return this.compiler.cache; + }, + "Compilation.cache was removed in favor of Compilation.getCache()", + "DEP_WEBPACK_COMPILATION_CACHE" + ), + set: util.deprecate( + /** + * Handles the value callback for this hook. + * @param {EXPECTED_ANY} _v value + */ + (_v) => {}, + "Compilation.cache was removed in favor of Compilation.getCache()", + "DEP_WEBPACK_COMPILATION_CACHE" + ) +}); + +/** + * Add additional assets to the compilation. + */ +Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2000; + +/** + * Basic preprocessing of assets. + */ +Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS = -1000; + +/** + * Derive new assets from existing assets. + * Existing assets should not be treated as complete. + */ +Compilation.PROCESS_ASSETS_STAGE_DERIVED = -200; + +/** + * Add additional sections to existing assets, like a banner or initialization code. + */ +Compilation.PROCESS_ASSETS_STAGE_ADDITIONS = -100; + +/** + * Optimize existing assets in a general way. + */ +Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE = 100; + +/** + * Optimize the count of existing assets, e. g. by merging them. + * Only assets of the same type should be merged. + * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE. + */ +Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT = 200; + +/** + * Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes. + */ +Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY = 300; + +/** + * Optimize the size of existing assets, e. g. by minimizing or omitting whitespace. + */ +Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE = 400; + +/** + * Add development tooling to assets, e. g. by extracting a SourceMap. + */ +Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 500; + +/** + * Optimize the count of existing assets, e. g. by inlining assets of into other assets. + * Only assets of different types should be inlined. + * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT. + */ +Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE = 700; + +/** + * Summarize the list of existing assets + * e. g. creating an assets manifest of Service Workers. + */ +Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000; + +/** + * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content. + */ +Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500; + +/** + * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset. + */ +Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000; + +/** + * Analyse existing assets. + */ +Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000; + +/** + * Creating assets for reporting purposes. + */ +Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000; + +module.exports = Compilation; Index: frontend/node_modules/webpack/lib/Compiler.js =================================================================== --- frontend/node_modules/webpack/lib/Compiler.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Compiler.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1495 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const asyncLib = require("neo-async"); +const { + AsyncParallelHook, + AsyncSeriesHook, + SyncBailHook, + SyncHook +} = require("tapable"); +const { SizeOnlySource } = require("webpack-sources"); +const Cache = require("./Cache"); +const CacheFacade = require("./CacheFacade"); +const ChunkGraph = require("./ChunkGraph"); +const Compilation = require("./Compilation"); +const ContextModuleFactory = require("./ContextModuleFactory"); +const ModuleGraph = require("./ModuleGraph"); +const NormalModuleFactory = require("./NormalModuleFactory"); +const RequestShortener = require("./RequestShortener"); +const ResolverFactory = require("./ResolverFactory"); +const Stats = require("./Stats"); +const Watching = require("./Watching"); +const ConcurrentCompilationError = require("./errors/ConcurrentCompilationError"); +const WebpackError = require("./errors/WebpackError"); +const { Logger } = require("./logging/Logger"); +const { dirname, join, mkdirp } = require("./util/fs"); +const { makePathsRelative } = require("./util/identifier"); +const memoize = require("./util/memoize"); +const parseJson = require("./util/parseJson"); +const { isSourceEqual } = require("./util/source"); +const webpack = require("."); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */ +/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */ +/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */ +/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */ +/** @typedef {import("../declarations/WebpackOptions").Plugins} Plugins */ +/** @typedef {import("./webpack").WebpackPluginFunction} WebpackPluginFunction */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./HotModuleReplacementPlugin").ChunkHashes} ChunkHashes */ +/** @typedef {import("./HotModuleReplacementPlugin").ChunkModuleHashes} ChunkModuleHashes */ +/** @typedef {import("./HotModuleReplacementPlugin").ChunkModuleIds} ChunkModuleIds */ +/** @typedef {import("./HotModuleReplacementPlugin").ChunkRuntime} ChunkRuntime */ +/** @typedef {import("./HotModuleReplacementPlugin").FullHashChunkModuleHashes} FullHashChunkModuleHashes */ +/** @typedef {import("./HotModuleReplacementPlugin").HotIndex} HotIndex */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./RecordIdsPlugin").RecordsChunks} RecordsChunks */ +/** @typedef {import("./RecordIdsPlugin").RecordsModules} RecordsModules */ +/** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */ +/** @typedef {import("./logging/createConsoleLogger").LoggingFunction} LoggingFunction */ +/** @typedef {import("./optimize/AggressiveSplittingPlugin").SplitData} SplitData */ +/** @typedef {import("./util/fs").IStats} IStats */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */ +/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */ +/** @typedef {import("./util/fs").TimeInfoEntries} TimeInfoEntries */ +/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */ +/** @typedef {import("schema-utils").validate} Validate */ +/** @typedef {import("schema-utils").Schema} Schema */ +/** @typedef {import("schema-utils").ValidationErrorConfiguration} ValidationErrorConfiguration */ + +/** + * Defines the compilation params type used by this module. + * @typedef {object} CompilationParams + * @property {NormalModuleFactory} normalModuleFactory + * @property {ContextModuleFactory} contextModuleFactory + */ + +/** + * Defines the callback type used by this module. + * @template T + * @template [R=void] + * @typedef {import("./webpack").Callback} Callback + */ + +/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */ + +/** + * Defines the run as child callback callback. + * @callback RunAsChildCallback + * @param {Error | null} err + * @param {Chunk[]=} entries + * @param {Compilation=} compilation + * @returns {void} + */ + +/** + * Defines the known records type used by this module. + * @typedef {object} KnownRecords + * @property {SplitData[]=} aggressiveSplits + * @property {RecordsChunks=} chunks + * @property {RecordsModules=} modules + * @property {string=} hash + * @property {HotIndex=} hotIndex + * @property {FullHashChunkModuleHashes=} fullHashChunkModuleHashes + * @property {ChunkModuleHashes=} chunkModuleHashes + * @property {ChunkHashes=} chunkHashes + * @property {ChunkRuntime=} chunkRuntime + * @property {ChunkModuleIds=} chunkModuleIds + */ + +/** @typedef {KnownRecords & Record & Record} Records */ + +/** + * Defines the asset emitted info type used by this module. + * @typedef {object} AssetEmittedInfo + * @property {Buffer} content + * @property {Source} source + * @property {Compilation} compilation + * @property {string} outputPath + * @property {string} targetPath + */ + +/** @typedef {{ sizeOnlySource: SizeOnlySource | undefined, writtenTo: Map }} CacheEntry */ +/** @typedef {{ path: string, source: Source, size: number | undefined, waiting: ({ cacheEntry: CacheEntry, file: string }[] | undefined) }} SimilarEntry */ + +/** @typedef {WeakMap} WeakReferences */ +/** @typedef {import("./util/WeakTupleMap")} MemCache */ +/** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, memCache: MemCache }} ModuleMemCachesItem */ + +/** + * Checks whether this object is sorted. + * @template T + * @param {T[]} array an array + * @returns {boolean} true, if the array is sorted + */ +const isSorted = (array) => { + for (let i = 1; i < array.length; i++) { + if (array[i - 1] > array[i]) return false; + } + return true; +}; + +/** + * Returns the object with properties sorted by property name. + * @template {object} T + * @param {T} obj an object + * @param {(keyof T)[]} keys the keys of the object + * @returns {T} the object with properties sorted by property name + */ +const sortObject = (obj, keys) => { + const o = /** @type {T} */ ({}); + for (const k of keys.sort()) { + o[k] = obj[k]; + } + return o; +}; + +/** + * Returns true, if the filename contains any hash. + * @param {string} filename filename + * @param {string | string[] | undefined} hashes list of hashes + * @returns {boolean} true, if the filename contains any hash + */ +const includesHash = (filename, hashes) => { + if (!hashes) return false; + if (Array.isArray(hashes)) { + return hashes.some((hash) => filename.includes(hash)); + } + return filename.includes(hashes); +}; + +const getValidate = memoize(() => require("schema-utils").validate); + +class Compiler { + /** + * Creates an instance of Compiler. + * @param {string} context the compilation path + * @param {WebpackOptions} options options + */ + constructor(context, options = /** @type {WebpackOptions} */ ({})) { + this.hooks = Object.freeze({ + /** @type {SyncHook<[]>} */ + initialize: new SyncHook([]), + + /** @type {SyncBailHook<[Compilation], boolean | void>} */ + shouldEmit: new SyncBailHook(["compilation"]), + /** @type {AsyncSeriesHook<[Stats]>} */ + done: new AsyncSeriesHook(["stats"]), + /** @type {SyncHook<[Stats]>} */ + afterDone: new SyncHook(["stats"]), + /** @type {AsyncSeriesHook<[]>} */ + additionalPass: new AsyncSeriesHook([]), + /** @type {AsyncSeriesHook<[Compiler]>} */ + beforeRun: new AsyncSeriesHook(["compiler"]), + /** @type {AsyncSeriesHook<[Compiler]>} */ + run: new AsyncSeriesHook(["compiler"]), + /** @type {AsyncSeriesHook<[Compilation]>} */ + emit: new AsyncSeriesHook(["compilation"]), + /** @type {AsyncSeriesHook<[string, AssetEmittedInfo]>} */ + assetEmitted: new AsyncSeriesHook(["file", "info"]), + /** @type {AsyncSeriesHook<[Compilation]>} */ + afterEmit: new AsyncSeriesHook(["compilation"]), + + /** @type {SyncHook<[Compilation, CompilationParams]>} */ + thisCompilation: new SyncHook(["compilation", "params"]), + /** @type {SyncHook<[Compilation, CompilationParams]>} */ + compilation: new SyncHook(["compilation", "params"]), + /** @type {SyncHook<[NormalModuleFactory]>} */ + normalModuleFactory: new SyncHook(["normalModuleFactory"]), + /** @type {SyncHook<[ContextModuleFactory]>} */ + contextModuleFactory: new SyncHook(["contextModuleFactory"]), + + /** @type {AsyncSeriesHook<[CompilationParams]>} */ + beforeCompile: new AsyncSeriesHook(["params"]), + /** @type {SyncHook<[CompilationParams]>} */ + compile: new SyncHook(["params"]), + /** @type {AsyncParallelHook<[Compilation]>} */ + make: new AsyncParallelHook(["compilation"]), + /** @type {AsyncParallelHook<[Compilation]>} */ + finishMake: new AsyncSeriesHook(["compilation"]), + /** @type {AsyncSeriesHook<[Compilation]>} */ + afterCompile: new AsyncSeriesHook(["compilation"]), + + /** @type {AsyncSeriesHook<[]>} */ + readRecords: new AsyncSeriesHook([]), + /** @type {AsyncSeriesHook<[]>} */ + emitRecords: new AsyncSeriesHook([]), + + /** @type {AsyncSeriesHook<[Compiler]>} */ + watchRun: new AsyncSeriesHook(["compiler"]), + /** @type {SyncHook<[Error]>} */ + failed: new SyncHook(["error"]), + /** @type {SyncHook<[string | null, number]>} */ + invalid: new SyncHook(["filename", "changeTime"]), + /** @type {SyncHook<[]>} */ + watchClose: new SyncHook([]), + /** @type {AsyncSeriesHook<[]>} */ + shutdown: new AsyncSeriesHook([]), + + /** @type {SyncBailHook<[string, string, EXPECTED_ANY[] | undefined], true | void>} */ + infrastructureLog: new SyncBailHook(["origin", "type", "args"]), + + // TODO the following hooks are weirdly located here + // TODO move them for webpack 5 + /** @type {SyncHook<[]>} */ + validate: new SyncHook([]), + /** @type {SyncHook<[]>} */ + environment: new SyncHook([]), + /** @type {SyncHook<[]>} */ + afterEnvironment: new SyncHook([]), + /** @type {SyncHook<[Compiler]>} */ + afterPlugins: new SyncHook(["compiler"]), + /** @type {SyncHook<[Compiler]>} */ + afterResolvers: new SyncHook(["compiler"]), + /** @type {SyncBailHook<[string, Entry], boolean | void>} */ + entryOption: new SyncBailHook(["context", "entry"]) + }); + + this.webpack = webpack; + + /** @type {string | undefined} */ + this.name = undefined; + /** @type {Compilation | undefined} */ + this.parentCompilation = undefined; + /** @type {Compiler} */ + this.root = this; + /** @type {string} */ + this.outputPath = ""; + /** @type {Watching | undefined} */ + this.watching = undefined; + + /** @type {OutputFileSystem | null} */ + this.outputFileSystem = null; + /** @type {IntermediateFileSystem | null} */ + this.intermediateFileSystem = null; + /** @type {InputFileSystem | null} */ + this.inputFileSystem = null; + /** @type {WatchFileSystem | null} */ + this.watchFileSystem = null; + + /** @type {string | null} */ + this.recordsInputPath = null; + /** @type {string | null} */ + this.recordsOutputPath = null; + /** @type {Records} */ + this.records = {}; + /** @type {Set} */ + this.managedPaths = new Set(); + /** @type {Set} */ + this.unmanagedPaths = new Set(); + /** @type {Set} */ + this.immutablePaths = new Set(); + + /** @type {ReadonlySet | undefined} */ + this.modifiedFiles = undefined; + /** @type {ReadonlySet | undefined} */ + this.removedFiles = undefined; + /** @type {TimeInfoEntries | undefined} */ + this.fileTimestamps = undefined; + /** @type {TimeInfoEntries | undefined} */ + this.contextTimestamps = undefined; + /** @type {number | undefined} */ + this.fsStartTime = undefined; + + /** @type {ResolverFactory} */ + this.resolverFactory = new ResolverFactory(); + + /** @type {LoggingFunction | undefined} */ + this.infrastructureLogger = undefined; + + /** @type {Readonly} */ + this.platform = { + web: null, + browser: null, + webworker: null, + node: null, + nwjs: null, + electron: null + }; + + this.options = options; + + this.context = context; + + this.requestShortener = new RequestShortener(context, this.root); + + this.cache = new Cache(); + + /** @type {Map | undefined} */ + this.moduleMemCaches = undefined; + + this.compilerPath = ""; + + /** @type {boolean} */ + this.running = false; + + /** @type {boolean} */ + this.idle = false; + + /** @type {boolean} */ + this.watchMode = false; + + this._backCompat = this.options.experiments.backCompat !== false; + + /** @type {Compilation | undefined} */ + this._lastCompilation = undefined; + /** @type {NormalModuleFactory | undefined} */ + this._lastNormalModuleFactory = undefined; + + /** + * @private + * @type {WeakMap} + */ + this._assetEmittingSourceCache = new WeakMap(); + /** + * @private + * @type {Map} + */ + this._assetEmittingWrittenFiles = new Map(); + /** + * @private + * @type {Set} + */ + this._assetEmittingPreviousFiles = new Set(); + } + + /** + * Returns the cache facade instance. + * @param {string} name cache name + * @returns {CacheFacade} the cache facade instance + */ + getCache(name) { + return new CacheFacade( + this.cache, + `${this.compilerPath}${name}`, + this.options.output.hashFunction + ); + } + + /** + * Gets infrastructure logger. + * @param {string | (() => string)} name name of the logger, or function called once to get the logger name + * @returns {Logger} a logger with that name + */ + getInfrastructureLogger(name) { + if (!name) { + throw new TypeError( + "Compiler.getInfrastructureLogger(name) called without a name" + ); + } + return new Logger( + (type, args) => { + if (typeof name === "function") { + name = name(); + if (!name) { + throw new TypeError( + "Compiler.getInfrastructureLogger(name) called with a function not returning a name" + ); + } + } + if ( + this.hooks.infrastructureLog.call(name, type, args) === undefined && + this.infrastructureLogger !== undefined + ) { + this.infrastructureLogger(name, type, args); + } + }, + (childName) => { + if (typeof name === "function") { + if (typeof childName === "function") { + return this.getInfrastructureLogger(() => { + if (typeof name === "function") { + name = name(); + if (!name) { + throw new TypeError( + "Compiler.getInfrastructureLogger(name) called with a function not returning a name" + ); + } + } + if (typeof childName === "function") { + childName = childName(); + if (!childName) { + throw new TypeError( + "Logger.getChildLogger(name) called with a function not returning a name" + ); + } + } + return `${name}/${childName}`; + }); + } + return this.getInfrastructureLogger(() => { + if (typeof name === "function") { + name = name(); + if (!name) { + throw new TypeError( + "Compiler.getInfrastructureLogger(name) called with a function not returning a name" + ); + } + } + return `${name}/${childName}`; + }); + } + if (typeof childName === "function") { + return this.getInfrastructureLogger(() => { + if (typeof childName === "function") { + childName = childName(); + if (!childName) { + throw new TypeError( + "Logger.getChildLogger(name) called with a function not returning a name" + ); + } + } + return `${name}/${childName}`; + }); + } + return this.getInfrastructureLogger(`${name}/${childName}`); + } + ); + } + + // TODO webpack 6: solve this in a better way + // e.g. move compilation specific info from Modules into ModuleGraph + _cleanupLastCompilation() { + if (this._lastCompilation !== undefined) { + for (const childCompilation of this._lastCompilation.children) { + for (const module of childCompilation.modules) { + ChunkGraph.clearChunkGraphForModule(module); + ModuleGraph.clearModuleGraphForModule(module); + module.cleanupForCache(); + } + for (const chunk of childCompilation.chunks) { + ChunkGraph.clearChunkGraphForChunk(chunk); + } + } + + for (const module of this._lastCompilation.modules) { + ChunkGraph.clearChunkGraphForModule(module); + ModuleGraph.clearModuleGraphForModule(module); + module.cleanupForCache(); + } + for (const chunk of this._lastCompilation.chunks) { + ChunkGraph.clearChunkGraphForChunk(chunk); + } + this._lastCompilation = undefined; + } + } + + // TODO webpack 6: solve this in a better way + _cleanupLastNormalModuleFactory() { + if (this._lastNormalModuleFactory !== undefined) { + this._lastNormalModuleFactory.cleanupForCache(); + this._lastNormalModuleFactory = undefined; + } + } + + /** + * Returns a compiler watcher. + * @param {WatchOptions} watchOptions the watcher's options + * @param {Callback} handler signals when the call finishes + * @returns {Watching | undefined} a compiler watcher + */ + watch(watchOptions, handler) { + if (this.running) { + handler(new ConcurrentCompilationError()); + return; + } + + this.running = true; + this.watchMode = true; + this.watching = new Watching(this, watchOptions, handler); + return this.watching; + } + + /** + * Processes the provided stat. + * @param {Callback} callback signals when the call finishes + * @returns {void} + */ + run(callback) { + if (this.running) { + callback(new ConcurrentCompilationError()); + return; + } + + /** @type {Logger | undefined} */ + let logger; + + /** + * Processes the provided err. + * @param {Error | null} err error + * @param {Stats=} stats stats + */ + const finalCallback = (err, stats) => { + if (logger) logger.time("beginIdle"); + this.idle = true; + this.cache.beginIdle(); + if (logger) logger.timeEnd("beginIdle"); + this.running = false; + if (err) { + this.hooks.failed.call(err); + } + if (callback !== undefined) callback(err, stats); + this.hooks.afterDone.call(/** @type {Stats} */ (stats)); + }; + + const startTime = Date.now(); + + this.running = true; + + /** + * Processes the provided err. + * @param {Error | null} err error + * @param {Compilation=} _compilation compilation + * @returns {void} + */ + const onCompiled = (err, _compilation) => { + if (err) return finalCallback(err); + + const compilation = /** @type {Compilation} */ (_compilation); + + if (this.hooks.shouldEmit.call(compilation) === false) { + compilation.startTime = startTime; + compilation.endTime = Date.now(); + const stats = new Stats(compilation); + this.hooks.done.callAsync(stats, (err) => { + if (err) return finalCallback(err); + return finalCallback(null, stats); + }); + return; + } + + process.nextTick(() => { + logger = compilation.getLogger("webpack.Compiler"); + logger.time("emitAssets"); + this.emitAssets(compilation, (err) => { + /** @type {Logger} */ + (logger).timeEnd("emitAssets"); + if (err) return finalCallback(err); + + if (compilation.hooks.needAdditionalPass.call()) { + compilation.needAdditionalPass = true; + + compilation.startTime = startTime; + compilation.endTime = Date.now(); + /** @type {Logger} */ + (logger).time("done hook"); + const stats = new Stats(compilation); + this.hooks.done.callAsync(stats, (err) => { + /** @type {Logger} */ + (logger).timeEnd("done hook"); + if (err) return finalCallback(err); + + this.hooks.additionalPass.callAsync((err) => { + if (err) return finalCallback(err); + this.compile(onCompiled); + }); + }); + return; + } + + /** @type {Logger} */ + (logger).time("emitRecords"); + this.emitRecords((err) => { + /** @type {Logger} */ + (logger).timeEnd("emitRecords"); + if (err) return finalCallback(err); + + compilation.startTime = startTime; + compilation.endTime = Date.now(); + /** @type {Logger} */ + (logger).time("done hook"); + const stats = new Stats(compilation); + this.hooks.done.callAsync(stats, (err) => { + /** @type {Logger} */ + (logger).timeEnd("done hook"); + if (err) return finalCallback(err); + this.cache.storeBuildDependencies( + compilation.buildDependencies, + (err) => { + if (err) return finalCallback(err); + return finalCallback(null, stats); + } + ); + }); + }); + }); + }); + }; + + const run = () => { + this.hooks.beforeRun.callAsync(this, (err) => { + if (err) return finalCallback(err); + + this.hooks.run.callAsync(this, (err) => { + if (err) return finalCallback(err); + + this.readRecords((err) => { + if (err) return finalCallback(err); + + this.compile(onCompiled); + }); + }); + }); + }; + + if (this.idle) { + this.cache.endIdle((err) => { + if (err) return finalCallback(err); + + this.idle = false; + run(); + }); + } else { + run(); + } + } + + /** + * Processes the provided run as child callback. + * @param {RunAsChildCallback} callback signals when the call finishes + * @returns {void} + */ + runAsChild(callback) { + const startTime = Date.now(); + + /** + * Processes the provided err. + * @param {Error | null} err error + * @param {Chunk[]=} entries entries + * @param {Compilation=} compilation compilation + */ + const finalCallback = (err, entries, compilation) => { + try { + callback(err, entries, compilation); + } catch (runAsChildErr) { + const err = new WebpackError( + `compiler.runAsChild callback error: ${runAsChildErr}`, + { cause: runAsChildErr } + ); + err.details = /** @type {Error} */ (runAsChildErr).stack; + /** @type {Compilation} */ + (this.parentCompilation).errors.push(err); + } + }; + + this.compile((err, _compilation) => { + if (err) return finalCallback(err); + + const compilation = /** @type {Compilation} */ (_compilation); + const parentCompilation = /** @type {Compilation} */ ( + this.parentCompilation + ); + + parentCompilation.children.push(compilation); + + for (const { name, source, info } of compilation.getAssets()) { + parentCompilation.emitAsset(name, source, info); + } + + /** @type {Chunk[]} */ + const entries = []; + + for (const ep of compilation.entrypoints.values()) { + entries.push(...ep.chunks); + } + + compilation.startTime = startTime; + compilation.endTime = Date.now(); + + return finalCallback(null, entries, compilation); + }); + } + + purgeInputFileSystem() { + if (this.inputFileSystem && this.inputFileSystem.purge) { + this.inputFileSystem.purge(); + } + } + + /** + * Processes the provided compilation. + * @param {Compilation} compilation the compilation + * @param {ErrorCallback} callback signals when the assets are emitted + * @returns {void} + */ + emitAssets(compilation, callback) { + /** @type {string} */ + let outputPath; + + /** + * Processes the provided err. + * @param {Error=} err error + * @returns {void} + */ + const emitFiles = (err) => { + if (err) return callback(err); + + const assets = compilation.getAssets(); + compilation.assets = { ...compilation.assets }; + /** @type {Map} */ + const caseInsensitiveMap = new Map(); + /** @type {Set} */ + const allTargetPaths = new Set(); + asyncLib.forEachLimit( + assets, + 15, + ({ name: file, source, info }, callback) => { + let targetFile = file; + let immutable = info.immutable; + const queryOrHashStringIdx = targetFile.search(/[?#]/); + if (queryOrHashStringIdx >= 0) { + targetFile = targetFile.slice(0, queryOrHashStringIdx); + // We may remove the hash, which is in the query string + // So we recheck if the file is immutable + // This doesn't cover all cases, but immutable is only a performance optimization anyway + immutable = + immutable && + (includesHash(targetFile, info.contenthash) || + includesHash(targetFile, info.chunkhash) || + includesHash(targetFile, info.modulehash) || + includesHash(targetFile, info.fullhash)); + } + + /** + * Processes the provided err. + * @param {Error=} err error + * @returns {void} + */ + const writeOut = (err) => { + if (err) return callback(err); + const targetPath = join( + /** @type {OutputFileSystem} */ + (this.outputFileSystem), + outputPath, + targetFile + ); + allTargetPaths.add(targetPath); + + // check if the target file has already been written by this Compiler + const targetFileGeneration = + this._assetEmittingWrittenFiles.get(targetPath); + + // create an cache entry for this Source if not already existing + let cacheEntry = this._assetEmittingSourceCache.get(source); + if (cacheEntry === undefined) { + cacheEntry = { + sizeOnlySource: undefined, + /** @type {CacheEntry["writtenTo"]} */ + writtenTo: new Map() + }; + this._assetEmittingSourceCache.set(source, cacheEntry); + } + + /** @type {SimilarEntry | undefined} */ + let similarEntry; + + const checkSimilarFile = () => { + const caseInsensitiveTargetPath = targetPath.toLowerCase(); + similarEntry = caseInsensitiveMap.get(caseInsensitiveTargetPath); + if (similarEntry !== undefined) { + const { path: other, source: otherSource } = similarEntry; + if (isSourceEqual(otherSource, source)) { + // Size may or may not be available at this point. + // If it's not available add to "waiting" list and it will be updated once available + if (similarEntry.size !== undefined) { + updateWithReplacementSource(similarEntry.size); + } else { + if (!similarEntry.waiting) similarEntry.waiting = []; + similarEntry.waiting.push({ file, cacheEntry }); + } + alreadyWritten(); + } else { + const err = + new WebpackError(`Prevent writing to file that only differs in casing or query string from already written file. +This will lead to a race-condition and corrupted files on case-insensitive file systems. +${targetPath} +${other}`); + err.file = file; + callback(err); + } + return true; + } + caseInsensitiveMap.set( + caseInsensitiveTargetPath, + (similarEntry = /** @type {SimilarEntry} */ ({ + path: targetPath, + source, + size: undefined, + waiting: undefined + })) + ); + return false; + }; + + /** + * get the binary (Buffer) content from the Source + * @returns {Buffer} content for the source + */ + const getContent = () => { + if (typeof source.buffer === "function") { + return source.buffer(); + } + const bufferOrString = source.source(); + if (Buffer.isBuffer(bufferOrString)) { + return bufferOrString; + } + return Buffer.from(bufferOrString, "utf8"); + }; + + const alreadyWritten = () => { + // cache the information that the Source has been already been written to that location + if (targetFileGeneration === undefined) { + const newGeneration = 1; + this._assetEmittingWrittenFiles.set(targetPath, newGeneration); + /** @type {CacheEntry} */ + (cacheEntry).writtenTo.set(targetPath, newGeneration); + } else { + /** @type {CacheEntry} */ + (cacheEntry).writtenTo.set(targetPath, targetFileGeneration); + } + callback(); + }; + + /** + * Write the file to output file system + * @param {Buffer} content content to be written + * @returns {void} + */ + const doWrite = (content) => { + /** @type {OutputFileSystem} */ + (this.outputFileSystem).writeFile(targetPath, content, (err) => { + if (err) return callback(err); + + // information marker that the asset has been emitted + compilation.emittedAssets.add(file); + + // cache the information that the Source has been written to that location + const newGeneration = + targetFileGeneration === undefined + ? 1 + : targetFileGeneration + 1; + /** @type {CacheEntry} */ + (cacheEntry).writtenTo.set(targetPath, newGeneration); + this._assetEmittingWrittenFiles.set(targetPath, newGeneration); + this.hooks.assetEmitted.callAsync( + file, + { + content, + source, + outputPath, + compilation, + targetPath + }, + callback + ); + }); + }; + + /** + * Updates with replacement source. + * @param {number} size size + */ + const updateWithReplacementSource = (size) => { + updateFileWithReplacementSource( + file, + /** @type {CacheEntry} */ (cacheEntry), + size + ); + /** @type {SimilarEntry} */ + (similarEntry).size = size; + if ( + /** @type {SimilarEntry} */ (similarEntry).waiting !== undefined + ) { + for (const { file, cacheEntry } of /** @type {SimilarEntry} */ ( + similarEntry + ).waiting) { + updateFileWithReplacementSource(file, cacheEntry, size); + } + } + }; + + /** + * Updates file with replacement source. + * @param {string} file file + * @param {CacheEntry} cacheEntry cache entry + * @param {number} size size + */ + const updateFileWithReplacementSource = ( + file, + cacheEntry, + size + ) => { + // Create a replacement resource which only allows to ask for size + // This allows to GC all memory allocated by the Source + // (expect when the Source is stored in any other cache) + if (!cacheEntry.sizeOnlySource) { + cacheEntry.sizeOnlySource = new SizeOnlySource(size); + } + compilation.updateAsset(file, cacheEntry.sizeOnlySource, { + size + }); + }; + + /** + * Process existing file. + * @param {IStats} stats stats + * @returns {void} + */ + const processExistingFile = (stats) => { + // skip emitting if it's already there and an immutable file + if (immutable) { + updateWithReplacementSource(/** @type {number} */ (stats.size)); + return alreadyWritten(); + } + + const content = getContent(); + + updateWithReplacementSource(content.length); + + // if it exists and content on disk matches content + // skip writing the same content again + // (to keep mtime and don't trigger watchers) + // for a fast negative match file size is compared first + if (content.length === stats.size) { + compilation.comparedForEmitAssets.add(file); + return /** @type {OutputFileSystem} */ ( + this.outputFileSystem + ).readFile(targetPath, (err, existingContent) => { + if ( + err || + !content.equals(/** @type {Buffer} */ (existingContent)) + ) { + return doWrite(content); + } + return alreadyWritten(); + }); + } + + return doWrite(content); + }; + + const processMissingFile = () => { + const content = getContent(); + + updateWithReplacementSource(content.length); + + return doWrite(content); + }; + + // if the target file has already been written + if (targetFileGeneration !== undefined) { + // check if the Source has been written to this target file + const writtenGeneration = /** @type {CacheEntry} */ ( + cacheEntry + ).writtenTo.get(targetPath); + if (writtenGeneration === targetFileGeneration) { + // if yes, we may skip writing the file + // if it's already there + // (we assume one doesn't modify files while the Compiler is running, other then removing them) + + if (this._assetEmittingPreviousFiles.has(targetPath)) { + const sizeOnlySource = /** @type {SizeOnlySource} */ ( + /** @type {CacheEntry} */ (cacheEntry).sizeOnlySource + ); + + // We assume that assets from the last compilation say intact on disk (they are not removed) + compilation.updateAsset(file, sizeOnlySource, { + size: sizeOnlySource.size() + }); + + return callback(); + } + // Settings immutable will make it accept file content without comparing when file exist + immutable = true; + } else if (!immutable) { + if (checkSimilarFile()) return; + // We wrote to this file before which has very likely a different content + // skip comparing and assume content is different for performance + // This case happens often during watch mode. + return processMissingFile(); + } + } + + if (checkSimilarFile()) return; + if (this.options.output.compareBeforeEmit) { + /** @type {OutputFileSystem} */ + (this.outputFileSystem).stat(targetPath, (err, stats) => { + const exists = !err && /** @type {IStats} */ (stats).isFile(); + + if (exists) { + processExistingFile(/** @type {IStats} */ (stats)); + } else { + processMissingFile(); + } + }); + } else { + processMissingFile(); + } + }; + + if (/\/|\\/.test(targetFile)) { + const fs = /** @type {OutputFileSystem} */ (this.outputFileSystem); + const dir = dirname(fs, join(fs, outputPath, targetFile)); + mkdirp(fs, dir, writeOut); + } else { + writeOut(); + } + }, + (err) => { + // Clear map to free up memory + caseInsensitiveMap.clear(); + if (err) { + this._assetEmittingPreviousFiles.clear(); + return callback(err); + } + + this._assetEmittingPreviousFiles = allTargetPaths; + + this.hooks.afterEmit.callAsync(compilation, (err) => { + if (err) return callback(err); + + return callback(null); + }); + } + ); + }; + + this.hooks.emit.callAsync(compilation, (err) => { + if (err) return callback(err); + outputPath = compilation.getPath(this.outputPath, {}); + mkdirp( + /** @type {OutputFileSystem} */ (this.outputFileSystem), + outputPath, + emitFiles + ); + }); + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the call finishes + * @returns {void} + */ + emitRecords(callback) { + if (this.hooks.emitRecords.isUsed()) { + if (this.recordsOutputPath) { + asyncLib.parallel( + [ + (cb) => this.hooks.emitRecords.callAsync(cb), + this._emitRecords.bind(this) + ], + (err) => callback(/** @type {Error | null} */ (err)) + ); + } else { + this.hooks.emitRecords.callAsync(callback); + } + } else if (this.recordsOutputPath) { + this._emitRecords(callback); + } else { + callback(null); + } + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the call finishes + * @returns {void} + */ + _emitRecords(callback) { + const writeFile = () => { + /** @type {OutputFileSystem} */ + (this.outputFileSystem).writeFile( + /** @type {string} */ (this.recordsOutputPath), + JSON.stringify( + this.records, + (n, value) => { + if ( + typeof value === "object" && + value !== null && + !Array.isArray(value) + ) { + const keys = Object.keys(value); + if (!isSorted(keys)) { + return sortObject(value, keys); + } + } + return value; + }, + 2 + ), + callback + ); + }; + + const recordsOutputPathDirectory = dirname( + /** @type {OutputFileSystem} */ + (this.outputFileSystem), + /** @type {string} */ + (this.recordsOutputPath) + ); + if (!recordsOutputPathDirectory) { + return writeFile(); + } + mkdirp( + /** @type {OutputFileSystem} */ (this.outputFileSystem), + recordsOutputPathDirectory, + (err) => { + if (err) return callback(err); + writeFile(); + } + ); + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the call finishes + * @returns {void} + */ + readRecords(callback) { + if (this.hooks.readRecords.isUsed()) { + if (this.recordsInputPath) { + asyncLib.parallel( + [ + (cb) => this.hooks.readRecords.callAsync(cb), + this._readRecords.bind(this) + ], + (err) => callback(/** @type {Error | null} */ (err)) + ); + } else { + this.records = {}; + this.hooks.readRecords.callAsync(callback); + } + } else if (this.recordsInputPath) { + this._readRecords(callback); + } else { + this.records = {}; + callback(null); + } + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the call finishes + * @returns {void} + */ + _readRecords(callback) { + if (!this.recordsInputPath) { + this.records = {}; + return callback(null); + } + /** @type {InputFileSystem} */ + (this.inputFileSystem).stat(this.recordsInputPath, (err) => { + // It doesn't exist + // We can ignore this. + if (err) return callback(null); + + /** @type {InputFileSystem} */ + (this.inputFileSystem).readFile( + /** @type {string} */ + (this.recordsInputPath), + (err, content) => { + if (err) return callback(err); + + try { + this.records = + /** @type {Records} */ + (parseJson(/** @type {Buffer} */ (content).toString("utf8"))); + } catch (parseErr) { + return callback( + new Error( + `Cannot parse records: ${/** @type {Error} */ (parseErr).message}` + ) + ); + } + + return callback(null); + } + ); + }); + } + + /** + * Creates a child compiler. + * @param {Compilation} compilation the compilation + * @param {string} compilerName the compiler's name + * @param {number} compilerIndex the compiler's index + * @param {Partial=} outputOptions the output options + * @param {Plugins=} plugins the plugins to apply + * @returns {Compiler} a child compiler + */ + createChildCompiler( + compilation, + compilerName, + compilerIndex, + outputOptions, + plugins + ) { + const childCompiler = new Compiler(this.context, { + ...this.options, + output: { + ...this.options.output, + ...outputOptions + } + }); + childCompiler.name = compilerName; + childCompiler.outputPath = this.outputPath; + childCompiler.inputFileSystem = this.inputFileSystem; + childCompiler.outputFileSystem = null; + childCompiler.resolverFactory = this.resolverFactory; + childCompiler.modifiedFiles = this.modifiedFiles; + childCompiler.removedFiles = this.removedFiles; + childCompiler.fileTimestamps = this.fileTimestamps; + childCompiler.contextTimestamps = this.contextTimestamps; + childCompiler.fsStartTime = this.fsStartTime; + childCompiler.cache = this.cache; + childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`; + childCompiler._backCompat = this._backCompat; + + const relativeCompilerName = makePathsRelative( + this.context, + compilerName, + this.root + ); + if (!this.records[relativeCompilerName]) { + this.records[relativeCompilerName] = []; + } + if (this.records[relativeCompilerName][compilerIndex]) { + childCompiler.records = + /** @type {Records} */ + (this.records[relativeCompilerName][compilerIndex]); + } else { + this.records[relativeCompilerName].push((childCompiler.records = {})); + } + + childCompiler.parentCompilation = compilation; + childCompiler.root = this.root; + if (Array.isArray(plugins)) { + for (const plugin of plugins) { + if (typeof plugin === "function") { + /** @type {WebpackPluginFunction} */ + (plugin).call(childCompiler, childCompiler); + } else if (plugin) { + plugin.apply(childCompiler); + } + } + } + for (const name in this.hooks) { + if ( + ![ + "make", + "compile", + "emit", + "afterEmit", + "invalid", + "done", + "thisCompilation" + ].includes(name) && + childCompiler.hooks[/** @type {keyof Compiler["hooks"]} */ (name)] + ) { + childCompiler.hooks[ + /** @type {keyof Compiler["hooks"]} */ + (name) + ].taps = [ + ...this.hooks[ + /** @type {keyof Compiler["hooks"]} */ + (name) + ].taps + ]; + } + } + + compilation.hooks.childCompiler.call( + childCompiler, + compilerName, + compilerIndex + ); + + return childCompiler; + } + + isChild() { + return Boolean(this.parentCompilation); + } + + /** + * Creates a compilation. + * @param {CompilationParams} params the compilation parameters + * @returns {Compilation} compilation + */ + createCompilation(params) { + this._cleanupLastCompilation(); + return (this._lastCompilation = new Compilation(this, params)); + } + + /** + * Returns the created compilation. + * @param {CompilationParams} params the compilation parameters + * @returns {Compilation} the created compilation + */ + newCompilation(params) { + const compilation = this.createCompilation(params); + compilation.name = this.name; + compilation.records = this.records; + this.hooks.thisCompilation.call(compilation, params); + this.hooks.compilation.call(compilation, params); + return compilation; + } + + createNormalModuleFactory() { + this._cleanupLastNormalModuleFactory(); + const normalModuleFactory = new NormalModuleFactory({ + context: this.options.context, + fs: /** @type {InputFileSystem} */ (this.inputFileSystem), + resolverFactory: this.resolverFactory, + options: this.options.module, + associatedObjectForCache: this.root + }); + this._lastNormalModuleFactory = normalModuleFactory; + this.hooks.normalModuleFactory.call(normalModuleFactory); + return normalModuleFactory; + } + + createContextModuleFactory() { + const contextModuleFactory = new ContextModuleFactory(this.resolverFactory); + this.hooks.contextModuleFactory.call(contextModuleFactory); + return contextModuleFactory; + } + + newCompilationParams() { + const params = { + normalModuleFactory: this.createNormalModuleFactory(), + contextModuleFactory: this.createContextModuleFactory() + }; + return params; + } + + /** + * Processes the provided compilation. + * @param {Callback} callback signals when the compilation finishes + * @returns {void} + */ + compile(callback) { + const params = this.newCompilationParams(); + this.hooks.beforeCompile.callAsync(params, (err) => { + if (err) return callback(err); + + this.hooks.compile.call(params); + + const compilation = this.newCompilation(params); + + const logger = compilation.getLogger("webpack.Compiler"); + + logger.time("make hook"); + this.hooks.make.callAsync(compilation, (err) => { + logger.timeEnd("make hook"); + if (err) return callback(err); + + logger.time("finish make hook"); + this.hooks.finishMake.callAsync(compilation, (err) => { + logger.timeEnd("finish make hook"); + if (err) return callback(err); + + process.nextTick(() => { + logger.time("finish compilation"); + compilation.finish((err) => { + logger.timeEnd("finish compilation"); + if (err) return callback(err); + + logger.time("seal compilation"); + compilation.seal((err) => { + logger.timeEnd("seal compilation"); + if (err) return callback(err); + + logger.time("afterCompile hook"); + this.hooks.afterCompile.callAsync(compilation, (err) => { + logger.timeEnd("afterCompile hook"); + if (err) return callback(err); + + return callback(null, compilation); + }); + }); + }); + }); + }); + }); + }); + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the compiler closes + * @returns {void} + */ + close(callback) { + if (this.watching) { + // When there is still an active watching, close this first + this.watching.close((_err) => { + this.close(callback); + }); + return; + } + this.hooks.shutdown.callAsync((err) => { + if (err) return callback(err); + // Get rid of reference to last compilation to avoid leaking memory + // We can't run this._cleanupLastCompilation() as the Stats to this compilation + // might be still in use. We try to get rid of the reference to the cache instead. + this._lastCompilation = undefined; + this._lastNormalModuleFactory = undefined; + this.cache.shutdown(callback); + }); + } + + /** + * Schema validation function with optional pre-compiled check + * @template {EXPECTED_OBJECT | EXPECTED_OBJECT[]} [T=EXPECTED_OBJECT] + * @param {Schema | (() => Schema)} schema schema + * @param {T} value value + * @param {ValidationErrorConfiguration=} options options + * @param {((value: T) => boolean)=} check options + */ + validate(schema, value, options, check) { + // Avoid validation at all when disabled + if (this.options.validate === false) { + return; + } + + /** + * Returns schema. + * @returns {Schema} schema + */ + const getSchema = () => { + if (typeof schema === "function") { + return schema(); + } + + return schema; + }; + + // // If we have precompiled schema let's use it + if (check) { + if (!check(value)) { + getValidate()(getSchema(), value, options); + require("util").deprecate( + () => {}, + "webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.", + "DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID" + )(); + } + return; + } + + // Otherwise let's standard validation + getValidate()(getSchema(), value, options); + } +} + +module.exports = Compiler; Index: frontend/node_modules/webpack/lib/ConcatenationScope.js =================================================================== --- frontend/node_modules/webpack/lib/ConcatenationScope.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ConcatenationScope.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,204 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + DEFAULT_EXPORT, + NAMESPACE_OBJECT_EXPORT +} = require("./util/concatenate"); + +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./optimize/ConcatenatedModule").ConcatenatedModuleInfo} ConcatenatedModuleInfo */ +/** @typedef {import("./optimize/ConcatenatedModule").ModuleInfo} ModuleInfo */ +/** @typedef {import("./optimize/ConcatenatedModule").ExportName} Ids */ + +const MODULE_REFERENCE_REGEXP = + /^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(?:_asiSafe(\d))?__$/; + +/** + * Encodes how a concatenated module reference should be interpreted when it is + * later reconstructed from its placeholder identifier. + * @typedef {object} ModuleReferenceOptions + * @property {Ids} ids the properties or exports selected from the referenced module + * @property {boolean} call true, when this referenced export is called + * @property {boolean} directImport true, when this referenced export is directly imported (not via property access) + * @property {boolean} deferredImport true, when this referenced export is deferred + * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown + */ + +/** + * Tracks the symbols and cross-module references needed while rendering a + * concatenated module. + */ +class ConcatenationScope { + /** + * Creates the mutable scope object used while rendering a concatenated + * module and its cross-module references. + * @param {ModuleInfo[] | Map} modulesMap all module info by module + * @param {ConcatenatedModuleInfo} currentModule the current module info + * @param {Set} usedNames all used names + */ + constructor(modulesMap, currentModule, usedNames) { + this._currentModule = currentModule; + if (Array.isArray(modulesMap)) { + /** @type {Map} */ + const map = new Map(); + for (const info of modulesMap) { + map.set(info.module, /** @type {ConcatenatedModuleInfo} */ (info)); + } + modulesMap = map; + } + this.usedNames = usedNames; + this._modulesMap = modulesMap; + } + + /** + * Checks whether a module participates in the current concatenation scope. + * @param {Module} module the referenced module + * @returns {boolean} true, when it's in the scope + */ + isModuleInScope(module) { + return this._modulesMap.has(module); + } + + /** + * Records the symbol that should be used when the current module exports a + * named binding. + * @param {string} exportName name of the export + * @param {string} symbol identifier of the export in source code + */ + registerExport(exportName, symbol) { + if (!this._currentModule.exportMap) { + this._currentModule.exportMap = new Map(); + } + if (!this._currentModule.exportMap.has(exportName)) { + this._currentModule.exportMap.set(exportName, symbol); + } + } + + /** + * Records a raw expression that can be used to reference an export without + * going through the normal symbol map. + * @param {string} exportName name of the export + * @param {string} expression expression to be used + */ + registerRawExport(exportName, expression) { + if (!this._currentModule.rawExportMap) { + this._currentModule.rawExportMap = new Map(); + } + if (!this._currentModule.rawExportMap.has(exportName)) { + this._currentModule.rawExportMap.set(exportName, expression); + } + } + + /** + * Returns the raw expression registered for an export, if one exists. + * @param {string} exportName name of the export + * @returns {string | undefined} the expression of the export + */ + getRawExport(exportName) { + if (!this._currentModule.rawExportMap) { + return undefined; + } + return this._currentModule.rawExportMap.get(exportName); + } + + /** + * Replaces the raw expression for an export only when that export already + * has an entry in the raw export map. + * @param {string} exportName name of the export + * @param {string} expression expression to be used + */ + setRawExportMap(exportName, expression) { + if (!this._currentModule.rawExportMap) { + this._currentModule.rawExportMap = new Map(); + } + if (this._currentModule.rawExportMap.has(exportName)) { + this._currentModule.rawExportMap.set(exportName, expression); + } + } + + /** + * Records the symbol that should be used for the synthetic namespace export. + * @param {string} symbol identifier of the export in source code + */ + registerNamespaceExport(symbol) { + this._currentModule.namespaceExportSymbol = symbol; + } + + /** + * Encodes a reference to another concatenated module as a placeholder + * identifier that can be parsed later during code generation. + * @param {Module} module the referenced module + * @param {Partial} options options + * @returns {string} the reference as identifier + */ + createModuleReference( + module, + { + ids = undefined, + call = false, + directImport = false, + deferredImport = false, + asiSafe = false + } + ) { + const info = /** @type {ModuleInfo} */ (this._modulesMap.get(module)); + const callFlag = call ? "_call" : ""; + const directImportFlag = directImport ? "_directImport" : ""; + const deferredImportFlag = deferredImport ? "_deferredImport" : ""; + const asiSafeFlag = asiSafe + ? "_asiSafe1" + : asiSafe === false + ? "_asiSafe0" + : ""; + const exportData = ids + ? Buffer.from(JSON.stringify(ids), "utf8").toString("hex") + : "ns"; + // a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode + return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${asiSafeFlag}__._`; + } + + /** + * Checks whether an identifier is one of webpack's encoded concatenation + * module references. + * @param {string} name the identifier + * @returns {boolean} true, when it's an module reference + */ + static isModuleReference(name) { + return MODULE_REFERENCE_REGEXP.test(name); + } + + /** + * Parses an encoded module reference back into its module index and + * reference flags. + * @param {string} name the identifier + * @returns {ModuleReferenceOptions & { index: number } | null} parsed options and index + */ + static matchModuleReference(name) { + const match = MODULE_REFERENCE_REGEXP.exec(name); + if (!match) return null; + const index = Number(match[1]); + const asiSafe = match[6]; + return { + index, + ids: + match[2] === "ns" + ? [] + : JSON.parse(Buffer.from(match[2], "hex").toString("utf8")), + call: Boolean(match[3]), + directImport: Boolean(match[4]), + deferredImport: Boolean(match[5]), + asiSafe: asiSafe ? asiSafe === "1" : undefined + }; + } +} + +ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT; +ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT; + +module.exports = ConcatenationScope; Index: frontend/node_modules/webpack/lib/ConditionalInitFragment.js =================================================================== --- frontend/node_modules/webpack/lib/ConditionalInitFragment.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ConditionalInitFragment.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,126 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { ConcatSource, PrefixSource } = require("webpack-sources"); +const InitFragment = require("./InitFragment"); +const Template = require("./Template"); +const { mergeRuntime } = require("./util/runtime"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./Generator").GenerateContext} GenerateContext */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** + * Returns wrapped source. + * @param {string} condition condition + * @param {string | Source} source source + * @returns {string | Source} wrapped source + */ +const wrapInCondition = (condition, source) => { + if (typeof source === "string") { + return Template.asString([ + `if (${condition}) {`, + Template.indent(source), + "}", + "" + ]); + } + return new ConcatSource( + `if (${condition}) {\n`, + new PrefixSource("\t", source), + "}\n" + ); +}; + +/** + * Represents ConditionalInitFragment. + * @extends {InitFragment} + */ +class ConditionalInitFragment extends InitFragment { + /** + * Creates an instance of ConditionalInitFragment. + * @param {string | Source | undefined} content the source code that will be included as initialization code + * @param {number} stage category of initialization code (contribute to order) + * @param {number} position position in the category (contribute to order) + * @param {string | undefined} key unique key to avoid emitting the same initialization code twice + * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed + * @param {string | Source=} endContent the source code that will be included at the end of the module + */ + constructor( + content, + stage, + position, + key, + runtimeCondition = true, + endContent = undefined + ) { + super(content, stage, position, key, endContent); + this.runtimeCondition = runtimeCondition; + } + + /** + * Returns the source code that will be included as initialization code. + * @param {GenerateContext} context context + * @returns {string | Source | undefined} the source code that will be included as initialization code + */ + getContent(context) { + if (this.runtimeCondition === false || !this.content) return ""; + if (this.runtimeCondition === true) return this.content; + const expr = context.runtimeTemplate.runtimeConditionExpression({ + chunkGraph: context.chunkGraph, + runtimeRequirements: context.runtimeRequirements, + runtime: context.runtime, + runtimeCondition: this.runtimeCondition + }); + if (expr === "true") return this.content; + return wrapInCondition(expr, this.content); + } + + /** + * Returns the source code that will be included at the end of the module. + * @param {GenerateContext} context context + * @returns {string | Source | undefined} the source code that will be included at the end of the module + */ + getEndContent(context) { + if (this.runtimeCondition === false || !this.endContent) return ""; + if (this.runtimeCondition === true) return this.endContent; + const expr = context.runtimeTemplate.runtimeConditionExpression({ + chunkGraph: context.chunkGraph, + runtimeRequirements: context.runtimeRequirements, + runtime: context.runtime, + runtimeCondition: this.runtimeCondition + }); + if (expr === "true") return this.endContent; + return wrapInCondition(expr, this.endContent); + } + + /** + * Returns merged fragment. + * @param {ConditionalInitFragment} other fragment to merge with + * @returns {ConditionalInitFragment} merged fragment + */ + merge(other) { + if (this.runtimeCondition === true) return this; + if (other.runtimeCondition === true) return other; + if (this.runtimeCondition === false) return other; + if (other.runtimeCondition === false) return this; + const runtimeCondition = mergeRuntime( + this.runtimeCondition, + other.runtimeCondition + ); + return new ConditionalInitFragment( + this.content, + this.stage, + this.position, + this.key, + runtimeCondition, + this.endContent + ); + } +} + +module.exports = ConditionalInitFragment; Index: frontend/node_modules/webpack/lib/ConstPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ConstPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ConstPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,570 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const CachedConstDependency = require("./dependencies/CachedConstDependency"); +const ConstDependency = require("./dependencies/ConstDependency"); +const { evaluateToString } = require("./javascript/JavascriptParserHelpers"); +const { parseResource } = require("./util/identifier"); + +/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */ +/** @typedef {import("estree").Expression} Expression */ +/** @typedef {import("estree").Identifier} Identifier */ +/** @typedef {import("estree").Pattern} Pattern */ +/** @typedef {import("estree").SourceLocation} SourceLocation */ +/** @typedef {import("estree").Statement} Statement */ +/** @typedef {import("estree").Super} Super */ +/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ + +/** @typedef {Set} Declarations */ + +/** + * Collect declaration. + * @param {Declarations} declarations set of declarations + * @param {Identifier | Pattern} pattern pattern to collect declarations from + */ +const collectDeclaration = (declarations, pattern) => { + const stack = [pattern]; + while (stack.length > 0) { + const node = /** @type {Pattern} */ (stack.pop()); + switch (node.type) { + case "Identifier": + declarations.add(node.name); + break; + case "ArrayPattern": + for (const element of node.elements) { + if (element) { + stack.push(element); + } + } + break; + case "AssignmentPattern": + stack.push(node.left); + break; + case "ObjectPattern": + for (const property of node.properties) { + stack.push(/** @type {AssignmentProperty} */ (property).value); + } + break; + case "RestElement": + stack.push(node.argument); + break; + } + } +}; + +/** + * Gets hoisted declarations. + * @param {Statement} branch branch to get hoisted declarations from + * @param {boolean} includeFunctionDeclarations whether to include function declarations + * @returns {string[]} hoisted declarations + */ +const getHoistedDeclarations = (branch, includeFunctionDeclarations) => { + /** @type {Declarations} */ + const declarations = new Set(); + /** @type {(Statement | null | undefined)[]} */ + const stack = [branch]; + while (stack.length > 0) { + const node = stack.pop(); + // Some node could be `null` or `undefined`. + if (!node) continue; + switch (node.type) { + // Walk through control statements to look for hoisted declarations. + // Some branches are skipped since they do not allow declarations. + case "BlockStatement": + for (const stmt of node.body) { + stack.push(stmt); + } + break; + case "IfStatement": + stack.push(node.consequent); + stack.push(node.alternate); + break; + case "ForStatement": + stack.push(/** @type {VariableDeclaration} */ (node.init)); + stack.push(node.body); + break; + case "ForInStatement": + case "ForOfStatement": + stack.push(/** @type {VariableDeclaration} */ (node.left)); + stack.push(node.body); + break; + case "DoWhileStatement": + case "WhileStatement": + case "LabeledStatement": + stack.push(node.body); + break; + case "SwitchStatement": + for (const cs of node.cases) { + for (const consequent of cs.consequent) { + stack.push(consequent); + } + } + break; + case "TryStatement": + stack.push(node.block); + if (node.handler) { + stack.push(node.handler.body); + } + stack.push(node.finalizer); + break; + case "FunctionDeclaration": + if (includeFunctionDeclarations) { + collectDeclaration(declarations, /** @type {Identifier} */ (node.id)); + } + break; + case "VariableDeclaration": + if (node.kind === "var") { + for (const decl of node.declarations) { + collectDeclaration(declarations, decl.id); + } + } + break; + } + } + return [...declarations]; +}; + +const PLUGIN_NAME = "ConstPlugin"; + +class ConstPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const cachedParseResource = parseResource.bindCache(compiler.root); + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyTemplates.set( + ConstDependency, + new ConstDependency.Template() + ); + + compilation.dependencyTemplates.set( + CachedConstDependency, + new CachedConstDependency.Template() + ); + + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + */ + const handler = (parser) => { + parser.hooks.terminate.tap(PLUGIN_NAME, (_statement) => true); + parser.hooks.statementIf.tap(PLUGIN_NAME, (statement) => { + if (parser.scope.isAsmJs) return; + const param = parser.evaluateExpression(statement.test); + const bool = param.asBool(); + if (typeof bool === "boolean") { + if (!param.couldHaveSideEffects()) { + const dep = new ConstDependency( + `${bool}`, + /** @type {Range} */ (param.range) + ); + dep.loc = /** @type {SourceLocation} */ (statement.loc); + parser.state.module.addPresentationalDependency(dep); + } else { + parser.walkExpression(statement.test); + } + const branchToRemove = bool + ? statement.alternate + : statement.consequent; + if (branchToRemove) { + this.eliminateUnusedStatement(parser, branchToRemove, true); + } + return bool; + } + }); + parser.hooks.unusedStatement.tap(PLUGIN_NAME, (statement) => { + if ( + parser.scope.isAsmJs || + // Check top level scope here again + parser.scope.topLevelScope === true + ) { + return; + } + this.eliminateUnusedStatement(parser, statement, false); + return true; + }); + parser.hooks.expressionConditionalOperator.tap( + PLUGIN_NAME, + (expression) => { + if (parser.scope.isAsmJs) return; + const param = parser.evaluateExpression(expression.test); + const bool = param.asBool(); + if (typeof bool === "boolean") { + if (!param.couldHaveSideEffects()) { + const dep = new ConstDependency( + ` ${bool}`, + /** @type {Range} */ (param.range) + ); + dep.loc = /** @type {SourceLocation} */ (expression.loc); + parser.state.module.addPresentationalDependency(dep); + } else { + parser.walkExpression(expression.test); + } + // Expressions do not hoist. + // It is safe to remove the dead branch. + // + // Given the following code: + // + // false ? someExpression() : otherExpression(); + // + // the generated code is: + // + // false ? 0 : otherExpression(); + // + const branchToRemove = bool + ? expression.alternate + : expression.consequent; + const dep = new ConstDependency( + "0", + /** @type {Range} */ (branchToRemove.range) + ); + dep.loc = /** @type {SourceLocation} */ (branchToRemove.loc); + parser.state.module.addPresentationalDependency(dep); + return bool; + } + } + ); + parser.hooks.expressionLogicalOperator.tap( + PLUGIN_NAME, + (expression) => { + if (parser.scope.isAsmJs) return; + if ( + expression.operator === "&&" || + expression.operator === "||" + ) { + const param = parser.evaluateExpression(expression.left); + const bool = param.asBool(); + if (typeof bool === "boolean") { + // Expressions do not hoist. + // It is safe to remove the dead branch. + // + // ------------------------------------------ + // + // Given the following code: + // + // falsyExpression() && someExpression(); + // + // the generated code is: + // + // falsyExpression() && false; + // + // ------------------------------------------ + // + // Given the following code: + // + // truthyExpression() && someExpression(); + // + // the generated code is: + // + // true && someExpression(); + // + // ------------------------------------------ + // + // Given the following code: + // + // truthyExpression() || someExpression(); + // + // the generated code is: + // + // truthyExpression() || false; + // + // ------------------------------------------ + // + // Given the following code: + // + // falsyExpression() || someExpression(); + // + // the generated code is: + // + // false && someExpression(); + // + const keepRight = + (expression.operator === "&&" && bool) || + (expression.operator === "||" && !bool); + + if ( + !param.couldHaveSideEffects() && + (param.isBoolean() || keepRight) + ) { + // for case like + // + // return'development'===process.env.NODE_ENV&&'foo' + // + // we need a space before the bool to prevent result like + // + // returnfalse&&'foo' + // + const dep = new ConstDependency( + ` ${bool}`, + /** @type {Range} */ (param.range) + ); + dep.loc = /** @type {SourceLocation} */ (expression.loc); + parser.state.module.addPresentationalDependency(dep); + } else { + parser.walkExpression(expression.left); + } + if (!keepRight) { + const dep = new ConstDependency( + "0", + /** @type {Range} */ (expression.right.range) + ); + dep.loc = /** @type {SourceLocation} */ (expression.loc); + parser.state.module.addPresentationalDependency(dep); + } + return keepRight; + } + } else if (expression.operator === "??") { + const param = parser.evaluateExpression(expression.left); + const keepRight = param.asNullish(); + if (typeof keepRight === "boolean") { + // ------------------------------------------ + // + // Given the following code: + // + // nonNullish ?? someExpression(); + // + // the generated code is: + // + // nonNullish ?? 0; + // + // ------------------------------------------ + // + // Given the following code: + // + // nullish ?? someExpression(); + // + // the generated code is: + // + // null ?? someExpression(); + // + if (!param.couldHaveSideEffects() && keepRight) { + // cspell:word returnnull + // for case like + // + // return('development'===process.env.NODE_ENV&&null)??'foo' + // + // we need a space before the bool to prevent result like + // + // returnnull??'foo' + // + const dep = new ConstDependency( + " null", + /** @type {Range} */ (param.range) + ); + dep.loc = /** @type {SourceLocation} */ (expression.loc); + parser.state.module.addPresentationalDependency(dep); + } else { + const dep = new ConstDependency( + "0", + /** @type {Range} */ (expression.right.range) + ); + dep.loc = /** @type {SourceLocation} */ (expression.loc); + parser.state.module.addPresentationalDependency(dep); + parser.walkExpression(expression.left); + } + + return keepRight; + } + } + } + ); + parser.hooks.optionalChaining.tap(PLUGIN_NAME, (expr) => { + /** @type {Expression[]} */ + const optionalExpressionsStack = []; + /** @type {Expression | Super} */ + let next = expr.expression; + + while ( + next.type === "MemberExpression" || + next.type === "CallExpression" + ) { + if (next.type === "MemberExpression") { + if (next.optional) { + // SuperNode can not be optional + optionalExpressionsStack.push( + /** @type {Expression} */ (next.object) + ); + } + next = next.object; + } else { + if (next.optional) { + // SuperNode can not be optional + optionalExpressionsStack.push( + /** @type {Expression} */ (next.callee) + ); + } + next = next.callee; + } + } + + while (optionalExpressionsStack.length) { + const expression = optionalExpressionsStack.pop(); + const evaluated = parser.evaluateExpression( + /** @type {Expression} */ (expression) + ); + + if (evaluated.asNullish()) { + // ------------------------------------------ + // + // Given the following code: + // + // nullishMemberChain?.a.b(); + // + // the generated code is: + // + // undefined; + // + // ------------------------------------------ + // + const dep = new ConstDependency( + " undefined", + /** @type {Range} */ (expr.range) + ); + dep.loc = /** @type {SourceLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return true; + } + } + }); + parser.hooks.evaluateIdentifier + .for("__resourceQuery") + .tap(PLUGIN_NAME, (expr) => { + if (parser.scope.isAsmJs) return; + if (!parser.state.module) return; + return evaluateToString( + cachedParseResource(parser.state.module.resource).query + )(expr); + }); + parser.hooks.expression + .for("__resourceQuery") + .tap(PLUGIN_NAME, (expr) => { + if (parser.scope.isAsmJs) return; + if (!parser.state.module) return; + const dep = new CachedConstDependency( + JSON.stringify( + cachedParseResource(parser.state.module.resource).query + ), + /** @type {Range} */ (expr.range), + "__resourceQuery" + ); + dep.loc = /** @type {SourceLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return true; + }); + + parser.hooks.evaluateIdentifier + .for("__resourceFragment") + .tap(PLUGIN_NAME, (expr) => { + if (parser.scope.isAsmJs) return; + if (!parser.state.module) return; + return evaluateToString( + cachedParseResource(parser.state.module.resource).fragment + )(expr); + }); + parser.hooks.expression + .for("__resourceFragment") + .tap(PLUGIN_NAME, (expr) => { + if (parser.scope.isAsmJs) return; + if (!parser.state.module) return; + const dep = new CachedConstDependency( + JSON.stringify( + cachedParseResource(parser.state.module.resource).fragment + ), + /** @type {Range} */ (expr.range), + "__resourceFragment" + ); + dep.loc = /** @type {SourceLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return true; + }); + }; + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } + + /** + * Eliminate an unused statement. + * @param {JavascriptParser} parser the parser + * @param {Statement} statement the statement to remove + * @param {boolean} alwaysInBlock whether to always generate curly brackets + * @returns {void} + */ + eliminateUnusedStatement(parser, statement, alwaysInBlock) { + // Before removing the unused branch, the hoisted declarations + // must be collected. + // + // Given the following code: + // + // if (true) f() else g() + // if (false) { + // function f() {} + // const g = function g() {} + // if (someTest) { + // let a = 1 + // var x, {y, z} = obj + // } + // } else { + // … + // } + // + // the generated code is: + // + // if (true) f() else {} + // if (false) { + // var f, x, y, z; (in loose mode) + // var x, y, z; (in strict mode) + // } else { + // … + // } + // + // NOTE: When code runs in strict mode, `var` declarations + // are hoisted but `function` declarations don't. + // + const declarations = parser.scope.isStrict + ? getHoistedDeclarations(statement, false) + : getHoistedDeclarations(statement, true); + + const inBlock = alwaysInBlock || statement.type === "BlockStatement"; + + let replacement = inBlock ? "{" : ""; + replacement += + declarations.length > 0 ? ` var ${declarations.join(", ")}; ` : ""; + replacement += inBlock ? "}" : ""; + + const dep = new ConstDependency( + `// removed by dead control flow\n${replacement}`, + /** @type {Range} */ (statement.range) + ); + dep.loc = /** @type {SourceLocation} */ (statement.loc); + parser.state.module.addPresentationalDependency(dep); + } +} + +module.exports = ConstPlugin; Index: frontend/node_modules/webpack/lib/ContextExclusionPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ContextExclusionPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ContextExclusionPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,34 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php +*/ + +"use strict"; + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "ContextExclusionPlugin"; + +class ContextExclusionPlugin { + /** + * Creates an instance of ContextExclusionPlugin. + * @param {RegExp} negativeMatcher Matcher regular expression + */ + constructor(negativeMatcher) { + this.negativeMatcher = negativeMatcher; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => { + cmf.hooks.contextModuleFiles.tap(PLUGIN_NAME, (files) => + files.filter((filePath) => !this.negativeMatcher.test(filePath)) + ); + }); + } +} + +module.exports = ContextExclusionPlugin; Index: frontend/node_modules/webpack/lib/ContextModule.js =================================================================== --- frontend/node_modules/webpack/lib/ContextModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ContextModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1423 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { OriginalSource, RawSource } = require("webpack-sources"); +const AsyncDependenciesBlock = require("./AsyncDependenciesBlock"); +const Module = require("./Module"); +const { + JAVASCRIPT_TYPE, + JAVASCRIPT_TYPES +} = require("./ModuleSourceTypeConstants"); +const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const Template = require("./Template"); +const { + getOutgoingAsyncModules +} = require("./async-modules/AsyncModuleHelpers"); +const { ImportPhase, ImportPhaseUtils } = require("./dependencies/ImportPhase"); +const { makeWebpackError } = require("./errors/HookWebpackError"); +const WebpackError = require("./errors/WebpackError"); +const { + compareLocations, + compareModulesById, + compareSelect, + concatComparators, + keepOriginalOrder +} = require("./util/comparators"); +const { + contextify, + makePathsRelative, + parseResource +} = require("./util/identifier"); +const makeSerializable = require("./util/makeSerializable"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */ +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Chunk").ChunkId} ChunkId */ +/** @typedef {import("./Chunk").ChunkName} ChunkName */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ +/** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").RawReferencedExports} RawReferencedExports */ +/** @typedef {import("./Generator").SourceTypes} SourceTypes */ +/** @typedef {import("./Module").BuildCallback} BuildCallback */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */ +/** @typedef {import("./Module").BuildMeta} BuildMeta */ +/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */ +/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */ +/** @typedef {import("./Module").LibIdent} LibIdent */ +/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */ +/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./Module").Sources} Sources */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */ +/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */ + +/** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */ + +/** + * @typedef {object} ContextOptions + * @property {ContextMode} mode + * @property {boolean} recursive + * @property {RegExp | false | null} regExp + * @property {"strict" | boolean=} namespaceObject + * @property {string=} addon + * @property {ChunkName=} chunkName + * @property {RegExp | null=} include + * @property {RegExp | null=} exclude + * @property {RawChunkGroupOptions=} groupOptions + * @property {string=} typePrefix + * @property {string=} category + * @property {RawReferencedExports | null=} referencedExports exports referenced from modules (won't be mangled) + * @property {string | null=} layer + * @property {ImportAttributes=} attributes + * @property {ImportPhaseType=} phase + */ + +/** + * @typedef {object} ContextModuleOptionsExtras + * @property {false | string | string[]} resource + * @property {string=} resourceQuery + * @property {string=} resourceFragment + * @property {ResolveOptions=} resolveOptions + */ + +/** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */ + +/** + * @callback ResolveDependenciesCallback + * @param {Error | null} err + * @param {ContextElementDependency[]=} dependencies + * @returns {void} + */ + +/** + * @callback ResolveDependencies + * @param {InputFileSystem} fs + * @param {ContextModuleOptions} options + * @param {ResolveDependenciesCallback} callback + */ + +/** @typedef {1 | 3 | 7 | 9} FakeMapType */ + +/** @typedef {Record} FakeMap */ +/** @typedef {Record} UserRequestMap */ +/** @typedef {Record} UserRequestsMap */ + +class ContextModule extends Module { + /** + * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context + * @param {ContextModuleOptions} options options object + */ + constructor(resolveDependencies, options) { + if (!options || typeof options.resource === "string") { + const parsed = parseResource( + options ? /** @type {string} */ (options.resource) : "" + ); + const resource = parsed.path; + const resourceQuery = (options && options.resourceQuery) || parsed.query; + const resourceFragment = + (options && options.resourceFragment) || parsed.fragment; + const layer = options && options.layer; + + super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, resource, layer); + /** @type {ContextModuleOptions} */ + this.options = { + ...options, + resource, + resourceQuery, + resourceFragment + }; + } else { + super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, undefined, options.layer); + /** @type {ContextModuleOptions} */ + this.options = { + ...options, + resource: options.resource, + resourceQuery: options.resourceQuery || "", + resourceFragment: options.resourceFragment || "" + }; + } + + // Info from Factory + /** @type {ResolveDependencies | undefined} */ + this.resolveDependencies = resolveDependencies; + if (options && options.resolveOptions !== undefined) { + this.resolveOptions = options.resolveOptions; + } + + if (options && typeof options.mode !== "string") { + throw new Error("options.mode is a required option"); + } + + this._identifier = this._createIdentifier(); + this._forceBuild = true; + } + + /** + * Returns the source types this module can generate. + * @returns {SourceTypes} types available (do not mutate) + */ + getSourceTypes() { + return JAVASCRIPT_TYPES; + } + + /** + * Assuming this module is in the cache. Update the (cached) module with + * the fresh module from the factory. Usually updates internal references + * and properties. + * @param {Module} module fresh module + * @returns {void} + */ + updateCacheModule(module) { + const m = /** @type {ContextModule} */ (module); + this.resolveDependencies = m.resolveDependencies; + this.options = m.options; + } + + /** + * Assuming this module is in the cache. Remove internal references to allow freeing some memory. + */ + cleanupForCache() { + super.cleanupForCache(); + this.resolveDependencies = undefined; + } + + /** + * @private + * @param {RegExp} regexString RegExp as a string + * @param {boolean=} stripSlash do we need to strip a slsh + * @returns {string} pretty RegExp + */ + _prettyRegExp(regexString, stripSlash = true) { + const str = stripSlash + ? regexString.source + regexString.flags + : `${regexString}`; + return str.replace(/!/g, "%21").replace(/\|/g, "%7C"); + } + + _createIdentifier() { + let identifier = + this.context || + (typeof this.options.resource === "string" || + this.options.resource === false + ? `${this.options.resource}` + : this.options.resource.join("|")); + if (this.options.resourceQuery) { + identifier += `|${this.options.resourceQuery}`; + } + if (this.options.resourceFragment) { + identifier += `|${this.options.resourceFragment}`; + } + if (this.options.mode) { + identifier += `|${this.options.mode}`; + } + if (!this.options.recursive) { + identifier += "|nonrecursive"; + } + if (this.options.addon) { + identifier += `|${this.options.addon}`; + } + if (this.options.regExp) { + identifier += `|${this._prettyRegExp(this.options.regExp, false)}`; + } + if (this.options.include) { + identifier += `|include: ${this._prettyRegExp( + this.options.include, + false + )}`; + } + if (this.options.exclude) { + identifier += `|exclude: ${this._prettyRegExp( + this.options.exclude, + false + )}`; + } + if (this.options.referencedExports) { + identifier += `|referencedExports: ${JSON.stringify( + this.options.referencedExports + )}`; + } + if (this.options.chunkName) { + identifier += `|chunkName: ${this.options.chunkName}`; + } + if (this.options.groupOptions) { + identifier += `|groupOptions: ${JSON.stringify( + this.options.groupOptions + )}`; + } + if (this.options.namespaceObject === "strict") { + identifier += "|strict namespace object"; + } else if (this.options.namespaceObject) { + identifier += "|namespace object"; + } + if (this.options.attributes) { + identifier += `|importAttributes: ${JSON.stringify(this.options.attributes)}`; + } + if (this.options.phase) { + identifier += `|importPhase: ${this.options.phase}`; + } + if (this.layer) { + identifier += `|layer: ${this.layer}`; + } + return identifier; + } + + /** + * Returns the unique identifier used to reference this module. + * @returns {string} a unique identifier of the module + */ + identifier() { + return this._identifier; + } + + /** + * Returns a human-readable identifier for this module. + * @param {RequestShortener} requestShortener the request shortener + * @returns {string} a user readable identifier of the module + */ + readableIdentifier(requestShortener) { + /** @type {string} */ + let identifier; + + if (this.context) { + identifier = `${requestShortener.shorten(this.context)}/`; + } else if ( + typeof this.options.resource === "string" || + this.options.resource === false + ) { + identifier = `${requestShortener.shorten(`${this.options.resource}`)}/`; + } else { + identifier = this.options.resource + .map((r) => `${requestShortener.shorten(r)}/`) + .join(" "); + } + if (this.options.resourceQuery) { + identifier += ` ${this.options.resourceQuery}`; + } + if (this.options.mode) { + identifier += ` ${this.options.mode}`; + } + if (!this.options.recursive) { + identifier += " nonrecursive"; + } + if (this.options.addon) { + identifier += ` ${requestShortener.shorten(this.options.addon)}`; + } + if (this.options.regExp) { + identifier += ` ${this._prettyRegExp(this.options.regExp)}`; + } + if (this.options.include) { + identifier += ` include: ${this._prettyRegExp(this.options.include)}`; + } + if (this.options.exclude) { + identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`; + } + if (this.options.referencedExports) { + identifier += ` referencedExports: ${this.options.referencedExports + .map((e) => e.join(".")) + .join(", ")}`; + } + if (this.options.chunkName) { + identifier += ` chunkName: ${this.options.chunkName}`; + } + if (this.options.groupOptions) { + const groupOptions = this.options.groupOptions; + for (const key of Object.keys(groupOptions)) { + identifier += ` ${key}: ${ + groupOptions[/** @type {keyof RawChunkGroupOptions} */ (key)] + }`; + } + } + if (this.options.namespaceObject === "strict") { + identifier += " strict namespace object"; + } else if (this.options.namespaceObject) { + identifier += " namespace object"; + } + + return identifier; + } + + /** + * Gets the library identifier. + * @param {LibIdentOptions} options options + * @returns {LibIdent | null} an identifier for library inclusion + */ + libIdent(options) { + /** @type {string} */ + let identifier; + + if (this.context) { + identifier = contextify( + options.context, + this.context, + options.associatedObjectForCache + ); + } else if (typeof this.options.resource === "string") { + identifier = contextify( + options.context, + this.options.resource, + options.associatedObjectForCache + ); + } else if (this.options.resource === false) { + identifier = "false"; + } else { + identifier = this.options.resource + .map((res) => + contextify(options.context, res, options.associatedObjectForCache) + ) + .join(" "); + } + + if (this.layer) identifier = `(${this.layer})/${identifier}`; + if (this.options.mode) { + identifier += ` ${this.options.mode}`; + } + if (this.options.recursive) { + identifier += " recursive"; + } + if (this.options.addon) { + identifier += ` ${contextify( + options.context, + this.options.addon, + options.associatedObjectForCache + )}`; + } + if (this.options.regExp) { + identifier += ` ${this._prettyRegExp(this.options.regExp)}`; + } + if (this.options.include) { + identifier += ` include: ${this._prettyRegExp(this.options.include)}`; + } + if (this.options.exclude) { + identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`; + } + if (this.options.referencedExports) { + identifier += ` referencedExports: ${this.options.referencedExports + .map((e) => e.join(".")) + .join(", ")}`; + } + + return identifier; + } + + /** + * Invalidates the cached state associated with this value. + * @returns {void} + */ + invalidateBuild() { + this._forceBuild = true; + } + + /** + * Checks whether the module needs to be rebuilt for the current build state. + * @param {NeedBuildContext} context context info + * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild + * @returns {void} + */ + needBuild({ fileSystemInfo }, callback) { + // build if enforced + if (this._forceBuild) return callback(null, true); + + const buildInfo = /** @type {BuildInfo} */ (this.buildInfo); + + // always build when we have no snapshot and context + if (!buildInfo.snapshot) { + return callback(null, Boolean(this.context || this.options.resource)); + } + + fileSystemInfo.checkSnapshotValid(buildInfo.snapshot, (err, valid) => { + callback(err, !valid); + }); + } + + /** + * Builds the module using the provided compilation context. + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {BuildCallback} callback callback function + * @returns {void} + */ + build(options, compilation, resolver, fs, callback) { + this._forceBuild = false; + /** @type {BuildMeta} */ + this.buildMeta = { + exportsType: "default", + defaultObject: "redirect-warn" + }; + this.buildInfo = { + snapshot: undefined + }; + this.dependencies.length = 0; + this.blocks.length = 0; + const startTime = Date.now(); + /** @type {ResolveDependencies} */ + (this.resolveDependencies)(fs, this.options, (err, dependencies) => { + if (err) { + return callback( + makeWebpackError(err, "ContextModule.resolveDependencies") + ); + } + + // abort if something failed + // this will create an empty context + if (!dependencies) { + callback(); + return; + } + + // enhance dependencies with meta info + for (const dep of dependencies) { + dep.loc = { + name: dep.userRequest + }; + dep.request = this.options.addon + dep.request; + } + dependencies.sort( + concatComparators( + compareSelect((a) => a.loc, compareLocations), + keepOriginalOrder(this.dependencies) + ) + ); + + if (this.options.mode === "sync" || this.options.mode === "eager") { + // if we have an sync or eager context + // just add all dependencies and continue + this.dependencies = dependencies; + } else if (this.options.mode === "lazy-once") { + // for the lazy-once mode create a new async dependency block + // and add that block to this context + if (dependencies.length > 0) { + const block = new AsyncDependenciesBlock({ + ...this.options.groupOptions, + name: this.options.chunkName + }); + for (const dep of dependencies) { + block.addDependency(dep); + } + this.addBlock(block); + } + } else if ( + this.options.mode === "weak" || + this.options.mode === "async-weak" + ) { + // we mark all dependencies as weak + for (const dep of dependencies) { + dep.weak = true; + } + this.dependencies = dependencies; + } else if (this.options.mode === "lazy") { + // if we are lazy create a new async dependency block per dependency + // and add all blocks to this context + let index = 0; + for (const dep of dependencies) { + let chunkName = this.options.chunkName; + if (chunkName) { + if (!/\[(?:index|request)\]/.test(chunkName)) { + chunkName += "[index]"; + } + chunkName = chunkName.replace(/\[index\]/g, `${index++}`); + chunkName = chunkName.replace( + /\[request\]/g, + Template.toPath(dep.userRequest) + ); + } + const block = new AsyncDependenciesBlock( + { + ...this.options.groupOptions, + name: chunkName + }, + dep.loc, + dep.userRequest + ); + block.addDependency(dep); + this.addBlock(block); + } + } else { + callback( + new WebpackError(`Unsupported mode "${this.options.mode}" in context`) + ); + return; + } + if (!this.context && !this.options.resource) return callback(); + + const snapshotOptions = compilation.options.snapshot.contextModule; + + compilation.fileSystemInfo.createSnapshot( + startTime, + null, + this.context + ? [this.context] + : typeof this.options.resource === "string" + ? [this.options.resource] + : /** @type {string[]} */ (this.options.resource), + null, + snapshotOptions, + (err, snapshot) => { + if (err) return callback(err); + /** @type {BuildInfo} */ + (this.buildInfo).snapshot = snapshot; + callback(); + } + ); + }); + } + + /** + * Adds the provided file dependencies to the module. + * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to + * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to + * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to + * @param {FileSystemDependencies} buildDependencies set where build dependencies are added to + */ + addCacheDependencies( + fileDependencies, + contextDependencies, + missingDependencies, + buildDependencies + ) { + if (this.context) { + contextDependencies.add(this.context); + } else if (typeof this.options.resource === "string") { + contextDependencies.add(this.options.resource); + } else if (this.options.resource === false) { + // Do nothing + } else { + for (const res of this.options.resource) contextDependencies.add(res); + } + } + + /** + * @param {Dependency[]} dependencies all dependencies + * @param {ChunkGraph} chunkGraph chunk graph + * @returns {UserRequestMap} map with user requests + */ + getUserRequestMap(dependencies, chunkGraph) { + const moduleGraph = chunkGraph.moduleGraph; + // if we filter first we get a new array + // therefore we don't need to create a clone of dependencies explicitly + // therefore the order of this is !important! + const sortedDependencies = + /** @type {ContextElementDependency[]} */ + (dependencies) + .filter((dependency) => moduleGraph.getModule(dependency)) + .sort((a, b) => { + if (a.userRequest === b.userRequest) { + return 0; + } + return a.userRequest < b.userRequest ? -1 : 1; + }); + /** @type {UserRequestMap} */ + const map = Object.create(null); + for (const dep of sortedDependencies) { + const module = /** @type {Module} */ (moduleGraph.getModule(dep)); + map[dep.userRequest] = + /** @type {ModuleId} */ + (chunkGraph.getModuleId(module)); + } + return map; + } + + /** + * @param {Dependency[]} dependencies all dependencies + * @param {ChunkGraph} chunkGraph chunk graph + * @returns {FakeMap | FakeMapType} fake map + */ + getFakeMap(dependencies, chunkGraph) { + if (!this.options.namespaceObject) { + return 9; + } + const moduleGraph = chunkGraph.moduleGraph; + // bitfield + let hasType = 0; + const comparator = compareModulesById(chunkGraph); + // if we filter first we get a new array + // therefore we don't need to create a clone of dependencies explicitly + // therefore the order of this is !important! + const sortedModules = dependencies + .map( + (dependency) => + /** @type {Module} */ (moduleGraph.getModule(dependency)) + ) + .filter(Boolean) + .sort(comparator); + /** @type {FakeMap} */ + const fakeMap = Object.create(null); + for (const module of sortedModules) { + const exportsType = module.getExportsType( + moduleGraph, + this.options.namespaceObject === "strict" + ); + const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module)); + switch (exportsType) { + case "namespace": + fakeMap[id] = 9; + hasType |= 1; + break; + case "dynamic": + fakeMap[id] = 7; + hasType |= 2; + break; + case "default-only": + fakeMap[id] = 1; + hasType |= 4; + break; + case "default-with-named": + fakeMap[id] = 3; + hasType |= 8; + break; + default: + throw new Error(`Unexpected exports type ${exportsType}`); + } + } + if (hasType === 1) { + return 9; + } + if (hasType === 2) { + return 7; + } + if (hasType === 4) { + return 1; + } + if (hasType === 8) { + return 3; + } + if (hasType === 0) { + return 9; + } + return fakeMap; + } + + /** + * @param {FakeMap | FakeMapType} fakeMap fake map + * @returns {string} fake map init statement + */ + getFakeMapInitStatement(fakeMap) { + return typeof fakeMap === "object" + ? `var fakeMap = ${JSON.stringify(fakeMap, null, "\t")};` + : ""; + } + + /** + * @param {Dependency[]} dependencies all dependencies + * @param {ChunkGraph} chunkGraph chunk graph + * @returns {UserRequestsMap} map with user requests + */ + getModuleDeferredAsyncDepsMap(dependencies, chunkGraph) { + const moduleGraph = chunkGraph.moduleGraph; + const comparator = compareModulesById(chunkGraph); + // if we filter first we get a new array + // therefore we don't need to create a clone of dependencies explicitly + // therefore the order of this is !important! + const sortedModules = dependencies + .map( + (dependency) => + /** @type {Module} */ (moduleGraph.getModule(dependency)) + ) + .filter(Boolean) + .sort(comparator); + /** @type {UserRequestsMap} */ + const map = Object.create(null); + for (const module of sortedModules) { + if (!(/** @type {BuildMeta} */ (module.buildMeta).async)) { + const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module)); + map[id] = Array.from( + getOutgoingAsyncModules(chunkGraph.moduleGraph, module), + (m) => chunkGraph.getModuleId(m) + ).filter((id) => id !== null); + } + } + return map; + } + + /** + * @param {false | UserRequestsMap} asyncDepsMap fake map + * @returns {string} async deps map init statement + */ + getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap) { + return typeof asyncDepsMap === "object" + ? `var asyncDepsMap = ${JSON.stringify(asyncDepsMap, null, "\t")};` + : ""; + } + + /** + * @param {FakeMapType} type type + * @param {boolean=} asyncModule is async module + * @returns {string} return result + */ + getReturn(type, asyncModule) { + if (type === 9) { + return `${RuntimeGlobals.require}(id)`; + } + return `${RuntimeGlobals.createFakeNamespaceObject}(id, ${type}${ + asyncModule ? " | 16" : "" + })`; + } + + /** + * @param {FakeMap | FakeMapType} fakeMap fake map + * @param {boolean=} asyncModule is async module + * @param {string=} asyncDeps async deps for deferred module + * @param {string=} fakeMapDataExpression fake map data expression + * @returns {string} module object source + */ + getReturnModuleObjectSource( + fakeMap, + asyncModule, + asyncDeps, + fakeMapDataExpression = "fakeMap[id]" + ) { + const source = + typeof fakeMap === "number" + ? this.getReturn(fakeMap, asyncModule) + : `${RuntimeGlobals.createFakeNamespaceObject}(id, ${fakeMapDataExpression}${asyncModule ? " | 16" : ""})`; + if (asyncDeps) { + if (!asyncModule) { + throw new Error("Must be async when module is deferred"); + } + const type = + typeof fakeMap === "number" ? fakeMap : fakeMapDataExpression; + return `${asyncDeps} ? ${asyncDeps}.length ? ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${asyncDeps}).then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, id, ${type} ^ 1, true)) : ${RuntimeGlobals.makeDeferredNamespaceObject}(id, ${type} ^ 1 | 16) : ${source}`; + } + return source; + } + + /** + * @param {Dependency[]} dependencies dependencies + * @param {ModuleId} id module id + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {string} source code + */ + getSyncSource(dependencies, id, chunkGraph) { + const map = this.getUserRequestMap(dependencies, chunkGraph); + const fakeMap = this.getFakeMap(dependencies, chunkGraph); + const returnModuleObject = this.getReturnModuleObjectSource(fakeMap); + + return `var map = ${JSON.stringify(map, null, "\t")}; +${this.getFakeMapInitStatement(fakeMap)} + +function webpackContext(req) { + var id = webpackContextResolve(req); + return ${returnModuleObject}; +} +function webpackContextResolve(req) { + if(!${RuntimeGlobals.hasOwnProperty}(map, req)) { + var e = new Error("Cannot find module '" + req + "'"); + e.code = 'MODULE_NOT_FOUND'; + throw e; + } + return map[req]; +} +webpackContext.keys = function webpackContextKeys() { + return Object.keys(map); +}; +webpackContext.resolve = webpackContextResolve; +module.exports = webpackContext; +webpackContext.id = ${JSON.stringify(id)};`; + } + + /** + * @param {Dependency[]} dependencies dependencies + * @param {ModuleId} id module id + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {string} source code + */ + getWeakSyncSource(dependencies, id, chunkGraph) { + const map = this.getUserRequestMap(dependencies, chunkGraph); + const fakeMap = this.getFakeMap(dependencies, chunkGraph); + const returnModuleObject = this.getReturnModuleObjectSource(fakeMap); + + return `var map = ${JSON.stringify(map, null, "\t")}; +${this.getFakeMapInitStatement(fakeMap)} + +function webpackContext(req) { + var id = webpackContextResolve(req); + if(!${RuntimeGlobals.moduleFactories}[id]) { + var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)"); + e.code = 'MODULE_NOT_FOUND'; + throw e; + } + return ${returnModuleObject}; +} +function webpackContextResolve(req) { + if(!${RuntimeGlobals.hasOwnProperty}(map, req)) { + var e = new Error("Cannot find module '" + req + "'"); + e.code = 'MODULE_NOT_FOUND'; + throw e; + } + return map[req]; +} +webpackContext.keys = function webpackContextKeys() { + return Object.keys(map); +}; +webpackContext.resolve = webpackContextResolve; +webpackContext.id = ${JSON.stringify(id)}; +module.exports = webpackContext;`; + } + + /** + * @param {Dependency[]} dependencies dependencies + * @param {ModuleId} id module id + * @param {ImportPhaseType} phase import phase + * @param {object} context context + * @param {ChunkGraph} context.chunkGraph the chunk graph + * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph + * @returns {string} source code + */ + getAsyncWeakSource(dependencies, id, phase, { chunkGraph, runtimeTemplate }) { + const map = this.getUserRequestMap(dependencies, chunkGraph); + const fakeMap = this.getFakeMap(dependencies, chunkGraph); + const asyncDepsMap = + ImportPhaseUtils.isDefer(phase) && + this.getModuleDeferredAsyncDepsMap(dependencies, chunkGraph); + const returnModuleObject = this.getReturnModuleObjectSource( + fakeMap, + true, + asyncDepsMap ? "asyncDepsMap[id]" : undefined + ); + + return `var map = ${JSON.stringify(map, null, "\t")}; +${this.getFakeMapInitStatement(fakeMap)} +${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap)} + +function webpackAsyncContext(req) { + return webpackAsyncContextResolve(req).then(${runtimeTemplate.basicFunction( + "id", + [ + `if(!${RuntimeGlobals.moduleFactories}[id]) {`, + Template.indent([ + 'var e = new Error("Module \'" + req + "\' (\'" + id + "\') is not available (weak dependency)");', + "e.code = 'MODULE_NOT_FOUND';", + "throw e;" + ]), + "}", + `return ${returnModuleObject};` + ] + )}); +} +function webpackAsyncContextResolve(req) { + // Here Promise.resolve().then() is used instead of new Promise() to prevent + // uncaught exception popping up in devtools + return Promise.resolve().then(${runtimeTemplate.basicFunction("", [ + `if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`, + Template.indent([ + 'var e = new Error("Cannot find module \'" + req + "\'");', + "e.code = 'MODULE_NOT_FOUND';", + "throw e;" + ]), + "}", + "return map[req];" + ])}); +} +webpackAsyncContext.keys = ${runtimeTemplate.returningFunction( + "Object.keys(map)" + )}; +webpackAsyncContext.resolve = webpackAsyncContextResolve; +webpackAsyncContext.id = ${JSON.stringify(id)}; +module.exports = webpackAsyncContext;`; + } + + /** + * @param {Dependency[]} dependencies dependencies + * @param {ModuleId} id module id + * @param {ImportPhaseType} phase import phase + * @param {object} context context + * @param {ChunkGraph} context.chunkGraph the chunk graph + * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph + * @returns {string} source code + */ + getEagerSource(dependencies, id, phase, { chunkGraph, runtimeTemplate }) { + const map = this.getUserRequestMap(dependencies, chunkGraph); + const fakeMap = this.getFakeMap(dependencies, chunkGraph); + const asyncDepsMap = + ImportPhaseUtils.isDefer(phase) && + this.getModuleDeferredAsyncDepsMap(dependencies, chunkGraph); + const thenFunction = runtimeTemplate.returningFunction( + this.getReturnModuleObjectSource( + fakeMap, + true, + asyncDepsMap ? "asyncDepsMap[id]" : undefined + ), + "id" + ); + + return `var map = ${JSON.stringify(map, null, "\t")}; +${this.getFakeMapInitStatement(fakeMap)} +${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap)} + +function webpackAsyncContext(req) { + return webpackAsyncContextResolve(req).then(${thenFunction}); +} +function webpackAsyncContextResolve(req) { + // Here Promise.resolve().then() is used instead of new Promise() to prevent + // uncaught exception popping up in devtools + return Promise.resolve().then(${runtimeTemplate.basicFunction("", [ + `if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`, + Template.indent([ + 'var e = new Error("Cannot find module \'" + req + "\'");', + "e.code = 'MODULE_NOT_FOUND';", + "throw e;" + ]), + "}", + "return map[req];" + ])}); +} +webpackAsyncContext.keys = ${runtimeTemplate.returningFunction( + "Object.keys(map)" + )}; +webpackAsyncContext.resolve = webpackAsyncContextResolve; +webpackAsyncContext.id = ${JSON.stringify(id)}; +module.exports = webpackAsyncContext;`; + } + + /** + * @param {AsyncDependenciesBlock} block block + * @param {Dependency[]} dependencies dependencies + * @param {ModuleId} id module id + * @param {ImportPhaseType} phase import phase + * @param {object} options options object + * @param {RuntimeTemplate} options.runtimeTemplate the runtime template + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @returns {string} source code + */ + getLazyOnceSource( + block, + dependencies, + id, + phase, + { runtimeTemplate, chunkGraph } + ) { + const promise = runtimeTemplate.blockPromise({ + chunkGraph, + block, + message: "lazy-once context", + /** @type {RuntimeRequirements} */ + runtimeRequirements: new Set() + }); + const map = this.getUserRequestMap(dependencies, chunkGraph); + const fakeMap = this.getFakeMap(dependencies, chunkGraph); + const asyncDepsMap = + ImportPhaseUtils.isDefer(phase) && + this.getModuleDeferredAsyncDepsMap(dependencies, chunkGraph); + const thenFunction = runtimeTemplate.returningFunction( + this.getReturnModuleObjectSource( + fakeMap, + true, + asyncDepsMap ? "asyncDepsMap[id]" : undefined + ), + "id" + ); + + return `var map = ${JSON.stringify(map, null, "\t")}; +${this.getFakeMapInitStatement(fakeMap)} +${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap)} + +function webpackAsyncContext(req) { + return webpackAsyncContextResolve(req).then(${thenFunction}); +} +function webpackAsyncContextResolve(req) { + return ${promise}.then(${runtimeTemplate.basicFunction("", [ + `if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`, + Template.indent([ + 'var e = new Error("Cannot find module \'" + req + "\'");', + "e.code = 'MODULE_NOT_FOUND';", + "throw e;" + ]), + "}", + "return map[req];" + ])}); +} +webpackAsyncContext.keys = ${runtimeTemplate.returningFunction( + "Object.keys(map)" + )}; +webpackAsyncContext.resolve = webpackAsyncContextResolve; +webpackAsyncContext.id = ${JSON.stringify(id)}; +module.exports = webpackAsyncContext;`; + } + + /** + * @param {AsyncDependenciesBlock[]} blocks blocks + * @param {ModuleId} id module id + * @param {ImportPhaseType} phase import phase + * @param {object} context context + * @param {ChunkGraph} context.chunkGraph the chunk graph + * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph + * @returns {string} source code + */ + getLazySource(blocks, id, phase, { chunkGraph, runtimeTemplate }) { + const moduleGraph = chunkGraph.moduleGraph; + let hasMultipleOrNoChunks = false; + let hasNoChunk = true; + let hasNoModuleDeferred = true; + const fakeMap = this.getFakeMap( + blocks.map((b) => b.dependencies[0]), + chunkGraph + ); + const hasFakeMap = typeof fakeMap === "object"; + /** @typedef {{ userRequest: string, dependency: ContextElementDependency, chunks: undefined | Chunk[], module: Module, block: AsyncDependenciesBlock, asyncDeps: undefined | ModuleId[] }} Item */ + /** + * @type {Item[]} + */ + const items = blocks + .map((block) => { + const dependency = + /** @type {ContextElementDependency} */ + (block.dependencies[0]); + return { + dependency, + module: /** @type {Module} */ (moduleGraph.getModule(dependency)), + block, + userRequest: dependency.userRequest, + chunks: undefined, + asyncDeps: undefined + }; + }) + .filter((item) => item.module); + for (const item of items) { + const chunkGroup = chunkGraph.getBlockChunkGroup(item.block); + const chunks = (chunkGroup && chunkGroup.chunks) || []; + item.chunks = chunks; + if (chunks.length > 0) { + hasNoChunk = false; + } + if (chunks.length !== 1) { + hasMultipleOrNoChunks = true; + } + const isModuleDeferred = + ImportPhaseUtils.isDefer(phase) && + !(/** @type {BuildMeta} */ (item.module.buildMeta).async); + if (isModuleDeferred) { + const asyncDeps = Array.from( + getOutgoingAsyncModules(chunkGraph.moduleGraph, item.module), + (m) => chunkGraph.getModuleId(m) + ).filter((id) => id !== null); + item.asyncDeps = asyncDeps; + hasNoModuleDeferred = false; + } + } + const shortMode = hasNoChunk && hasNoModuleDeferred && !hasFakeMap; + const sortedItems = items.sort((a, b) => { + if (a.userRequest === b.userRequest) return 0; + return a.userRequest < b.userRequest ? -1 : 1; + }); + /** @type {Record} */ + const map = Object.create(null); + for (const item of sortedItems) { + const moduleId = + /** @type {ModuleId} */ + (chunkGraph.getModuleId(item.module)); + if (shortMode) { + map[item.userRequest] = moduleId; + } else { + /** @type {(ModuleId | FakeMapType | ChunkId[] | (ModuleId[] | undefined))[]} */ + const array = [moduleId]; + if (hasFakeMap) { + array.push(fakeMap[moduleId]); + } + if (!hasNoChunk) { + array.push( + /** @type {Chunk[]} */ (item.chunks).map( + (chunk) => /** @type {ChunkId} */ (chunk.id) + ) + ); + } + if (!hasNoModuleDeferred) { + array.push(item.asyncDeps); + } + map[item.userRequest] = array; + } + } + + const chunksPosition = hasFakeMap ? 2 : 1; + const asyncDepsPosition = chunksPosition + 1; + const requestPrefix = hasNoChunk + ? "Promise.resolve()" + : hasMultipleOrNoChunks + ? `Promise.all(ids[${chunksPosition}].map(${RuntimeGlobals.ensureChunk}))` + : `${RuntimeGlobals.ensureChunk}(ids[${chunksPosition}][0])`; + const returnModuleObject = this.getReturnModuleObjectSource( + fakeMap, + true, + hasNoModuleDeferred ? undefined : `ids[${asyncDepsPosition}]`, + shortMode ? "invalid" : "ids[1]" + ); + + const webpackAsyncContext = + requestPrefix === "Promise.resolve()" + ? ` +function webpackAsyncContext(req) { + return Promise.resolve().then(${runtimeTemplate.basicFunction("", [ + `if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`, + Template.indent([ + 'var e = new Error("Cannot find module \'" + req + "\'");', + "e.code = 'MODULE_NOT_FOUND';", + "throw e;" + ]), + "}", + shortMode ? "var id = map[req];" : "var ids = map[req], id = ids[0];", + `return ${returnModuleObject};` + ])}); +}` + : `function webpackAsyncContext(req) { + try { + if(!${RuntimeGlobals.hasOwnProperty}(map, req)) { + return Promise.resolve().then(${runtimeTemplate.basicFunction("", [ + 'var e = new Error("Cannot find module \'" + req + "\'");', + "e.code = 'MODULE_NOT_FOUND';", + "throw e;" + ])}); + } + } catch(err) { + return Promise.reject(err); + } + + var ids = map[req], id = ids[0]; + return ${requestPrefix}.then(${runtimeTemplate.returningFunction(returnModuleObject)}); +}`; + + return `var map = ${JSON.stringify(map, null, "\t")}; +${webpackAsyncContext} +webpackAsyncContext.keys = ${runtimeTemplate.returningFunction( + "Object.keys(map)" + )}; +webpackAsyncContext.id = ${JSON.stringify(id)}; +module.exports = webpackAsyncContext;`; + } + + /** + * @param {ModuleId} id module id + * @param {RuntimeTemplate} runtimeTemplate runtime template + * @returns {string} source for empty async context + */ + getSourceForEmptyContext(id, runtimeTemplate) { + return `function webpackEmptyContext(req) { + var e = new Error("Cannot find module '" + req + "'"); + e.code = 'MODULE_NOT_FOUND'; + throw e; +} +webpackEmptyContext.keys = ${runtimeTemplate.returningFunction("[]")}; +webpackEmptyContext.resolve = webpackEmptyContext; +webpackEmptyContext.id = ${JSON.stringify(id)}; +module.exports = webpackEmptyContext;`; + } + + /** + * @param {ModuleId} id module id + * @param {RuntimeTemplate} runtimeTemplate runtime template + * @returns {string} source for empty async context + */ + getSourceForEmptyAsyncContext(id, runtimeTemplate) { + return `function webpackEmptyAsyncContext(req) { + // Here Promise.resolve().then() is used instead of new Promise() to prevent + // uncaught exception popping up in devtools + return Promise.resolve().then(${runtimeTemplate.basicFunction("", [ + 'var e = new Error("Cannot find module \'" + req + "\'");', + "e.code = 'MODULE_NOT_FOUND';", + "throw e;" + ])}); +} +webpackEmptyAsyncContext.keys = ${runtimeTemplate.returningFunction("[]")}; +webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext; +webpackEmptyAsyncContext.id = ${JSON.stringify(id)}; +module.exports = webpackEmptyAsyncContext;`; + } + + /** + * @param {string} asyncMode module mode + * @param {ImportPhaseType} phase import phase + * @param {CodeGenerationContext} context context info + * @returns {string} the source code + */ + getSourceString(asyncMode, phase, { runtimeTemplate, chunkGraph }) { + const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(this)); + if (asyncMode === "lazy") { + if (this.blocks && this.blocks.length > 0) { + return this.getLazySource(this.blocks, id, phase, { + runtimeTemplate, + chunkGraph + }); + } + return this.getSourceForEmptyAsyncContext(id, runtimeTemplate); + } + if (asyncMode === "eager") { + if (this.dependencies && this.dependencies.length > 0) { + return this.getEagerSource(this.dependencies, id, phase, { + chunkGraph, + runtimeTemplate + }); + } + return this.getSourceForEmptyAsyncContext(id, runtimeTemplate); + } + if (asyncMode === "lazy-once") { + const block = this.blocks[0]; + if (block) { + return this.getLazyOnceSource(block, block.dependencies, id, phase, { + runtimeTemplate, + chunkGraph + }); + } + return this.getSourceForEmptyAsyncContext(id, runtimeTemplate); + } + if (asyncMode === "async-weak") { + if (this.dependencies && this.dependencies.length > 0) { + return this.getAsyncWeakSource(this.dependencies, id, phase, { + chunkGraph, + runtimeTemplate + }); + } + return this.getSourceForEmptyAsyncContext(id, runtimeTemplate); + } + if ( + asyncMode === "weak" && + this.dependencies && + this.dependencies.length > 0 + ) { + return this.getWeakSyncSource(this.dependencies, id, chunkGraph); + } + if (this.dependencies && this.dependencies.length > 0) { + return this.getSyncSource(this.dependencies, id, chunkGraph); + } + return this.getSourceForEmptyContext(id, runtimeTemplate); + } + + /** + * @param {string} sourceString source content + * @param {Compilation=} compilation the compilation + * @returns {Source} generated source + */ + getSource(sourceString, compilation) { + if (this.useSourceMap || this.useSimpleSourceMap) { + return new OriginalSource( + sourceString, + `webpack://${makePathsRelative( + (compilation && compilation.compiler.context) || "", + this.identifier(), + compilation && compilation.compiler.root + )}` + ); + } + return new RawSource(sourceString); + } + + /** + * Generates code and runtime requirements for this module. + * @param {CodeGenerationContext} context context for code generation + * @returns {CodeGenerationResult} result + */ + codeGeneration(context) { + const { chunkGraph, compilation } = context; + + /** @type {Sources} */ + const sources = new Map(); + sources.set( + JAVASCRIPT_TYPE, + this.getSource( + this.getSourceString( + this.options.mode, + this.options.phase || ImportPhase.Evaluation, + context + ), + compilation + ) + ); + /** @type {RuntimeRequirements} */ + const set = new Set(); + const allDeps = + this.dependencies.length > 0 + ? /** @type {ContextElementDependency[]} */ [...this.dependencies] + : []; + for (const block of this.blocks) { + for (const dep of block.dependencies) { + allDeps.push(/** @type {ContextElementDependency} */ (dep)); + } + } + set.add(RuntimeGlobals.module); + set.add(RuntimeGlobals.hasOwnProperty); + if (allDeps.length > 0) { + const asyncMode = this.options.mode; + set.add(RuntimeGlobals.require); + if (asyncMode === "weak") { + set.add(RuntimeGlobals.moduleFactories); + } else if (asyncMode === "async-weak") { + set.add(RuntimeGlobals.moduleFactories); + set.add(RuntimeGlobals.ensureChunk); + } else if (asyncMode === "lazy" || asyncMode === "lazy-once") { + set.add(RuntimeGlobals.ensureChunk); + } + if (this.getFakeMap(allDeps, chunkGraph) !== 9) { + set.add(RuntimeGlobals.createFakeNamespaceObject); + } + if ( + ImportPhaseUtils.isDefer(this.options.phase || ImportPhase.Evaluation) + ) { + set.add(RuntimeGlobals.makeDeferredNamespaceObject); + } + } + return { + sources, + runtimeRequirements: set + }; + } + + /** + * Returns the estimated size for the requested source type. + * @param {string=} type the source type for which the size should be estimated + * @returns {number} the estimated size of the module (must be non-zero) + */ + size(type) { + // base penalty + let size = 160; + + // if we don't have dependencies we stop here. + for (const dependency of this.dependencies) { + const element = /** @type {ContextElementDependency} */ (dependency); + size += 5 + element.userRequest.length; + } + return size; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + write(this._identifier); + write(this._forceBuild); + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + this._identifier = read(); + this._forceBuild = read(); + super.deserialize(context); + } +} + +makeSerializable(ContextModule, "webpack/lib/ContextModule"); + +module.exports = ContextModule; Index: frontend/node_modules/webpack/lib/ContextModuleFactory.js =================================================================== --- frontend/node_modules/webpack/lib/ContextModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ContextModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,524 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const asyncLib = require("neo-async"); +const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = require("tapable"); +const ContextModule = require("./ContextModule"); +const ModuleFactory = require("./ModuleFactory"); +const ContextElementDependency = require("./dependencies/ContextElementDependency"); +const LazySet = require("./util/LazySet"); +const { cachedSetProperty } = require("./util/cleverMerge"); +const { createFakeHook } = require("./util/deprecation"); +const { join } = require("./util/fs"); + +/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */ +/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */ +/** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */ +/** @typedef {import("./ResolverFactory")} ResolverFactory */ +/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */ +/** @typedef {import("./dependencies/ContextDependency").ContextOptions} ContextOptions */ + +/** + * Defines the shared type used by this module. + * @template T + * @typedef {import("./util/deprecation").FakeHook} FakeHook + */ +/** @typedef {import("./util/fs").IStats} IStats */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {{ context: string, request: string }} ContextAlternativeRequest */ + +/** + * Defines the context resolve data type used by this module. + * @typedef {object} ContextResolveData + * @property {string} context + * @property {string} request + * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions + * @property {FileSystemDependencies} fileDependencies + * @property {FileSystemDependencies} missingDependencies + * @property {FileSystemDependencies} contextDependencies + * @property {ContextDependency[]} dependencies + */ + +/** @typedef {ContextResolveData & ContextOptions} BeforeContextResolveData */ +/** @typedef {BeforeContextResolveData & { resource: string | string[], resourceQuery: string | undefined, resourceFragment: string | undefined, resolveDependencies: ContextModuleFactory["resolveDependencies"] }} AfterContextResolveData */ + +const EMPTY_RESOLVE_OPTIONS = {}; + +class ContextModuleFactory extends ModuleFactory { + /** + * Creates an instance of ContextModuleFactory. + * @param {ResolverFactory} resolverFactory resolverFactory + */ + constructor(resolverFactory) { + super(); + /** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[], ContextModuleOptions]>} */ + const alternativeRequests = new AsyncSeriesWaterfallHook([ + "modules", + "options" + ]); + this.hooks = Object.freeze({ + /** @type {AsyncSeriesWaterfallHook<[BeforeContextResolveData], BeforeContextResolveData | false | void>} */ + beforeResolve: new AsyncSeriesWaterfallHook(["data"]), + /** @type {AsyncSeriesWaterfallHook<[AfterContextResolveData], AfterContextResolveData | false | void>} */ + afterResolve: new AsyncSeriesWaterfallHook(["data"]), + /** @type {SyncWaterfallHook<[string[]]>} */ + contextModuleFiles: new SyncWaterfallHook(["files"]), + /** @type {FakeHook, "tap" | "tapAsync" | "tapPromise" | "name">>} */ + alternatives: createFakeHook( + { + name: "alternatives", + /** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["intercept"]} */ + intercept: (interceptor) => { + throw new Error( + "Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead" + ); + }, + /** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["tap"]} */ + tap: (options, fn) => { + alternativeRequests.tap(options, fn); + }, + /** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["tapAsync"]} */ + tapAsync: (options, fn) => { + alternativeRequests.tapAsync(options, (items, _options, callback) => + fn(items, callback) + ); + }, + /** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["tapPromise"]} */ + tapPromise: (options, fn) => { + alternativeRequests.tapPromise(options, fn); + } + }, + "ContextModuleFactory.hooks.alternatives has deprecated in favor of ContextModuleFactory.hooks.alternativeRequests with an additional options argument.", + "DEP_WEBPACK_CONTEXT_MODULE_FACTORY_ALTERNATIVES" + ), + alternativeRequests + }); + /** @type {ResolverFactory} */ + this.resolverFactory = resolverFactory; + } + + /** + * Processes the provided data. + * @param {ModuleFactoryCreateData} data data object + * @param {ModuleFactoryCallback} callback callback + * @returns {void} + */ + create(data, callback) { + const context = data.context; + const dependencies = /** @type {ContextDependency[]} */ (data.dependencies); + const resolveOptions = data.resolveOptions; + const dependency = dependencies[0]; + /** @type {FileSystemDependencies} */ + const fileDependencies = new LazySet(); + /** @type {FileSystemDependencies} */ + const missingDependencies = new LazySet(); + /** @type {FileSystemDependencies} */ + const contextDependencies = new LazySet(); + this.hooks.beforeResolve.callAsync( + { + context, + dependencies, + layer: data.contextInfo.issuerLayer, + resolveOptions, + fileDependencies, + missingDependencies, + contextDependencies, + ...dependency.options + }, + (err, beforeResolveResult) => { + if (err) { + return callback(err, { + fileDependencies, + missingDependencies, + contextDependencies + }); + } + + // Ignored + if (!beforeResolveResult) { + return callback(null, { + fileDependencies, + missingDependencies, + contextDependencies + }); + } + + const context = beforeResolveResult.context; + const request = beforeResolveResult.request; + const resolveOptions = beforeResolveResult.resolveOptions; + + /** @type {undefined | string[]} */ + let loaders; + /** @type {undefined | string} */ + let resource; + let loadersPrefix = ""; + const idx = request.lastIndexOf("!"); + if (idx >= 0) { + let loadersRequest = request.slice(0, idx + 1); + /** @type {number} */ + let i; + for ( + i = 0; + i < loadersRequest.length && loadersRequest[i] === "!"; + i++ + ) { + loadersPrefix += "!"; + } + loadersRequest = loadersRequest + .slice(i) + .replace(/!+$/, "") + .replace(/!{2,}/g, "!"); + loaders = loadersRequest === "" ? [] : loadersRequest.split("!"); + resource = request.slice(idx + 1); + } else { + loaders = []; + resource = request; + } + + const contextResolver = this.resolverFactory.get( + "context", + dependencies.length > 0 + ? cachedSetProperty( + resolveOptions || EMPTY_RESOLVE_OPTIONS, + "dependencyType", + dependencies[0].category + ) + : resolveOptions + ); + const loaderResolver = this.resolverFactory.get("loader"); + + asyncLib.parallel( + [ + (callback) => { + const results = /** @type {ResolveRequest[]} */ ([]); + /** + * Processes the provided obj. + * @param {ResolveRequest} obj obj + * @returns {void} + */ + const yield_ = (obj) => { + results.push(obj); + }; + + contextResolver.resolve( + {}, + context, + resource, + { + fileDependencies, + missingDependencies, + contextDependencies, + yield: yield_ + }, + (err) => { + if (err) return callback(err); + callback(null, results); + } + ); + }, + (callback) => { + asyncLib.map( + loaders, + (loader, callback) => { + loaderResolver.resolve( + {}, + context, + loader, + { + fileDependencies, + missingDependencies, + contextDependencies + }, + (err, result) => { + if (err) return callback(err); + callback(null, result); + } + ); + }, + callback + ); + } + ], + (err, result) => { + if (err) { + return callback(err, { + fileDependencies, + missingDependencies, + contextDependencies + }); + } + let [contextResult, loaderResult] = + /** @type {[ResolveRequest[], string[]]} */ (result); + if (contextResult.length > 1) { + const first = contextResult[0]; + contextResult = contextResult.filter((r) => r.path); + if (contextResult.length === 0) contextResult.push(first); + } + this.hooks.afterResolve.callAsync( + { + addon: + loadersPrefix + + loaderResult.join("!") + + (loaderResult.length > 0 ? "!" : ""), + resource: + contextResult.length > 1 + ? /** @type {string[]} */ (contextResult.map((r) => r.path)) + : /** @type {string} */ (contextResult[0].path), + resolveDependencies: this.resolveDependencies.bind(this), + resourceQuery: contextResult[0].query, + resourceFragment: contextResult[0].fragment, + ...beforeResolveResult + }, + (err, result) => { + if (err) { + return callback(err, { + fileDependencies, + missingDependencies, + contextDependencies + }); + } + + // Ignored + if (!result) { + return callback(null, { + fileDependencies, + missingDependencies, + contextDependencies + }); + } + + return callback(null, { + module: new ContextModule(result.resolveDependencies, result), + fileDependencies, + missingDependencies, + contextDependencies + }); + } + ); + } + ); + } + ); + } + + /** + * Resolves dependencies. + * @param {InputFileSystem} fs file system + * @param {ContextModuleOptions} options options + * @param {ResolveDependenciesCallback} callback callback function + * @returns {void} + */ + resolveDependencies(fs, options, callback) { + const cmf = this; + const { + resource, + resourceQuery, + resourceFragment, + recursive, + regExp, + include, + exclude, + referencedExports, + category, + typePrefix, + attributes + } = options; + if (!regExp || !resource) return callback(null, []); + + /** + * Adds directory checked. + * @param {string} ctx context + * @param {string} directory directory + * @param {Set} visited visited + * @param {ResolveDependenciesCallback} callback callback + */ + const addDirectoryChecked = (ctx, directory, visited, callback) => { + /** @type {NonNullable} */ + (fs.realpath)(directory, (err, _realPath) => { + if (err) return callback(err); + const realPath = /** @type {string} */ (_realPath); + if (visited.has(realPath)) return callback(null, []); + /** @type {Set | undefined} */ + let recursionStack; + addDirectory( + ctx, + directory, + (_, dir, callback) => { + if (recursionStack === undefined) { + recursionStack = new Set(visited); + recursionStack.add(realPath); + } + addDirectoryChecked(ctx, dir, recursionStack, callback); + }, + callback + ); + }); + }; + + /** + * Adds the provided ctx to the context module factory. + * @param {string} ctx context + * @param {string} directory directory + * @param {(context: string, subResource: string, callback: () => void) => void} addSubDirectory addSubDirectoryFn + * @param {ResolveDependenciesCallback} callback callback + * @returns {void} + */ + const addDirectory = (ctx, directory, addSubDirectory, callback) => { + fs.readdir(directory, (err, files) => { + if (err) return callback(err); + const processedFiles = cmf.hooks.contextModuleFiles.call( + /** @type {string[]} */ (files).map((file) => file.normalize("NFC")) + ); + if (!processedFiles || processedFiles.length === 0) { + return callback(null, []); + } + asyncLib.map( + processedFiles.filter((p) => p.indexOf(".") !== 0), + (segment, callback) => { + const subResource = join(fs, directory, segment); + + if (!exclude || !exclude.test(subResource)) { + fs.stat(subResource, (err, _stat) => { + if (err) { + if (err.code === "ENOENT") { + // ENOENT is ok here because the file may have been deleted between + // the readdir and stat calls. + return callback(); + } + return callback(err); + } + + const stat = /** @type {IStats} */ (_stat); + + if (stat.isDirectory()) { + if (!recursive) return callback(); + addSubDirectory(ctx, subResource, callback); + } else if ( + stat.isFile() && + (!include || include.test(subResource)) + ) { + /** @type {{ context: string, request: string }} */ + const obj = { + context: ctx, + request: `.${subResource.slice(ctx.length).replace(/\\/g, "/")}` + }; + + this.hooks.alternativeRequests.callAsync( + [obj], + options, + (err, alternatives) => { + if (err) return callback(err); + callback( + null, + /** @type {ContextAlternativeRequest[]} */ + (alternatives) + .filter((obj) => + regExp.test(/** @type {string} */ (obj.request)) + ) + .map((obj) => { + const dep = new ContextElementDependency( + `${obj.request}${resourceQuery}${resourceFragment}`, + obj.request, + typePrefix, + /** @type {string} */ + (category), + referencedExports, + obj.context, + attributes + ); + dep.optional = true; + return dep; + }) + ); + } + ); + } else { + callback(); + } + }); + } else { + callback(); + } + }, + (err, result) => { + if (err) return callback(err); + + if (!result) return callback(null, []); + + /** @type {ContextElementDependency[]} */ + const flattenedResult = []; + + for (const item of result) { + if (item) flattenedResult.push(...item); + } + + callback(null, flattenedResult); + } + ); + }); + }; + + /** + * Adds sub directory. + * @param {string} ctx context + * @param {string} dir dir + * @param {ResolveDependenciesCallback} callback callback + * @returns {void} + */ + const addSubDirectory = (ctx, dir, callback) => + addDirectory(ctx, dir, addSubDirectory, callback); + + /** + * Processes the provided resource. + * @param {string} resource resource + * @param {ResolveDependenciesCallback} callback callback + */ + const visitResource = (resource, callback) => { + if (typeof fs.realpath === "function") { + addDirectoryChecked( + resource, + resource, + /** @type {Set} */ + new Set(), + callback + ); + } else { + addDirectory(resource, resource, addSubDirectory, callback); + } + }; + + if (typeof resource === "string") { + visitResource(resource, callback); + } else { + asyncLib.map(resource, visitResource, (err, _result) => { + if (err) return callback(err); + const result = /** @type {ContextElementDependency[][]} */ (_result); + + // result dependencies should have unique userRequest + // ordered by resolve result + /** @type {Set} */ + const temp = new Set(); + /** @type {ContextElementDependency[]} */ + const res = []; + for (let i = 0; i < result.length; i++) { + const inner = result[i]; + for (const el of inner) { + if (temp.has(el.userRequest)) continue; + res.push(el); + temp.add(el.userRequest); + } + } + callback(null, res); + }); + } + } +} + +module.exports = ContextModuleFactory; Index: frontend/node_modules/webpack/lib/ContextReplacementPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ContextReplacementPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ContextReplacementPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,230 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const ContextElementDependency = require("./dependencies/ContextElementDependency"); +const { join } = require("./util/fs"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */ +/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */ +/** @typedef {import("./ContextModuleFactory").AfterContextResolveData} AfterContextResolveData */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ + +/** @typedef {Record} NewContentCreateContextMap */ + +const PLUGIN_NAME = "ContextReplacementPlugin"; + +class ContextReplacementPlugin { + /** + * Creates an instance of ContextReplacementPlugin. + * @param {RegExp} resourceRegExp A regular expression that determines which files will be selected + * @param {(string | ((context: BeforeContextResolveData | AfterContextResolveData) => void) | RegExp | boolean)=} newContentResource A new resource to replace the match + * @param {(boolean | NewContentCreateContextMap | RegExp)=} newContentRecursive If true, all subdirectories are searched for matches + * @param {RegExp=} newContentRegExp A regular expression that determines which files will be selected + */ + constructor( + resourceRegExp, + newContentResource, + newContentRecursive, + newContentRegExp + ) { + this.resourceRegExp = resourceRegExp; + + // new webpack.ContextReplacementPlugin(/selector/, (context) => { /* Logic */ }); + if (typeof newContentResource === "function") { + this.newContentCallback = newContentResource; + } + // new ContextReplacementPlugin(/selector/, './folder', { './request': './request' }); + else if ( + typeof newContentResource === "string" && + typeof newContentRecursive === "object" + ) { + this.newContentResource = newContentResource; + /** + * Stores new content create context map. + * @param {InputFileSystem} fs input file system + * @param {(err: null | Error, newContentRecursive: NewContentCreateContextMap) => void} callback callback + */ + this.newContentCreateContextMap = (fs, callback) => { + callback( + null, + /** @type {NewContentCreateContextMap} */ (newContentRecursive) + ); + }; + } + // new ContextReplacementPlugin(/selector/, './folder', (context) => { /* Logic */ }); + else if ( + typeof newContentResource === "string" && + typeof newContentRecursive === "function" + ) { + this.newContentResource = newContentResource; + this.newContentCreateContextMap = newContentRecursive; + } else { + // new webpack.ContextReplacementPlugin(/selector/, false, /reg-exp/); + if (typeof newContentResource !== "string") { + newContentRegExp = /** @type {RegExp} */ (newContentRecursive); + newContentRecursive = /** @type {boolean} */ (newContentResource); + newContentResource = undefined; + } + // new webpack.ContextReplacementPlugin(/selector/, /de|fr|hu/); + if (typeof newContentRecursive !== "boolean") { + newContentRegExp = /** @type {RegExp} */ (newContentRecursive); + newContentRecursive = undefined; + } + // new webpack.ContextReplacementPlugin(/selector/, './folder', false, /selector/); + this.newContentResource = + /** @type {string | undefined} */ + (newContentResource); + this.newContentRecursive = + /** @type {boolean | undefined} */ + (newContentRecursive); + this.newContentRegExp = + /** @type {RegExp | undefined} */ + (newContentRegExp); + } + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const resourceRegExp = this.resourceRegExp; + const newContentCallback = this.newContentCallback; + const newContentResource = this.newContentResource; + const newContentRecursive = this.newContentRecursive; + const newContentRegExp = this.newContentRegExp; + const newContentCreateContextMap = this.newContentCreateContextMap; + + compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => { + cmf.hooks.beforeResolve.tap(PLUGIN_NAME, (result) => { + if (!result) return; + if (resourceRegExp.test(result.request)) { + if (newContentResource !== undefined) { + result.request = newContentResource; + } + if (newContentRecursive !== undefined) { + result.recursive = newContentRecursive; + } + if (newContentRegExp !== undefined) { + result.regExp = newContentRegExp; + } + if (typeof newContentCallback === "function") { + newContentCallback(result); + } else { + for (const d of result.dependencies) { + if (d.critical) d.critical = false; + } + } + } + return result; + }); + cmf.hooks.afterResolve.tap(PLUGIN_NAME, (result) => { + if (!result) return; + const isMatchResourceRegExp = () => { + if (Array.isArray(result.resource)) { + return result.resource.some((item) => resourceRegExp.test(item)); + } + + return resourceRegExp.test(result.resource); + }; + if (isMatchResourceRegExp()) { + if (newContentResource !== undefined) { + if ( + newContentResource.startsWith("/") || + (newContentResource.length > 1 && newContentResource[1] === ":") + ) { + result.resource = newContentResource; + } else { + const rootPath = + typeof result.resource === "string" + ? result.resource + : /** @type {string} */ + (result.resource.find((item) => resourceRegExp.test(item))); + result.resource = join( + /** @type {InputFileSystem} */ + (compiler.inputFileSystem), + rootPath, + newContentResource + ); + } + } + if (newContentRecursive !== undefined) { + result.recursive = newContentRecursive; + } + if (newContentRegExp !== undefined) { + result.regExp = newContentRegExp; + } + if (typeof newContentCreateContextMap === "function") { + result.resolveDependencies = + createResolveDependenciesFromContextMap( + newContentCreateContextMap + ); + } + if (typeof newContentCallback === "function") { + const origResource = result.resource; + newContentCallback(result); + if (result.resource !== origResource) { + const newResource = Array.isArray(result.resource) + ? result.resource + : [result.resource]; + + for (let i = 0; i < newResource.length; i++) { + if ( + !newResource[i].startsWith("/") && + (newResource[i].length <= 1 || newResource[i][1] !== ":") + ) { + // When the function changed it to an relative path + newResource[i] = join( + /** @type {InputFileSystem} */ + (compiler.inputFileSystem), + origResource[i], + newResource[i] + ); + } + } + + result.resource = newResource; + } + } else { + for (const d of result.dependencies) { + if (d.critical) d.critical = false; + } + } + } + return result; + }); + }); + } +} + +/** + * Creates a resolve dependencies from context map. + * @param {(fs: InputFileSystem, callback: (err: null | Error, map: NewContentCreateContextMap) => void) => void} createContextMap create context map function + * @returns {(fs: InputFileSystem, options: ContextModuleOptions, callback: (err: null | Error, dependencies?: ContextElementDependency[]) => void) => void} resolve resolve dependencies from context map function + */ +const createResolveDependenciesFromContextMap = + (createContextMap) => (fs, options, callback) => { + createContextMap(fs, (err, map) => { + if (err) return callback(err); + const dependencies = Object.keys(map).map( + (key) => + new ContextElementDependency( + map[key] + options.resourceQuery + options.resourceFragment, + key, + options.typePrefix, + /** @type {string} */ + (options.category), + options.referencedExports + ) + ); + callback(null, dependencies); + }); + }; + +module.exports = ContextReplacementPlugin; Index: frontend/node_modules/webpack/lib/DefinePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/DefinePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/DefinePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,891 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { SyncWaterfallHook } = require("tapable"); +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const ConstDependency = require("./dependencies/ConstDependency"); +const WebpackError = require("./errors/WebpackError"); +const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression"); +const { VariableInfo } = require("./javascript/JavascriptParser"); +const { + evaluateToString, + toConstantDependency +} = require("./javascript/JavascriptParserHelpers"); +const createHash = require("./util/createHash"); + +/** @typedef {import("estree").Expression} Expression */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./Module").ValueCacheVersion} ValueCacheVersion */ +/** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */ +/** @typedef {import("./NormalModule")} NormalModule */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ +/** @typedef {import("./logging/Logger").Logger} Logger */ +/** @typedef {import("./Compilation")} Compilation */ + +/** @typedef {null | undefined | RegExp | EXPECTED_FUNCTION | string | number | boolean | bigint | undefined} CodeValuePrimitive */ +/** @typedef {RecursiveArrayOrRecord} CodeValue */ + +/** + * Defines the runtime value options type used by this module. + * @typedef {object} RuntimeValueOptions + * @property {string[]=} fileDependencies + * @property {string[]=} contextDependencies + * @property {string[]=} missingDependencies + * @property {string[]=} buildDependencies + * @property {string | (() => string)=} version + */ + +/** @typedef {(value: { module: NormalModule, key: string, readonly version: ValueCacheVersion }) => CodeValuePrimitive} GeneratorFn */ + +class RuntimeValue { + /** + * Creates an instance of RuntimeValue. + * @param {GeneratorFn} fn generator function + * @param {true | string[] | RuntimeValueOptions=} options options + */ + constructor(fn, options) { + /** @type {GeneratorFn} */ + this.fn = fn; + if (Array.isArray(options)) { + options = { + fileDependencies: options + }; + } + /** @type {true | RuntimeValueOptions} */ + this.options = options || {}; + } + + get fileDependencies() { + return this.options === true ? true : this.options.fileDependencies; + } + + /** + * Returns code. + * @param {JavascriptParser} parser the parser + * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions + * @param {string} key the defined key + * @returns {CodeValuePrimitive} code + */ + exec(parser, valueCacheVersions, key) { + const buildInfo = /** @type {BuildInfo} */ (parser.state.module.buildInfo); + if (this.options === true) { + buildInfo.cacheable = false; + } else { + if (this.options.fileDependencies) { + for (const dep of this.options.fileDependencies) { + /** @type {NonNullable} */ + (buildInfo.fileDependencies).add(dep); + } + } + if (this.options.contextDependencies) { + for (const dep of this.options.contextDependencies) { + /** @type {NonNullable} */ + (buildInfo.contextDependencies).add(dep); + } + } + if (this.options.missingDependencies) { + for (const dep of this.options.missingDependencies) { + /** @type {NonNullable} */ + (buildInfo.missingDependencies).add(dep); + } + } + if (this.options.buildDependencies) { + for (const dep of this.options.buildDependencies) { + /** @type {NonNullable} */ + (buildInfo.buildDependencies).add(dep); + } + } + } + + return this.fn({ + module: parser.state.module, + key, + get version() { + return /** @type {ValueCacheVersion} */ ( + valueCacheVersions.get(VALUE_DEP_PREFIX + key) + ); + } + }); + } + + getCacheVersion() { + return this.options === true + ? undefined + : (typeof this.options.version === "function" + ? this.options.version() + : this.options.version) || "unset"; + } +} + +/** + * Returns used keys. + * @param {DestructuringAssignmentProperties | undefined} properties properties + * @returns {Set | undefined} used keys + */ +function getObjKeys(properties) { + if (!properties) return; + return new Set([...properties].map((p) => p.id)); +} + +/** @typedef {Set | null} ObjKeys */ +/** @typedef {boolean | undefined | null} AsiSafe */ + +/** + * Returns code converted to string that evaluates. + * @param {EXPECTED_ANY[] | { [k: string]: EXPECTED_ANY }} obj obj + * @param {JavascriptParser} parser Parser + * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions + * @param {string} key the defined key + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @param {Logger} logger the logger object + * @param {AsiSafe=} asiSafe asi safe (undefined: unknown, null: unneeded) + * @param {ObjKeys=} objKeys used keys + * @returns {string} code converted to string that evaluates + */ +const stringifyObj = ( + obj, + parser, + valueCacheVersions, + key, + runtimeTemplate, + logger, + asiSafe, + objKeys +) => { + /** @type {string} */ + let code; + const arr = Array.isArray(obj); + if (arr) { + code = `[${obj + .map((code) => + toCode( + code, + parser, + valueCacheVersions, + key, + runtimeTemplate, + logger, + null + ) + ) + .join(",")}]`; + } else { + let keys = Object.keys(obj); + if (objKeys) { + keys = objKeys.size === 0 ? [] : keys.filter((k) => objKeys.has(k)); + } + code = `{${keys + .map((key) => { + const code = obj[key]; + return `${key === "__proto__" ? '["__proto__"]' : JSON.stringify(key)}:${toCode( + code, + parser, + valueCacheVersions, + key, + runtimeTemplate, + logger, + null + )}`; + }) + .join(",")}}`; + } + + switch (asiSafe) { + case null: + return code; + case true: + return arr ? code : `(${code})`; + case false: + return arr ? `;${code}` : `;(${code})`; + default: + return `/*#__PURE__*/Object(${code})`; + } +}; + +/** + * Convert code to a string that evaluates + * @param {CodeValue} code Code to evaluate + * @param {JavascriptParser} parser Parser + * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions + * @param {string} key the defined key + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @param {Logger} logger the logger object + * @param {boolean | undefined | null=} asiSafe asi safe (undefined: unknown, null: unneeded) + * @param {ObjKeys=} objKeys used keys + * @returns {string} code converted to string that evaluates + */ +const toCode = ( + code, + parser, + valueCacheVersions, + key, + runtimeTemplate, + logger, + asiSafe, + objKeys +) => { + const transformToCode = () => { + if (code === null) { + return "null"; + } + if (code === undefined) { + return "undefined"; + } + if (Object.is(code, -0)) { + return "-0"; + } + if (code instanceof RuntimeValue) { + return toCode( + code.exec(parser, valueCacheVersions, key), + parser, + valueCacheVersions, + key, + runtimeTemplate, + logger, + asiSafe + ); + } + if (code instanceof RegExp && code.toString) { + return code.toString(); + } + if (typeof code === "function" && code.toString) { + return `(${code.toString()})`; + } + if (typeof code === "object") { + return stringifyObj( + code, + parser, + valueCacheVersions, + key, + runtimeTemplate, + logger, + asiSafe, + objKeys + ); + } + if (typeof code === "bigint") { + return runtimeTemplate.supportsBigIntLiteral() + ? `${code}n` + : `BigInt("${code}")`; + } + return `${code}`; + }; + + const strCode = transformToCode(); + + logger.debug(`Replaced "${key}" with "${strCode}"`); + + return strCode; +}; + +/** + * Returns result. + * @param {CodeValue} code code + * @returns {string | undefined} result + */ +const toCacheVersion = (code) => { + if (code === null) { + return "null"; + } + if (code === undefined) { + return "undefined"; + } + if (Object.is(code, -0)) { + return "-0"; + } + if (code instanceof RuntimeValue) { + return code.getCacheVersion(); + } + if (code instanceof RegExp && code.toString) { + return code.toString(); + } + if (typeof code === "function" && code.toString) { + return `(${code.toString()})`; + } + if (typeof code === "object") { + const items = Object.keys(code).map((key) => ({ + key, + value: toCacheVersion( + /** @type {Record} */ + (code)[key] + ) + })); + if (items.some(({ value }) => value === undefined)) return; + return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`; + } + if (typeof code === "bigint") { + return `${code}n`; + } + return `${code}`; +}; + +const PLUGIN_NAME = "DefinePlugin"; +const VALUE_DEP_PREFIX = `webpack/${PLUGIN_NAME} `; +const VALUE_DEP_MAIN = `webpack/${PLUGIN_NAME}_hash`; +const TYPEOF_OPERATOR_REGEXP = /^typeof\s+/; +const WEBPACK_REQUIRE_FUNCTION_REGEXP = new RegExp( + `${RuntimeGlobals.require}\\s*(!?\\.)` +); +const WEBPACK_REQUIRE_IDENTIFIER_REGEXP = new RegExp(RuntimeGlobals.require); + +/** + * Defines the define plugin hooks type used by this module. + * @typedef {object} DefinePluginHooks + * @property {SyncWaterfallHook<[Record]>} definitions + */ + +/** @typedef {Record} Definitions */ + +/** @type {WeakMap} */ +const compilationHooksMap = new WeakMap(); + +class DefinePlugin { + /** + * Returns the attached hooks. + * @param {Compilation} compilation the compilation + * @returns {DefinePluginHooks} the attached hooks + */ + static getCompilationHooks(compilation) { + let hooks = compilationHooksMap.get(compilation); + if (hooks === undefined) { + hooks = { + definitions: new SyncWaterfallHook(["definitions"]) + }; + compilationHooksMap.set(compilation, hooks); + } + return hooks; + } + + /** + * Create a new define plugin + * @param {Definitions} definitions A map of global object definitions + */ + constructor(definitions) { + /** @type {Definitions} */ + this.definitions = definitions; + } + + /** + * Returns runtime value. + * @param {GeneratorFn} fn generator function + * @param {true | string[] | RuntimeValueOptions=} options options + * @returns {RuntimeValue} runtime value + */ + static runtimeValue(fn, options) { + return new RuntimeValue(fn, options); + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + const definitions = this.definitions; + const hooks = DefinePlugin.getCompilationHooks(compilation); + + hooks.definitions.tap(PLUGIN_NAME, (previousDefinitions) => ({ + ...previousDefinitions, + ...definitions + })); + + /** + * @type {Map>} + */ + const finalByNestedKey = new Map(); + /** + * @type {Map>} + */ + const nestedByFinalKey = new Map(); + + const logger = compilation.getLogger("webpack.DefinePlugin"); + compilation.dependencyTemplates.set( + ConstDependency, + new ConstDependency.Template() + ); + const { runtimeTemplate } = compilation; + + const mainHash = createHash(compilation.outputOptions.hashFunction); + mainHash.update( + /** @type {string} */ + (compilation.valueCacheVersions.get(VALUE_DEP_MAIN)) || "" + ); + + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser Parser + * @returns {void} + */ + const handler = (parser) => { + /** @type {Set} */ + const hooked = new Set(); + const mainValue = + /** @type {ValueCacheVersion} */ + (compilation.valueCacheVersions.get(VALUE_DEP_MAIN)); + parser.hooks.program.tap(PLUGIN_NAME, () => { + const buildInfo = /** @type {BuildInfo} */ ( + parser.state.module.buildInfo + ); + if (!buildInfo.valueDependencies) { + buildInfo.valueDependencies = new Map(); + } + buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue); + }); + + /** + * Adds value dependency. + * @param {string} key key + */ + const addValueDependency = (key) => { + const buildInfo = + /** @type {BuildInfo} */ + (parser.state.module.buildInfo); + /** @type {NonNullable} */ + (buildInfo.valueDependencies).set( + VALUE_DEP_PREFIX + key, + /** @type {ValueCacheVersion} */ + (compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key)) + ); + }; + + /** + * With value dependency. + * @template T + * @param {string} key key + * @param {(expression: Expression) => T} fn fn + * @returns {(expression: Expression) => T} result + */ + const withValueDependency = + (key, fn) => + (...args) => { + addValueDependency(key); + return fn(...args); + }; + + /** + * Processes the provided definition. + * @param {Definitions} definitions Definitions map + * @param {string} prefix Prefix string + * @returns {void} + */ + const walkDefinitions = (definitions, prefix) => { + for (const key of Object.keys(definitions)) { + const code = definitions[key]; + if ( + code && + typeof code === "object" && + !(code instanceof RuntimeValue) && + !(code instanceof RegExp) + ) { + walkDefinitions( + /** @type {Definitions} */ (code), + `${prefix + key}.` + ); + applyObjectDefine(prefix + key, code); + continue; + } + applyDefineKey(prefix, key); + applyDefine(prefix + key, code); + } + }; + + /** + * Processes the provided prefix. + * @param {string} prefix Prefix + * @param {string} key Key + * @returns {void} + */ + const applyDefineKey = (prefix, key) => { + const splittedKey = key.split("."); + const firstKey = splittedKey[0]; + for (const [i, _] of splittedKey.slice(1).entries()) { + const fullKey = prefix + splittedKey.slice(0, i + 1).join("."); + parser.hooks.canRename.for(fullKey).tap(PLUGIN_NAME, () => { + addValueDependency(key); + if ( + parser.scope.definitions.get(firstKey) instanceof VariableInfo + ) { + return false; + } + return true; + }); + } + if (prefix === "") { + const final = splittedKey[splittedKey.length - 1]; + const nestedSet = nestedByFinalKey.get(final); + if (!nestedSet || nestedSet.size <= 0) return; + for (const nested of /** @type {Set} */ (nestedSet)) { + if (nested && !hooked.has(nested)) { + // only detect the same nested key once + hooked.add(nested); + parser.hooks.collectDestructuringAssignmentProperties.tap( + PLUGIN_NAME, + (expr) => { + const nameInfo = parser.getNameForExpression(expr); + if (nameInfo && nameInfo.name === nested) return true; + } + ); + parser.hooks.expression.for(nested).tap( + { + name: PLUGIN_NAME, + // why 100? Ensures it runs after object define + stage: 100 + }, + (expr) => { + const destructed = + parser.destructuringAssignmentPropertiesFor(expr); + if (destructed === undefined) { + return; + } + /** @type {Definitions} */ + const obj = Object.create(null); + const finalSet = finalByNestedKey.get(nested); + for (const { id } of destructed) { + const fullKey = `${nested}.${id}`; + if ( + !finalSet || + !finalSet.has(id) || + !definitions[fullKey] + ) { + return; + } + obj[id] = definitions[fullKey]; + } + let strCode = stringifyObj( + obj, + parser, + compilation.valueCacheVersions, + key, + runtimeTemplate, + logger, + !parser.isAsiPosition( + /** @type {Range} */ (expr.range)[0] + ), + getObjKeys(destructed) + ); + if (parser.scope.inShorthand) { + strCode = `${parser.scope.inShorthand}:${strCode}`; + } + return toConstantDependency(parser, strCode)(expr); + } + ); + } + } + } + }; + + /** + * Processes the provided key. + * @param {string} key Key + * @param {CodeValue} code Code + * @returns {void} + */ + const applyDefine = (key, code) => { + const originalKey = key; + const isTypeof = TYPEOF_OPERATOR_REGEXP.test(key); + if (isTypeof) key = key.replace(TYPEOF_OPERATOR_REGEXP, ""); + let recurse = false; + let recurseTypeof = false; + if (!isTypeof) { + parser.hooks.canRename.for(key).tap(PLUGIN_NAME, () => { + addValueDependency(originalKey); + return true; + }); + parser.hooks.evaluateIdentifier + .for(key) + .tap(PLUGIN_NAME, (expr) => { + /** + * this is needed in case there is a recursion in the DefinePlugin + * to prevent an endless recursion + * e.g.: new DefinePlugin({ + * "a": "b", + * "b": "a" + * }); + */ + if (recurse) return; + addValueDependency(originalKey); + recurse = true; + const res = parser.evaluate( + toCode( + code, + parser, + compilation.valueCacheVersions, + key, + runtimeTemplate, + logger, + null + ) + ); + recurse = false; + res.setRange(/** @type {Range} */ (expr.range)); + return res; + }); + parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expr) => { + addValueDependency(originalKey); + let strCode = toCode( + code, + parser, + compilation.valueCacheVersions, + originalKey, + runtimeTemplate, + logger, + !parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]), + null + ); + + if (parser.scope.inShorthand) { + strCode = `${parser.scope.inShorthand}:${strCode}`; + } + + if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) { + return toConstantDependency(parser, strCode, [ + RuntimeGlobals.require + ])(expr); + } else if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) { + return toConstantDependency(parser, strCode, [ + RuntimeGlobals.requireScope + ])(expr); + } + return toConstantDependency(parser, strCode)(expr); + }); + } + parser.hooks.evaluateTypeof.for(key).tap(PLUGIN_NAME, (expr) => { + /** + * this is needed in case there is a recursion in the DefinePlugin + * to prevent an endless recursion + * e.g.: new DefinePlugin({ + * "typeof a": "typeof b", + * "typeof b": "typeof a" + * }); + */ + if (recurseTypeof) return; + recurseTypeof = true; + addValueDependency(originalKey); + const codeCode = toCode( + code, + parser, + compilation.valueCacheVersions, + originalKey, + runtimeTemplate, + logger, + null + ); + const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`; + const res = parser.evaluate(typeofCode); + recurseTypeof = false; + res.setRange(/** @type {Range} */ (expr.range)); + return res; + }); + parser.hooks.typeof.for(key).tap(PLUGIN_NAME, (expr) => { + addValueDependency(originalKey); + const codeCode = toCode( + code, + parser, + compilation.valueCacheVersions, + originalKey, + runtimeTemplate, + logger, + null + ); + const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`; + const res = parser.evaluate(typeofCode); + if (!res.isString()) return; + return toConstantDependency( + parser, + JSON.stringify(res.string) + ).bind(parser)(expr); + }); + }; + + /** + * Processes the provided key. + * @param {string} key Key + * @param {object} obj Object + * @returns {void} + */ + const applyObjectDefine = (key, obj) => { + parser.hooks.canRename.for(key).tap(PLUGIN_NAME, () => { + addValueDependency(key); + return true; + }); + parser.hooks.evaluateIdentifier + .for(key) + .tap(PLUGIN_NAME, (expr) => { + addValueDependency(key); + return new BasicEvaluatedExpression() + .setTruthy() + .setSideEffects(false) + .setRange(/** @type {Range} */ (expr.range)); + }); + parser.hooks.evaluateTypeof + .for(key) + .tap( + PLUGIN_NAME, + withValueDependency(key, evaluateToString("object")) + ); + parser.hooks.collectDestructuringAssignmentProperties.tap( + PLUGIN_NAME, + (expr) => { + const nameInfo = parser.getNameForExpression(expr); + if (nameInfo && nameInfo.name === key) return true; + } + ); + parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expr) => { + addValueDependency(key); + let strCode = stringifyObj( + obj, + parser, + compilation.valueCacheVersions, + key, + runtimeTemplate, + logger, + !parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]), + getObjKeys(parser.destructuringAssignmentPropertiesFor(expr)) + ); + + if (parser.scope.inShorthand) { + strCode = `${parser.scope.inShorthand}:${strCode}`; + } + + if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) { + return toConstantDependency(parser, strCode, [ + RuntimeGlobals.require + ])(expr); + } else if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) { + return toConstantDependency(parser, strCode, [ + RuntimeGlobals.requireScope + ])(expr); + } + return toConstantDependency(parser, strCode)(expr); + }); + parser.hooks.typeof + .for(key) + .tap( + PLUGIN_NAME, + withValueDependency( + key, + toConstantDependency(parser, JSON.stringify("object")) + ) + ); + }; + + walkDefinitions(definitions, ""); + }; + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + + /** + * Processes the provided definition. + * @param {Definitions} definitions Definitions map + * @param {string} prefix Prefix string + * @returns {void} + */ + const walkDefinitionsForValues = (definitions, prefix) => { + for (const key of Object.keys(definitions)) { + const code = definitions[key]; + const version = /** @type {string} */ (toCacheVersion(code)); + const name = VALUE_DEP_PREFIX + prefix + key; + mainHash.update(`|${prefix}${key}`); + const oldVersion = compilation.valueCacheVersions.get(name); + if (oldVersion === undefined) { + compilation.valueCacheVersions.set(name, version); + } else if (oldVersion !== version) { + const warning = new WebpackError( + `${PLUGIN_NAME}\nConflicting values for '${prefix + key}'` + ); + warning.details = `'${oldVersion}' !== '${version}'`; + warning.hideStack = true; + compilation.warnings.push(warning); + } + if ( + code && + typeof code === "object" && + !(code instanceof RuntimeValue) && + !(code instanceof RegExp) + ) { + walkDefinitionsForValues( + /** @type {Definitions} */ (code), + `${prefix + key}.` + ); + } + } + }; + + /** + * Walk definitions for keys. + * @param {Definitions} definitions Definitions map + * @returns {void} + */ + const walkDefinitionsForKeys = (definitions) => { + /** + * Adds the provided map to the define plugin. + * @param {Map>} map Map + * @param {string} key key + * @param {string} value v + * @returns {void} + */ + const addToMap = (map, key, value) => { + if (map.has(key)) { + /** @type {Set} */ + (map.get(key)).add(value); + } else { + map.set(key, new Set([value])); + } + }; + for (const key of Object.keys(definitions)) { + const code = definitions[key]; + if ( + !code || + typeof code === "object" || + TYPEOF_OPERATOR_REGEXP.test(key) + ) { + continue; + } + const idx = key.lastIndexOf("."); + if (idx <= 0 || idx >= key.length - 1) { + continue; + } + const nested = key.slice(0, idx); + const final = key.slice(idx + 1); + addToMap(finalByNestedKey, nested, final); + addToMap(nestedByFinalKey, final, nested); + } + }; + + walkDefinitionsForKeys(definitions); + walkDefinitionsForValues(definitions, ""); + + compilation.valueCacheVersions.set( + VALUE_DEP_MAIN, + mainHash.digest("hex").slice(0, 8) + ); + } + ); + } +} + +module.exports = DefinePlugin; Index: frontend/node_modules/webpack/lib/DependenciesBlock.js =================================================================== --- frontend/node_modules/webpack/lib/DependenciesBlock.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/DependenciesBlock.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,125 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const makeSerializable = require("./util/makeSerializable"); + +/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ + +/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */ + +/** + * DependenciesBlock is the base class for all Module classes in webpack. It describes a + * "block" of dependencies which are pointers to other DependenciesBlock instances. For example + * when a Module has a CommonJs require statement, the DependencyBlock for the CommonJs module + * would be added as a dependency to the Module. DependenciesBlock is inherited by two types of classes: + * Module subclasses and AsyncDependenciesBlock subclasses. The only difference between the two is that + * AsyncDependenciesBlock subclasses are used for code-splitting (async boundary) and Module subclasses are not. + */ +class DependenciesBlock { + constructor() { + /** @type {Dependency[]} */ + this.dependencies = []; + /** @type {AsyncDependenciesBlock[]} */ + this.blocks = []; + /** @type {DependenciesBlock | undefined} */ + this.parent = undefined; + } + + getRootBlock() { + /** @type {DependenciesBlock} */ + let current = this; + while (current.parent) current = current.parent; + return current; + } + + /** + * Adds a DependencyBlock to DependencyBlock relationship. + * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting) + * @param {AsyncDependenciesBlock} block block being added + * @returns {void} + */ + addBlock(block) { + this.blocks.push(block); + block.parent = this; + } + + /** + * Adds the provided dependency to the dependencies block. + * @param {Dependency} dependency dependency being tied to block. + * This is an "edge" pointing to another "node" on module graph. + * @returns {void} + */ + addDependency(dependency) { + this.dependencies.push(dependency); + } + + /** + * Removes dependency. + * @param {Dependency} dependency dependency being removed + * @returns {void} + */ + removeDependency(dependency) { + const idx = this.dependencies.indexOf(dependency); + if (idx >= 0) { + this.dependencies.splice(idx, 1); + } + } + + /** + * Clear dependencies and blocks. + * @returns {void} + */ + clearDependenciesAndBlocks() { + this.dependencies.length = 0; + this.blocks.length = 0; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) { + for (const dep of this.dependencies) { + dep.updateHash(hash, context); + } + for (const block of this.blocks) { + block.updateHash(hash, context); + } + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize({ write }) { + write(this.dependencies); + write(this.blocks); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize({ read }) { + this.dependencies = read(); + this.blocks = read(); + for (const block of this.blocks) { + block.parent = this; + } + } +} + +makeSerializable(DependenciesBlock, "webpack/lib/DependenciesBlock"); + +module.exports = DependenciesBlock; Index: frontend/node_modules/webpack/lib/Dependency.js =================================================================== --- frontend/node_modules/webpack/lib/Dependency.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Dependency.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,434 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const memoize = require("./util/memoize"); + +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./DependenciesBlock")} DependenciesBlock */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */ +/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("./errors/WebpackError")} WebpackError */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ +/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */ +/** + * Defines the update hash context type used by this module. + * @typedef {object} UpdateHashContext + * @property {ChunkGraph} chunkGraph + * @property {RuntimeSpec} runtime + * @property {RuntimeTemplate=} runtimeTemplate + */ + +/** + * Defines the source position type used by this module. + * @typedef {object} SourcePosition + * @property {number} line + * @property {number=} column + */ + +/** + * Defines the real dependency location type used by this module. + * @typedef {object} RealDependencyLocation + * @property {SourcePosition} start + * @property {SourcePosition=} end + * @property {number=} index + */ + +/** + * Defines the synthetic dependency location type used by this module. + * @typedef {object} SyntheticDependencyLocation + * @property {string} name + * @property {number=} index + */ + +/** @typedef {SyntheticDependencyLocation | RealDependencyLocation} DependencyLocation */ + +/** @typedef {string} ExportInfoName */ + +/** + * Defines the export spec type used by this module. + * @typedef {object} ExportSpec + * @property {ExportInfoName} name the name of the export + * @property {boolean=} canMangle can the export be renamed (defaults to true) + * @property {boolean=} terminalBinding is the export a terminal binding that should be checked for export star conflicts + * @property {(string | ExportSpec)[]=} exports nested exports + * @property {ModuleGraphConnection=} from when reexported: from which module + * @property {string[] | null=} export when reexported: from which export + * @property {number=} priority when reexported: with which priority + * @property {boolean=} hidden export is not visible, because another export blends over it + */ + +/** @typedef {Set} ExportsSpecExcludeExports */ + +/** + * Defines the exports spec type used by this module. + * @typedef {object} ExportsSpec + * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports + * @property {ExportsSpecExcludeExports=} excludeExports when exports = true, list of unaffected exports + * @property {(Set | null)=} hideExports list of maybe prior exposed, but now hidden exports + * @property {ModuleGraphConnection=} from when reexported: from which module + * @property {number=} priority when reexported: with which priority + * @property {boolean=} canMangle can the export be renamed (defaults to true) + * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts + * @property {Module[]=} dependencies module on which the result depends on + */ + +/** + * Defines the referenced export type used by this module. + * @typedef {object} ReferencedExport + * @property {string[]} name name of the referenced export + * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true + */ + +/** @typedef {string[][]} RawReferencedExports */ +/** @typedef {(string[] | ReferencedExport)[]} ReferencedExports */ + +/** @typedef {(moduleGraphConnection: ModuleGraphConnection, runtime: RuntimeSpec) => ConnectionState} GetConditionFn */ + +const TRANSITIVE = /** @type {symbol} */ (Symbol("transitive")); + +const getIgnoredModule = memoize(() => { + const RawModule = require("./RawModule"); + + const module = new RawModule("/* (ignored) */", "ignored", "(ignored)"); + module.factoryMeta = { sideEffectFree: true }; + return module; +}); + +class Dependency { + constructor() { + /** @type {Module | undefined} */ + this._parentModule = undefined; + /** @type {DependenciesBlock | undefined} */ + this._parentDependenciesBlock = undefined; + /** @type {number} */ + this._parentDependenciesBlockIndex = -1; + // TODO check if this can be moved into ModuleDependency + /** @type {boolean} */ + this.weak = false; + // TODO check if this can be moved into ModuleDependency + /** @type {boolean | undefined} */ + this.optional = false; + this._locSL = 0; + this._locSC = 0; + this._locEL = 0; + this._locEC = 0; + /** @type {undefined | number} */ + this._locI = undefined; + /** @type {undefined | string} */ + this._locN = undefined; + /** @type {undefined | DependencyLocation} */ + this._loc = undefined; + } + + /** + * Returns a display name for the type of dependency. + * @returns {string} a display name for the type of dependency + */ + get type() { + return "unknown"; + } + + /** + * Returns a dependency category, typical categories are "commonjs", "amd", "esm". + * @returns {string} a dependency category, typical categories are "commonjs", "amd", "esm" + */ + get category() { + return "unknown"; + } + + /** + * Returns location. + * @returns {DependencyLocation} location + */ + get loc() { + if (this._loc !== undefined) return this._loc; + + /** @type {SyntheticDependencyLocation & RealDependencyLocation} */ + const loc = {}; + + if (this._locSL > 0) { + loc.start = { line: this._locSL, column: this._locSC }; + } + if (this._locEL > 0) { + loc.end = { line: this._locEL, column: this._locEC }; + } + if (this._locN !== undefined) { + loc.name = this._locN; + } + if (this._locI !== undefined) { + loc.index = this._locI; + } + + return (this._loc = loc); + } + + set loc(loc) { + if ("start" in loc && typeof loc.start === "object") { + this._locSL = loc.start.line || 0; + this._locSC = loc.start.column || 0; + } else { + this._locSL = 0; + this._locSC = 0; + } + if ("end" in loc && typeof loc.end === "object") { + this._locEL = loc.end.line || 0; + this._locEC = loc.end.column || 0; + } else { + this._locEL = 0; + this._locEC = 0; + } + this._locI = "index" in loc ? loc.index : undefined; + this._locN = "name" in loc ? loc.name : undefined; + this._loc = loc; + } + + /** + * Updates loc using the provided start line. + * @param {number} startLine start line + * @param {number} startColumn start column + * @param {number} endLine end line + * @param {number} endColumn end column + */ + setLoc(startLine, startColumn, endLine, endColumn) { + this._locSL = startLine; + this._locSC = startColumn; + this._locEL = endLine; + this._locEC = endColumn; + this._locI = undefined; + this._locN = undefined; + this._loc = undefined; + } + + /** + * Returns a request context. + * @returns {string | undefined} a request context + */ + getContext() { + return undefined; + } + + /** + * Returns an identifier to merge equal requests. + * @returns {string | null} an identifier to merge equal requests + */ + getResourceIdentifier() { + return null; + } + + /** + * Could affect referencing module. + * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module + */ + couldAffectReferencingModule() { + return TRANSITIVE; + } + + /** + * Returns the referenced module and export + * @deprecated + * @param {ModuleGraph} moduleGraph module graph + * @returns {never} throws error + */ + getReference(moduleGraph) { + throw new Error( + "Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule, ModuleGraph.getConnection(), and ModuleGraphConnection.getActiveState(runtime)" + ); + } + + /** + * Returns list of exports referenced by this dependency + * @param {ModuleGraph} moduleGraph module graph + * @param {RuntimeSpec} runtime the runtime for which the module is analysed + * @returns {ReferencedExports} referenced exports + */ + getReferencedExports(moduleGraph, runtime) { + return Dependency.EXPORTS_OBJECT_REFERENCED; + } + + /** + * Returns function to determine if the connection is active. + * @param {ModuleGraph} moduleGraph module graph + * @returns {null | false | GetConditionFn} function to determine if the connection is active + */ + getCondition(moduleGraph) { + return null; + } + + /** + * Returns the exported names + * @param {ModuleGraph} moduleGraph module graph + * @returns {ExportsSpec | undefined} export names + */ + getExports(moduleGraph) { + return undefined; + } + + /** + * Returns warnings. + * @param {ModuleGraph} moduleGraph module graph + * @returns {WebpackError[] | null | undefined} warnings + */ + getWarnings(moduleGraph) { + return null; + } + + /** + * Returns errors. + * @param {ModuleGraph} moduleGraph module graph + * @returns {WebpackError[] | null | undefined} errors + */ + getErrors(moduleGraph) { + return null; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash hash to be updated + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) {} + + /** + * implement this method to allow the occurrence order plugin to count correctly + * @returns {number} count how often the id is used in this dependency + */ + getNumberOfIdOccurrences() { + return 1; + } + + /** + * Gets module evaluation side effects state. + * @param {ModuleGraph} moduleGraph the module graph + * @returns {ConnectionState} how this dependency connects the module to referencing modules + */ + getModuleEvaluationSideEffectsState(moduleGraph) { + return true; + } + + /** + * Creates an ignored module. + * @param {string} context context directory + * @returns {Module} ignored module + */ + createIgnoredModule(context) { + return getIgnoredModule(); + } + + /** + * Returns true if this dependency can be concatenated + * @returns {boolean} true if this dependency can be concatenated + */ + canConcatenate() { + return false; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize({ write }) { + write(this.weak); + write(this.optional); + write(this._locSL); + write(this._locSC); + write(this._locEL); + write(this._locEC); + write(this._locI); + write(this._locN); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize({ read }) { + this.weak = read(); + this.optional = read(); + this._locSL = read(); + this._locSC = read(); + this._locEL = read(); + this._locEC = read(); + this._locI = read(); + this._locN = read(); + } +} + +/** @type {RawReferencedExports} */ +Dependency.NO_EXPORTS_REFERENCED = []; +/** @type {RawReferencedExports} */ +Dependency.EXPORTS_OBJECT_REFERENCED = [[]]; + +// TODO remove in webpack 6 +Object.defineProperty(Dependency.prototype, "module", { + /** + * Returns throws. + * @deprecated + * @returns {EXPECTED_ANY} throws + */ + get() { + throw new Error( + "module property was removed from Dependency (use compilation.moduleGraph.getModule(dependency) instead)" + ); + }, + + /** + * Updates module. + * @deprecated + * @returns {never} throws + */ + set() { + throw new Error( + "module property was removed from Dependency (use compilation.moduleGraph.updateModule(dependency, module) instead)" + ); + } +}); + +/** + * Returns true if the dependency is a low priority dependency. + * @param {Dependency} dependency dep + * @returns {boolean} true if the dependency is a low priority dependency + */ +Dependency.isLowPriorityDependency = (dependency) => + /** @type {ModuleDependency} */ (dependency).sourceOrder === Infinity; + +// TODO in webpack 6, call canConcatenate() directly on the dependency instance instead of using this static method. +/** + * Returns true if the dependency can be concatenated (scope hoisting). + * @param {Dependency} dependency dep + * @returns {boolean} true if this dependency supports concatenation + */ +Dependency.canConcatenate = (dependency) => { + if (typeof dependency.canConcatenate === "function") { + return dependency.canConcatenate(); + } + return false; +}; + +// TODO remove in webpack 6 +Object.defineProperty(Dependency.prototype, "disconnect", { + /** + * Returns throws. + * @deprecated + * @returns {EXPECTED_ANY} throws + */ + get() { + throw new Error( + "disconnect was removed from Dependency (Dependency no longer carries graph specific information)" + ); + } +}); + +Dependency.TRANSITIVE = TRANSITIVE; + +module.exports = Dependency; Index: frontend/node_modules/webpack/lib/DependencyTemplate.js =================================================================== --- frontend/node_modules/webpack/lib/DependencyTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/DependencyTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,77 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */ +/** @typedef {import("./ConcatenationScope")} ConcatenationScope */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */ +/** @typedef {import("./DependencyTemplates")} DependencyTemplates */ +/** @typedef {import("./Generator").GenerateContext} GenerateContext */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ + +/** + * Defines the init fragment type used by this module. + * @template T + * @typedef {import("./InitFragment")} InitFragment + */ + +/** + * Defines the dependency template context type used by this module. + * @typedef {object} DependencyTemplateContext + * @property {RuntimeTemplate} runtimeTemplate the runtime template + * @property {DependencyTemplates} dependencyTemplates the dependency templates + * @property {ModuleGraph} moduleGraph the module graph + * @property {ChunkGraph} chunkGraph the chunk graph + * @property {RuntimeRequirements} runtimeRequirements the requirements for runtime + * @property {Module} module current module + * @property {RuntimeSpec} runtime current runtimes, for which code is generated + * @property {InitFragment[]} initFragments mutable array of init fragments for the current module + * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules + * @property {CodeGenerationResults} codeGenerationResults the code generation results + * @property {InitFragment[]} chunkInitFragments chunkInitFragments + */ + +/** + * Defines the css dependency template context extras type used by this module. + * @typedef {object} CssDependencyTemplateContextExtras + * @property {CssData} cssData the css exports data + * @property {string} type the css exports data + */ + +/** + * Defines the css data type used by this module. + * @typedef {object} CssData + * @property {boolean} esModule whether export __esModule + * @property {Map} exports the css exports + * @property {Map=} exportLocs source position (line is 1-based, column is 0-based) of each export's defining identifier in the original CSS, used to emit fine-grained JS-to-CSS source mappings + */ + +/** @typedef {DependencyTemplateContext & CssDependencyTemplateContextExtras} CssDependencyTemplateContext */ + +class DependencyTemplate { + /* istanbul ignore next */ + /** + * Applies the plugin by registering its hooks on the compiler. + * @abstract + * @param {Dependency} dependency the dependency for which the template should be applied + * @param {ReplaceSource} source the current replace source which can be modified + * @param {DependencyTemplateContext} templateContext the context object + * @returns {void} + */ + apply(dependency, source, templateContext) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } +} + +module.exports = DependencyTemplate; Index: frontend/node_modules/webpack/lib/DependencyTemplates.js =================================================================== --- frontend/node_modules/webpack/lib/DependencyTemplates.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/DependencyTemplates.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,71 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { DEFAULTS } = require("./config/defaults"); +const createHash = require("./util/createHash"); + +/** @typedef {import("./Compilation").DependencyConstructor} DependencyConstructor */ +/** @typedef {import("./DependencyTemplate")} DependencyTemplate */ +/** @typedef {import("./util/Hash").HashFunction} HashFunction */ + +class DependencyTemplates { + /** + * Creates an instance of DependencyTemplates. + * @param {HashFunction} hashFunction the hash function to use + */ + constructor(hashFunction = DEFAULTS.HASH_FUNCTION) { + /** @type {Map} */ + this._map = new Map(); + /** @type {string} */ + this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0"; + /** @type {HashFunction} */ + this._hashFunction = hashFunction; + } + + /** + * Returns template for this dependency. + * @param {DependencyConstructor} dependency Constructor of Dependency + * @returns {DependencyTemplate | undefined} template for this dependency + */ + get(dependency) { + return this._map.get(dependency); + } + + /** + * Updates value using the provided dependency. + * @param {DependencyConstructor} dependency Constructor of Dependency + * @param {DependencyTemplate} dependencyTemplate template for this dependency + * @returns {void} + */ + set(dependency, dependencyTemplate) { + this._map.set(dependency, dependencyTemplate); + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {string} part additional hash contributor + * @returns {void} + */ + updateHash(part) { + const hash = createHash(this._hashFunction); + hash.update(`${this._hash}${part}`); + this._hash = hash.digest("hex"); + } + + getHash() { + return this._hash; + } + + clone() { + const newInstance = new DependencyTemplates(this._hashFunction); + newInstance._map = new Map(this._map); + newInstance._hash = this._hash; + return newInstance; + } +} + +module.exports = DependencyTemplates; Index: frontend/node_modules/webpack/lib/DotenvPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/DotenvPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/DotenvPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,473 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Natsu @xiaoxiaojx +*/ + +"use strict"; + +const FileSystemInfo = require("./FileSystemInfo"); +const { join } = require("./util/fs"); + +/** @typedef {import("../declarations/WebpackOptions").DotenvPluginOptions} DotenvPluginOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */ + +/** @typedef {Exclude} Prefix */ +/** @typedef {Record} Env */ + +const DEFAULT_TEMPLATE = [ + ".env", + ".env.local", + ".env.[mode]", + ".env.[mode].local" +]; + +// Regex for parsing .env files +// ported from https://github.com/motdotla/dotenv/blob/master/lib/main.js#L49 +const LINE = + /^\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?$/gm; + +const PLUGIN_NAME = "DotenvPlugin"; + +/** + * Parse .env file content + * ported from https://github.com/motdotla/dotenv/blob/master/lib/main.js#L49 + * @param {string | Buffer} src the source content to parse + * @returns {Env} parsed environment variables object + */ +function parse(src) { + const obj = /** @type {Env} */ (Object.create(null)); + + // Convert buffer to string + let lines = src.toString(); + + // Convert line breaks to same format + lines = lines.replace(/\r\n?/g, "\n"); + + /** @type {null | RegExpExecArray} */ + let match; + + while ((match = LINE.exec(lines)) !== null) { + const key = match[1]; + + // Default undefined or null to empty string + let value = match[2] || ""; + + // Remove whitespace + value = value.trim(); + + // Check if double quoted + const maybeQuote = value[0]; + + // Remove surrounding quotes + value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2"); + + // Expand newlines if double quoted + if (maybeQuote === '"') { + value = value.replace(/\\n/g, "\n"); + value = value.replace(/\\r/g, "\r"); + } + + // Add to object + obj[key] = value; + } + + return obj; +} + +/** + * Resolve escape sequences + * ported from https://github.com/motdotla/dotenv-expand + * @param {string} value value to resolve + * @returns {string} resolved value + */ +function _resolveEscapeSequences(value) { + return value.replace(/\\\$/g, "$"); +} + +/** + * Expand environment variable value + * ported from https://github.com/motdotla/dotenv-expand + * @param {string} value value to expand + * @param {Record} processEnv process.env object + * @param {Env} runningParsed running parsed object + * @returns {string} expanded value + */ +function expandValue(value, processEnv, runningParsed) { + const env = { ...runningParsed, ...processEnv }; // process.env wins + + const regex = /(?} */ + const seen = new Set(); // self-referential checker + + while ((match = regex.exec(result)) !== null) { + seen.add(result); + + const [template, bracedExpression, unbracedExpression] = match; + const expression = bracedExpression || unbracedExpression; + + // match the operators `:+`, `+`, `:-`, and `-` + const opRegex = /(:\+|\+|:-|-)/; + // find first match + const opMatch = expression.match(opRegex); + const splitter = opMatch ? opMatch[0] : null; + + const r = expression.split(/** @type {string} */ (splitter)); + // const r = splitter ? expression.split(splitter) : [expression]; + + /** @type {string} */ + let defaultValue; + /** @type {undefined | null | string} */ + let value; + + const key = r.shift(); + + if ([":+", "+"].includes(splitter || "")) { + defaultValue = env[key || ""] ? r.join(splitter || "") : ""; + value = null; + } else { + defaultValue = r.join(splitter || ""); + value = env[key || ""]; + } + + if (value) { + // self-referential check + result = seen.has(value) + ? result.replace(template, defaultValue) + : result.replace(template, value); + } else { + result = result.replace(template, defaultValue); + } + + // if the result equaled what was in process.env and runningParsed then stop expanding + if (result === runningParsed[key || ""]) { + break; + } + + regex.lastIndex = 0; // reset regex search position to re-evaluate after each replacement + } + + return result; +} + +/** + * Expand environment variables in parsed object + * ported from https://github.com/motdotla/dotenv-expand + * @param {{ parsed: Env, processEnv: Record }} options expand options + * @returns {{ parsed: Env }} expanded options + */ +function expand(options) { + // for use with progressive expansion + const runningParsed = /** @type {Env} */ (Object.create(null)); + const processEnv = options.processEnv; + + // dotenv.config() ran before this so the assumption is process.env has already been set + for (const key in options.parsed) { + let value = options.parsed[key]; + + // short-circuit scenario: process.env was already set prior to the file value + value = + Object.prototype.hasOwnProperty.call(processEnv, key) && + processEnv[key] !== value + ? /** @type {string} */ (processEnv[key]) + : expandValue(value, processEnv, runningParsed); + + const resolvedValue = _resolveEscapeSequences(value); + + options.parsed[key] = resolvedValue; + // for use with progressive expansion + runningParsed[key] = resolvedValue; + } + + // Part of `dotenv-expand` code, but we don't need it because of we don't modify `process.env` + // for (const processKey in options.parsed) { + // if (processEnv) { + // processEnv[processKey] = options.parsed[processKey]; + // } + // } + + return options; +} + +/** + * Format environment variables as DefinePlugin definitions + * @param {Env} env environment variables + * @returns {Record} formatted definitions + */ +const envToDefinitions = (env) => { + const definitions = /** @type {Record} */ ({}); + + for (const [key, value] of Object.entries(env)) { + const defValue = JSON.stringify(value); + definitions[`process.env.${key}`] = defValue; + definitions[`import.meta.env.${key}`] = defValue; + } + + return definitions; +}; + +class DotenvPlugin { + /** + * Creates an instance of DotenvPlugin. + * @param {DotenvPluginOptions=} options options object + */ + constructor(options = {}) { + /** @type {DotenvPluginOptions} */ + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => { + const { definitions } = require("../schemas/WebpackOptions.json"); + + return { + definitions, + oneOf: [{ $ref: "#/definitions/DotenvPluginOptions" }] + }; + }, + this.options, + { + name: "Dotenv Plugin", + baseDataPath: "options" + } + ); + }); + const definePlugin = new compiler.webpack.DefinePlugin({}); + const prefixes = Array.isArray(this.options.prefix) + ? this.options.prefix + : [this.options.prefix || "WEBPACK_"]; + /** @type {string | false} */ + const dir = + typeof this.options.dir === "string" + ? this.options.dir + : typeof this.options.dir === "undefined" + ? compiler.context + : this.options.dir; + + /** @type {undefined | Snapshot} */ + let snapshot; + + const cache = compiler.getCache(PLUGIN_NAME); + const identifier = JSON.stringify( + this.options.template || DEFAULT_TEMPLATE + ); + const itemCache = cache.getItemCache(identifier, null); + + compiler.hooks.beforeCompile.tapPromise(PLUGIN_NAME, async () => { + const { parsed, snapshot: newSnapshot } = dir + ? await this._loadEnv(compiler, itemCache, dir) + : { parsed: {} }; + const env = this._getEnv(prefixes, parsed); + + definePlugin.definitions = envToDefinitions(env || {}); + snapshot = newSnapshot; + }); + + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + if (snapshot) { + compilation.fileDependencies.addAll(snapshot.getFileIterable()); + compilation.missingDependencies.addAll(snapshot.getMissingIterable()); + } + }); + + definePlugin.apply(compiler); + } + + /** + * Get list of env files to load based on mode and template + * Similar to Vite's getEnvFilesForMode + * @private + * @param {InputFileSystem} inputFileSystem the input file system + * @param {string | false} dir the directory containing .env files + * @param {string | undefined} mode the mode (e.g., 'production', 'development') + * @returns {string[]} array of file paths to load + */ + _getEnvFilesForMode(inputFileSystem, dir, mode) { + if (!dir) { + return []; + } + + const templates = this.options.template || DEFAULT_TEMPLATE; + + return templates + .map((pattern) => pattern.replace(/\[mode\]/g, mode || "development")) + .map((file) => join(inputFileSystem, dir, file)); + } + + /** + * Get parsed env variables from `.env` files + * @private + * @param {InputFileSystem} fs input file system + * @param {string} dir dir to load `.env` files + * @param {string} mode mode + * @returns {Promise<{ parsed: Env, fileDependencies: string[], missingDependencies: string[] }>} parsed env variables and dependencies + */ + async _getParsed(fs, dir, mode) { + /** @type {string[]} */ + const fileDependencies = []; + /** @type {string[]} */ + const missingDependencies = []; + + // Get env files to load + const envFiles = this._getEnvFilesForMode(fs, dir, mode); + + // Read all files + const contents = await Promise.all( + envFiles.map((filePath) => + this._loadFile(fs, filePath).then( + (content) => { + fileDependencies.push(filePath); + return content; + }, + () => { + // File doesn't exist, add to missingDependencies (this is normal) + missingDependencies.push(filePath); + return ""; + } + ) + ) + ); + + // Parse all files and merge (later files override earlier ones) + // Similar to Vite's implementation + const parsed = /** @type {Env} */ (Object.create(null)); + + for (const content of contents) { + if (!content) continue; + const entries = parse(content); + for (const key in entries) { + parsed[key] = entries[key]; + } + } + + return { parsed, fileDependencies, missingDependencies }; + } + + /** + * Loads the provided compiler. + * @private + * @param {Compiler} compiler compiler + * @param {ItemCacheFacade} itemCache item cache facade + * @param {string} dir directory to read + * @returns {Promise<{ parsed: Env, snapshot: Snapshot }>} parsed result and snapshot + */ + async _loadEnv(compiler, itemCache, dir) { + const fs = /** @type {InputFileSystem} */ (compiler.inputFileSystem); + const fileSystemInfo = new FileSystemInfo(fs, { + unmanagedPaths: compiler.unmanagedPaths, + managedPaths: compiler.managedPaths, + immutablePaths: compiler.immutablePaths, + hashFunction: compiler.options.output.hashFunction + }); + + const result = await itemCache.getPromise(); + + if (result) { + const isSnapshotValid = await new Promise((resolve, reject) => { + fileSystemInfo.checkSnapshotValid(result.snapshot, (error, isValid) => { + if (error) { + reject(error); + + return; + } + + resolve(isValid); + }); + }); + + if (isSnapshotValid) { + return { parsed: result.parsed, snapshot: result.snapshot }; + } + } + + const { parsed, fileDependencies, missingDependencies } = + await this._getParsed( + fs, + dir, + /** @type {string} */ + (compiler.options.mode) + ); + + const startTime = Date.now(); + const newSnapshot = await new Promise((resolve, reject) => { + fileSystemInfo.createSnapshot( + startTime, + fileDependencies, + null, + missingDependencies, + // `.env` files are build dependencies + compiler.options.snapshot.buildDependencies, + (err, snapshot) => { + if (err) return reject(err); + resolve(snapshot); + } + ); + }); + + await itemCache.storePromise({ parsed, snapshot: newSnapshot }); + + return { parsed, snapshot: newSnapshot }; + } + + /** + * Generate env variables + * @private + * @param {Prefix} prefixes expose only environment variables that start with these prefixes + * @param {Env} parsed parsed env variables + * @returns {Env} env variables + */ + _getEnv(prefixes, parsed) { + // Always expand environment variables (like Vite does) + // Make a copy of process.env so that dotenv-expand doesn't modify global process.env + const processEnv = { ...process.env }; + expand({ parsed, processEnv }); + const env = /** @type {Env} */ (Object.create(null)); + + // Get all keys from parser and process.env + const keys = [...Object.keys(parsed), ...Object.keys(process.env)]; + + // Prioritize actual env variables from `process.env`, fallback to parsed + for (const key of keys) { + if (prefixes.some((prefix) => key.startsWith(prefix))) { + env[key] = + Object.prototype.hasOwnProperty.call(process.env, key) && + process.env[key] + ? process.env[key] + : parsed[key]; + } + } + + return env; + } + + /** + * Load a file with proper path resolution + * @private + * @param {InputFileSystem} fs the input file system + * @param {string} file the file to load + * @returns {Promise} the content of the file + */ + _loadFile(fs, file) { + return new Promise((resolve, reject) => { + fs.readFile(file, (err, content) => { + if (err) reject(err); + else resolve(/** @type {Buffer} */ (content).toString() || ""); + }); + }); + } +} + +module.exports = DotenvPlugin; Index: frontend/node_modules/webpack/lib/DynamicEntryPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/DynamicEntryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/DynamicEntryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,95 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Naoyuki Kanezawa @nkzawa +*/ + +"use strict"; + +const EntryOptionPlugin = require("./EntryOptionPlugin"); +const EntryPlugin = require("./EntryPlugin"); +const EntryDependency = require("./dependencies/EntryDependency"); + +/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */ +/** @typedef {import("../declarations/WebpackOptions").EntryStatic} EntryStatic */ +/** @typedef {import("../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */ +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "DynamicEntryPlugin"; + +/** @typedef {() => EntryStatic | Promise} RawEntryDynamic */ +/** @typedef {() => Promise} EntryDynamic */ + +class DynamicEntryPlugin { + /** + * Creates an instance of DynamicEntryPlugin. + * @param {string} context the context path + * @param {EntryDynamic} entry the entry value + */ + constructor(context, entry) { + /** @type {string} */ + this.context = context; + /** @type {EntryDynamic} */ + this.entry = entry; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyFactories.set( + EntryDependency, + normalModuleFactory + ); + } + ); + + compiler.hooks.make.tapPromise(PLUGIN_NAME, (compilation) => + Promise.resolve(this.entry()) + .then((entry) => { + /** @type {Promise[]} */ + const promises = []; + for (const name of Object.keys(entry)) { + const desc = entry[name]; + const options = EntryOptionPlugin.entryDescriptionToOptions( + compiler, + name, + desc + ); + for (const entry of /** @type {NonNullable} */ ( + desc.import + )) { + promises.push( + new Promise( + /** + * Handles the callback logic for this hook. + * @param {(value?: undefined) => void} resolve resolve + * @param {(reason?: Error) => void} reject reject + */ + (resolve, reject) => { + compilation.addEntry( + this.context, + EntryPlugin.createDependency(entry, options), + options, + (err) => { + if (err) return reject(err); + resolve(); + } + ); + } + ) + ); + } + } + return Promise.all(promises); + }) + .then(() => {}) + ); + } +} + +module.exports = DynamicEntryPlugin; Index: frontend/node_modules/webpack/lib/EntryOptionPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/EntryOptionPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/EntryOptionPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,101 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */ +/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */ + +const PLUGIN_NAME = "EntryOptionPlugin"; + +class EntryOptionPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance one is tapping into + * @returns {void} + */ + apply(compiler) { + compiler.hooks.entryOption.tap(PLUGIN_NAME, (context, entry) => { + EntryOptionPlugin.applyEntryOption(compiler, context, entry); + return true; + }); + } + + /** + * Apply entry option. + * @param {Compiler} compiler the compiler + * @param {string} context context directory + * @param {Entry} entry request + * @returns {void} + */ + static applyEntryOption(compiler, context, entry) { + if (typeof entry === "function") { + const DynamicEntryPlugin = require("./DynamicEntryPlugin"); + + new DynamicEntryPlugin(context, entry).apply(compiler); + } else { + const EntryPlugin = require("./EntryPlugin"); + + for (const name of Object.keys(entry)) { + const desc = entry[name]; + const options = EntryOptionPlugin.entryDescriptionToOptions( + compiler, + name, + desc + ); + const descImport = + /** @type {Exclude} */ + (desc.import); + for (const entry of descImport) { + new EntryPlugin(context, entry, options).apply(compiler); + } + } + } + } + + /** + * Entry description to options. + * @param {Compiler} compiler the compiler + * @param {string} name entry name + * @param {EntryDescription} desc entry description + * @returns {EntryOptions} options for the entry + */ + static entryDescriptionToOptions(compiler, name, desc) { + /** @type {EntryOptions} */ + const options = { + name, + filename: desc.filename, + runtime: desc.runtime, + layer: desc.layer, + dependOn: desc.dependOn, + baseUri: desc.baseUri, + publicPath: desc.publicPath, + chunkLoading: desc.chunkLoading, + asyncChunks: desc.asyncChunks, + wasmLoading: desc.wasmLoading, + library: desc.library + }; + if (desc.chunkLoading) { + const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin"); + + EnableChunkLoadingPlugin.checkEnabled(compiler, desc.chunkLoading); + } + if (desc.wasmLoading) { + const EnableWasmLoadingPlugin = require("./wasm/EnableWasmLoadingPlugin"); + + EnableWasmLoadingPlugin.checkEnabled(compiler, desc.wasmLoading); + } + if (desc.library) { + const EnableLibraryPlugin = require("./library/EnableLibraryPlugin"); + + EnableLibraryPlugin.checkEnabled(compiler, desc.library.type); + } + return options; + } +} + +module.exports = EntryOptionPlugin; Index: frontend/node_modules/webpack/lib/EntryPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/EntryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/EntryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,73 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const EntryDependency = require("./dependencies/EntryDependency"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */ + +const PLUGIN_NAME = "EntryPlugin"; + +class EntryPlugin { + /** + * An entry plugin which will handle creation of the EntryDependency + * @param {string} context context path + * @param {string} entry entry path + * @param {EntryOptions | string=} options entry options (passing a string is deprecated) + */ + constructor(context, entry, options) { + this.context = context; + this.entry = entry; + this.options = options || ""; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyFactories.set( + EntryDependency, + normalModuleFactory + ); + } + ); + + const { entry, options, context } = this; + const dep = EntryPlugin.createDependency(entry, options); + + compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => { + compilation.addEntry(context, dep, options, (err) => { + callback(err); + }); + }); + } + + /** + * Creates a dependency. + * @param {string} entry entry request + * @param {EntryOptions | string} options entry options (passing string is deprecated) + * @returns {EntryDependency} the dependency + */ + static createDependency(entry, options) { + const dep = new EntryDependency(entry); + // TODO webpack 6 remove string option + dep.loc = { + name: + typeof options === "object" + ? /** @type {string} */ (options.name) + : options + }; + return dep; + } +} + +module.exports = EntryPlugin; Index: frontend/node_modules/webpack/lib/Entrypoint.js =================================================================== --- frontend/node_modules/webpack/lib/Entrypoint.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Entrypoint.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,124 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const ChunkGroup = require("./ChunkGroup"); +const SortableSet = require("./util/SortableSet"); + +/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */ +/** @typedef {import("./Chunk")} Chunk */ + +/** @typedef {{ name?: string } & Omit} EntryOptions */ + +/** + * Entrypoint serves as an encapsulation primitive for chunks that are + * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a + * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects + * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks. + */ +class Entrypoint extends ChunkGroup { + /** + * Creates an instance of Entrypoint. + * @param {EntryOptions | string} entryOptions the options for the entrypoint (or name) + * @param {boolean=} initial false, when the entrypoint is not initial loaded + */ + constructor(entryOptions, initial = true) { + if (typeof entryOptions === "string") { + entryOptions = { name: entryOptions }; + } + super({ + name: entryOptions.name + }); + this.options = entryOptions; + /** @type {Chunk=} */ + this._runtimeChunk = undefined; + /** @type {Chunk=} */ + this._entrypointChunk = undefined; + /** @type {boolean} */ + this._initial = initial; + /** @type {SortableSet} */ + this._dependOn = new SortableSet(); + } + + /** + * Indicates whether this chunk group is loaded as part of the initial page + * load instead of being created lazily. + * @returns {boolean} true, when this chunk group will be loaded on initial page load + */ + isInitial() { + return this._initial; + } + + /** + * Sets the runtimeChunk for an entrypoint. + * @param {Chunk} chunk the chunk being set as the runtime chunk. + * @returns {void} + */ + setRuntimeChunk(chunk) { + this._runtimeChunk = chunk; + } + + /** + * Fetches the chunk reference containing the webpack bootstrap code + * @returns {Chunk | null} returns the runtime chunk or null if there is none + */ + getRuntimeChunk() { + if (this._runtimeChunk) return this._runtimeChunk; + for (const parent of this.parentsIterable) { + if (parent instanceof Entrypoint) return parent.getRuntimeChunk(); + } + return null; + } + + /** + * Sets the chunk with the entrypoint modules for an entrypoint. + * @param {Chunk} chunk the chunk being set as the entrypoint chunk. + * @returns {void} + */ + setEntrypointChunk(chunk) { + this._entrypointChunk = chunk; + } + + /** + * Returns the chunk which contains the entrypoint modules + * (or at least the execution of them) + * @returns {Chunk} chunk + */ + getEntrypointChunk() { + return /** @type {Chunk} */ (this._entrypointChunk); + } + + /** + * Replaces one member chunk with another while preserving the group's + * ordering and avoiding duplicates. + * @param {Chunk} oldChunk chunk to be replaced + * @param {Chunk} newChunk New chunk that will be replaced with + * @returns {boolean | undefined} returns true if the replacement was successful + */ + replaceChunk(oldChunk, newChunk) { + if (this._runtimeChunk === oldChunk) this._runtimeChunk = newChunk; + if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk; + return super.replaceChunk(oldChunk, newChunk); + } + + /** + * @param {Entrypoint} entrypoint the entrypoint + * @returns {void} + */ + addDependOn(entrypoint) { + this._dependOn.add(entrypoint); + } + + /** + * @param {Entrypoint} entrypoint the entrypoint + * @returns {boolean} true if the entrypoint is in the dependOn set + */ + dependOn(entrypoint) { + return this._dependOn.has(entrypoint); + } +} + +module.exports = Entrypoint; Index: frontend/node_modules/webpack/lib/EnvironmentPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/EnvironmentPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/EnvironmentPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,75 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Authors Simen Brekken @simenbrekken, Einar Löve @einarlove +*/ + +"use strict"; + +const DefinePlugin = require("./DefinePlugin"); +const WebpackError = require("./errors/WebpackError"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./DefinePlugin").CodeValue} CodeValue */ + +const PLUGIN_NAME = "EnvironmentPlugin"; + +class EnvironmentPlugin { + /** + * Creates an instance of EnvironmentPlugin. + * @param {(string | string[] | Record)[]} keys keys + */ + constructor(...keys) { + if (keys.length === 1 && Array.isArray(keys[0])) { + /** @type {string[]} */ + this.keys = keys[0]; + this.defaultValues = {}; + } else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") { + this.keys = Object.keys(keys[0]); + this.defaultValues = + /** @type {Record} */ + (keys[0]); + } else { + this.keys = /** @type {string[]} */ (keys); + this.defaultValues = {}; + } + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const definePlugin = new DefinePlugin({}); + + compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => { + /** @type {Record} */ + const definitions = {}; + for (const key of this.keys) { + const value = + process.env[key] !== undefined + ? process.env[key] + : this.defaultValues[key]; + + if (value === undefined) { + const error = new WebpackError( + `${PLUGIN_NAME} - ${key} environment variable is undefined.\n\n` + + "You can pass an object with default values to suppress this warning.\n" + + "See https://webpack.js.org/plugins/environment-plugin for example." + ); + + error.name = "EnvVariableNotDefinedError"; + compilation.errors.push(error); + } + const defValue = + value === undefined ? "undefined" : JSON.stringify(value); + definitions[`process.env.${key}`] = defValue; + definitions[`import.meta.env.${key}`] = defValue; + } + definePlugin.definitions = definitions; + }); + definePlugin.apply(compiler); + } +} + +module.exports = EnvironmentPlugin; Index: frontend/node_modules/webpack/lib/ErrorHelpers.js =================================================================== --- frontend/node_modules/webpack/lib/ErrorHelpers.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ErrorHelpers.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,107 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const loaderFlag = "LOADER_EXECUTION"; + +const webpackOptionsFlag = "WEBPACK_OPTIONS"; + +/** + * Returns stack trace without the specified flag included. + * @param {string} stack stack trace + * @param {string} flag flag to cut off + * @returns {string} stack trace without the specified flag included + */ +const cutOffByFlag = (stack, flag) => { + const errorStack = stack.split("\n"); + for (let i = 0; i < errorStack.length; i++) { + if (errorStack[i].includes(flag)) { + errorStack.length = i; + } + } + return errorStack.join("\n"); +}; + +/** + * Cut off loader execution. + * @param {string} stack stack trace + * @returns {string} stack trace without the loader execution flag included + */ +const cutOffLoaderExecution = (stack) => cutOffByFlag(stack, loaderFlag); + +/** + * Cut off webpack options. + * @param {string} stack stack trace + * @returns {string} stack trace without the webpack options flag included + */ +const cutOffWebpackOptions = (stack) => cutOffByFlag(stack, webpackOptionsFlag); + +/** + * Cut off multiline message. + * @param {string} stack stack trace + * @param {string} message error message + * @returns {string} stack trace without the message included + */ +const cutOffMultilineMessage = (stack, message) => { + const stackSplitByLines = stack.split("\n"); + const messageSplitByLines = message.split("\n"); + + /** @type {string[]} */ + const result = []; + + for (const [idx, line] of stackSplitByLines.entries()) { + if (!line.includes(messageSplitByLines[idx])) result.push(line); + } + + return result.join("\n"); +}; + +/** + * Returns stack trace without the message included. + * @param {string} stack stack trace + * @param {string} message error message + * @returns {string} stack trace without the message included + */ +const cutOffMessage = (stack, message) => { + const nextLine = stack.indexOf("\n"); + if (nextLine === -1) { + return stack === message ? "" : stack; + } + const firstLine = stack.slice(0, nextLine); + return firstLine === message ? stack.slice(nextLine + 1) : stack; +}; + +/** + * Returns stack trace without the loader execution flag and message included. + * @param {string} stack stack trace + * @param {string} message error message + * @returns {string} stack trace without the loader execution flag and message included + */ +const cleanUp = (stack, message) => { + stack = cutOffLoaderExecution(stack); + stack = cutOffMessage(stack, message); + return stack; +}; + +/** + * Clean up webpack options. + * @param {string} stack stack trace + * @param {string} message error message + * @returns {string} stack trace without the webpack options flag and message included + */ +const cleanUpWebpackOptions = (stack, message) => { + stack = cutOffWebpackOptions(stack); + stack = cutOffMultilineMessage(stack, message); + return stack; +}; + +module.exports.cleanUp = cleanUp; +module.exports.cleanUpWebpackOptions = cleanUpWebpackOptions; +module.exports.cutOffByFlag = cutOffByFlag; +module.exports.cutOffLoaderExecution = cutOffLoaderExecution; +module.exports.cutOffMessage = cutOffMessage; +module.exports.cutOffMultilineMessage = cutOffMultilineMessage; +module.exports.cutOffWebpackOptions = cutOffWebpackOptions; Index: frontend/node_modules/webpack/lib/EvalDevToolModulePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/EvalDevToolModulePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/EvalDevToolModulePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,137 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { ConcatSource, RawSource } = require("webpack-sources"); +const ExternalModule = require("./ExternalModule"); +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").DevtoolNamespace} DevtoolNamespace */ +/** @typedef {import("../declarations/WebpackOptions").DevtoolModuleFilenameTemplate} DevtoolModuleFilenameTemplate */ +/** @typedef {import("./Compiler")} Compiler */ + +/** @type {WeakMap} */ +const cache = new WeakMap(); + +const devtoolWarning = new RawSource(`/* + * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development"). + * This devtool is neither made for production nor for readable output files. + * It uses "eval()" calls to create a separate source file in the browser devtools. + * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/) + * or disable the default devtool with "devtool: false". + * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/). + */ +`); + +/** + * Defines the eval dev tool module plugin options type used by this module. + * @typedef {object} EvalDevToolModulePluginOptions + * @property {DevtoolNamespace=} namespace namespace + * @property {string=} sourceUrlComment source url comment + * @property {DevtoolModuleFilenameTemplate=} moduleFilenameTemplate module filename template + */ + +const PLUGIN_NAME = "EvalDevToolModulePlugin"; + +class EvalDevToolModulePlugin { + /** + * Creates an instance of EvalDevToolModulePlugin. + * @param {EvalDevToolModulePluginOptions=} options options + */ + constructor(options = {}) { + /** @type {DevtoolNamespace} */ + this.namespace = options.namespace || ""; + /** @type {string} */ + this.sourceUrlComment = options.sourceUrlComment || "\n//# sourceURL=[url]"; + /** @type {DevtoolModuleFilenameTemplate} */ + this.moduleFilenameTemplate = + options.moduleFilenameTemplate || + "webpack://[namespace]/[resourcePath]?[loaders]"; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation); + hooks.renderModuleContent.tap( + PLUGIN_NAME, + (source, module, { chunk, runtimeTemplate, chunkGraph }) => { + const cacheEntry = cache.get(source); + if (cacheEntry !== undefined) return cacheEntry; + if (module instanceof ExternalModule) { + cache.set(source, source); + return source; + } + const content = source.source(); + const namespace = compilation.getPath(this.namespace, { + chunk + }); + const str = ModuleFilenameHelpers.createFilename( + module, + { + moduleFilenameTemplate: this.moduleFilenameTemplate, + namespace + }, + { + requestShortener: runtimeTemplate.requestShortener, + chunkGraph, + hashFunction: compilation.outputOptions.hashFunction + } + ); + const footer = `\n${this.sourceUrlComment.replace( + /\[url\]/g, + encodeURI(str) + .replace(/%2F/g, "/") + .replace(/%20/g, "_") + .replace(/%5E/g, "^") + .replace(/%5C/g, "\\") + .replace(/^\//, "") + )}`; + const result = new RawSource( + `eval(${ + compilation.outputOptions.trustedTypes + ? `${RuntimeGlobals.createScript}(${JSON.stringify( + `{${content + footer}\n}` + )})` + : JSON.stringify(`{${content + footer}\n}`) + });` + ); + cache.set(source, result); + return result; + } + ); + hooks.inlineInRuntimeBailout.tap( + PLUGIN_NAME, + () => "the eval devtool is used." + ); + hooks.render.tap( + PLUGIN_NAME, + (source) => new ConcatSource(devtoolWarning, source) + ); + hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash) => { + hash.update(PLUGIN_NAME); + hash.update("2"); + }); + if (compilation.outputOptions.trustedTypes) { + compilation.hooks.additionalModuleRuntimeRequirements.tap( + PLUGIN_NAME, + (module, set, _context) => { + set.add(RuntimeGlobals.createScript); + } + ); + } + }); + } +} + +module.exports = EvalDevToolModulePlugin; Index: frontend/node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,252 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { ConcatSource, RawSource } = require("webpack-sources"); +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); +const NormalModule = require("./NormalModule"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin"); +const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin"); +const ConcatenatedModule = require("./optimize/ConcatenatedModule"); +const generateDebugId = require("./util/generateDebugId"); +const { makePathsAbsolute } = require("./util/identifier"); + +/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */ +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").DevtoolNamespace} DevtoolNamespace */ +/** @typedef {import("../declarations/WebpackOptions").DevtoolModuleFilenameTemplate} DevtoolModuleFilenameTemplate */ +/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */ +/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").Rules} Rules */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ + +/** @type {WeakMap} */ +const cache = new WeakMap(); + +const devtoolWarning = new RawSource(`/* + * ATTENTION: An "eval-source-map" devtool has been used. + * This devtool is neither made for production nor for readable output files. + * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools. + * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/) + * or disable the default devtool with "devtool: false". + * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/). + */ +`); + +const PLUGIN_NAME = "EvalSourceMapDevToolPlugin"; + +class EvalSourceMapDevToolPlugin { + /** + * Creates an instance of EvalSourceMapDevToolPlugin. + * @param {SourceMapDevToolPluginOptions | string=} inputOptions Options object + */ + constructor(inputOptions = {}) { + /** @type {SourceMapDevToolPluginOptions} */ + let options; + if (typeof inputOptions === "string") { + options = { + append: inputOptions + }; + } else { + options = inputOptions; + } + /** @type {string} */ + this.sourceMapComment = + options.append && typeof options.append !== "function" + ? options.append + : "//# sourceURL=[module]\n//# sourceMappingURL=[url]"; + /** @type {DevtoolModuleFilenameTemplate} */ + this.moduleFilenameTemplate = + options.moduleFilenameTemplate || + "webpack://[namespace]/[resource-path]?[hash]"; + /** @type {DevtoolNamespace} */ + this.namespace = options.namespace || ""; + /** @type {SourceMapDevToolPluginOptions} */ + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const options = this.options; + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation); + new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation); + const matchModule = ModuleFilenameHelpers.matchObject.bind( + ModuleFilenameHelpers, + options + ); + hooks.renderModuleContent.tap( + PLUGIN_NAME, + (source, m, { chunk, runtimeTemplate, chunkGraph }) => { + const cachedSource = cache.get(source); + if (cachedSource !== undefined) { + return cachedSource; + } + + /** + * Returns result. + * @param {Source} r result + * @returns {Source} result + */ + const result = (r) => { + cache.set(source, r); + return r; + }; + + if (m instanceof NormalModule) { + if (!matchModule(m.resource)) { + return result(source); + } + } else if (m instanceof ConcatenatedModule) { + if (m.rootModule instanceof NormalModule) { + if (!matchModule(m.rootModule.resource)) { + return result(source); + } + } else { + return result(source); + } + } else { + return result(source); + } + + const namespace = compilation.getPath(this.namespace, { + chunk + }); + /** @type {RawSourceMap} */ + let sourceMap; + /** @type {string | Buffer} */ + let content; + if (source.sourceAndMap) { + const sourceAndMap = source.sourceAndMap(options); + sourceMap = /** @type {RawSourceMap} */ (sourceAndMap.map); + content = sourceAndMap.source; + } else { + sourceMap = /** @type {RawSourceMap} */ (source.map(options)); + content = source.source(); + } + if (!sourceMap) { + return result(source); + } + + // Clone (flat) the sourcemap to ensure that the mutations below do not persist. + sourceMap = { ...sourceMap }; + const context = compiler.context; + const root = compiler.root; + const cachedAbsolutify = makePathsAbsolute.bindContextCache( + context, + root + ); + const modules = sourceMap.sources.map((source) => { + if (!source.startsWith("webpack://")) return source; + source = cachedAbsolutify(source.slice(10)); + const module = compilation.findModule(source); + return module || source; + }); + let moduleFilenames = modules.map((module) => + ModuleFilenameHelpers.createFilename( + module, + { + moduleFilenameTemplate: this.moduleFilenameTemplate, + namespace + }, + { + requestShortener: runtimeTemplate.requestShortener, + chunkGraph, + hashFunction: compilation.outputOptions.hashFunction + } + ) + ); + moduleFilenames = ModuleFilenameHelpers.replaceDuplicates( + moduleFilenames, + (filename, i, n) => { + for (let j = 0; j < n; j++) filename += "*"; + return filename; + } + ); + sourceMap.sources = moduleFilenames; + if (options.ignoreList) { + const ignoreList = sourceMap.sources.reduce( + /** @type {(acc: number[], sourceName: string, idx: number) => number[]} */ ( + (acc, sourceName, idx) => { + const rule = /** @type {Rules} */ (options.ignoreList); + if (ModuleFilenameHelpers.matchPart(sourceName, rule)) { + acc.push(idx); + } + return acc; + } + ), + [] + ); + if (ignoreList.length > 0) { + sourceMap.ignoreList = ignoreList; + } + } + + if (options.noSources) { + sourceMap.sourcesContent = undefined; + } + sourceMap.sourceRoot = options.sourceRoot || ""; + const moduleId = + /** @type {ModuleId} */ + (chunkGraph.getModuleId(m)); + sourceMap.file = + typeof moduleId === "number" ? `${moduleId}.js` : moduleId; + + if (options.debugIds) { + sourceMap.debugId = generateDebugId(content, sourceMap.file); + } + + const footer = `${this.sourceMapComment.replace( + /\[url\]/g, + `data:application/json;charset=utf-8;base64,${Buffer.from( + JSON.stringify(sourceMap), + "utf8" + ).toString("base64")}` + )}\n//# sourceURL=webpack-internal:///${moduleId}\n`; // workaround for chrome bug + + return result( + new RawSource( + `eval(${ + compilation.outputOptions.trustedTypes + ? `${RuntimeGlobals.createScript}(${JSON.stringify( + `{${content + footer}\n}` + )})` + : JSON.stringify(`{${content + footer}\n}`) + });` + ) + ); + } + ); + hooks.inlineInRuntimeBailout.tap( + PLUGIN_NAME, + () => "the eval-source-map devtool is used." + ); + hooks.render.tap( + PLUGIN_NAME, + (source) => new ConcatSource(devtoolWarning, source) + ); + hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash) => { + hash.update(PLUGIN_NAME); + hash.update("2"); + }); + if (compilation.outputOptions.trustedTypes) { + compilation.hooks.additionalModuleRuntimeRequirements.tap( + PLUGIN_NAME, + (module, set, context) => { + set.add(RuntimeGlobals.createScript); + } + ); + } + }); + } +} + +module.exports = EvalSourceMapDevToolPlugin; Index: frontend/node_modules/webpack/lib/ExportsInfo.js =================================================================== --- frontend/node_modules/webpack/lib/ExportsInfo.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ExportsInfo.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1713 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { ImportPhaseUtils } = require("./dependencies/ImportPhase"); +const { equals } = require("./util/ArrayHelpers"); +const SortableSet = require("./util/SortableSet"); +const makeSerializable = require("./util/makeSerializable"); +const { forEachRuntime } = require("./util/runtime"); + +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */ +/** @typedef {import("./Dependency").ExportInfoName} ExportInfoName */ +/** @typedef {import("./Dependency").ExportsSpecExcludeExports} ExportsSpecExcludeExports */ +/** @typedef {import("./dependencies/HarmonyImportDependency")} HarmonyImportDependency */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ + +/** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */ +/** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */ + +/** @typedef {Map} UsedInRuntime */ +/** @typedef {{ module: Module, export: ExportInfoName[], deferred: boolean }} TargetItemWithoutConnection */ +/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: ExportInfoName[] | undefined }} TargetItemWithConnection */ +/** @typedef {(target: TargetItemWithConnection) => boolean} ResolveTargetFilter */ +/** @typedef {(module: Module) => boolean} ValidTargetModuleFilter */ +/** @typedef {{ connection: ModuleGraphConnection, export: ExportInfoName[], priority: number }} TargetItem */ +/** @typedef {Map} Target */ + +/** @typedef {string | null} ExportInfoUsedName */ +/** @typedef {boolean | null} ExportInfoProvided */ + +/** @typedef {Map} Exports */ +/** @typedef {string | string[] | false} UsedName */ +/** @typedef {Set} AlreadyVisitedExportInfo */ + +/** + * Defines the restore provided data exports type used by this module. + * @typedef {object} RestoreProvidedDataExports + * @property {ExportInfoName} name + * @property {ExportInfo["provided"]} provided + * @property {ExportInfo["canMangleProvide"]} canMangleProvide + * @property {ExportInfo["terminalBinding"]} terminalBinding + * @property {RestoreProvidedData | undefined} exportsInfo + */ + +const UsageState = Object.freeze({ + Unused: /** @type {0} */ (0), + OnlyPropertiesUsed: /** @type {1} */ (1), + NoInfo: /** @type {2} */ (2), + Unknown: /** @type {3} */ (3), + Used: /** @type {4} */ (4) +}); + +const RETURNS_TRUE = () => true; + +const CIRCULAR = Symbol("circular target"); + +class RestoreProvidedData { + /** + * Creates an instance of RestoreProvidedData. + * @param {RestoreProvidedDataExports[]} exports exports + * @param {ExportInfo["provided"]} otherProvided other provided + * @param {ExportInfo["canMangleProvide"]} otherCanMangleProvide other can mangle provide + * @param {ExportInfo["terminalBinding"]} otherTerminalBinding other terminal binding + */ + constructor( + exports, + otherProvided, + otherCanMangleProvide, + otherTerminalBinding + ) { + this.exports = exports; + this.otherProvided = otherProvided; + this.otherCanMangleProvide = otherCanMangleProvide; + this.otherTerminalBinding = otherTerminalBinding; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize({ write }) { + write(this.exports); + write(this.otherProvided); + write(this.otherCanMangleProvide); + write(this.otherTerminalBinding); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + * @returns {RestoreProvidedData} RestoreProvidedData + */ + static deserialize({ read }) { + return new RestoreProvidedData(read(), read(), read(), read()); + } +} + +makeSerializable( + RestoreProvidedData, + "webpack/lib/ModuleGraph", + "RestoreProvidedData" +); + +class ExportsInfo { + constructor() { + /** @type {Exports} */ + this._exports = new Map(); + + // `_otherExportsInfo` is a fallback entry for unlisted exports. Two roles: + // 1. factory template — `getExportInfo` creates `new ExportInfo(name, this)`, + // so created export info extends its properties. + // 2. flags whether the whole exportsInfo can be statically analyzed. + // Its `used` reachable values: + // - NoInfo: no use analysis yet (`optimization#usedExports` off), or used without info + // - Unused: analyzed, no unlisted export needed + // - Unknown: used in unknown way + // - Used/OnlyPropertiesUsed: never reached + // Its `provided` reachable values: + // - undefined: provision not determined yet + // - false: determined, no unlisted export is provided + // - null: only runtime knows (dynamic/unknown exports) + // - true: never reached + /** @type {ExportInfo} */ + this._otherExportsInfo = new ExportInfo(null); + /** @type {ExportInfo} */ + this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*"); + /** @type {boolean} */ + this._exportsAreOrdered = false; + /** @type {ExportsInfo=} */ + this._redirectTo = undefined; + } + + /** + * Gets owned exports. + * @returns {Iterable} all owned exports in any order + */ + get ownedExports() { + return this._exports.values(); + } + + /** + * Gets ordered owned exports. + * @returns {Iterable} all owned exports in order + */ + get orderedOwnedExports() { + if (!this._exportsAreOrdered) { + this._sortExports(); + } + return this._exports.values(); + } + + /** + * Returns all exports in any order. + * @returns {Iterable} all exports in any order + */ + get exports() { + if (this._redirectTo !== undefined) { + const map = new Map(this._redirectTo._exports); + for (const [key, value] of this._exports) { + map.set(key, value); + } + return map.values(); + } + return this._exports.values(); + } + + /** + * Gets ordered exports. + * @returns {Iterable} all exports in order + */ + get orderedExports() { + if (!this._exportsAreOrdered) { + this._sortExports(); + } + if (this._redirectTo !== undefined) { + /** @type {Exports} */ + const map = new Map( + Array.from(this._redirectTo.orderedExports, (item) => [item.name, item]) + ); + for (const [key, value] of this._exports) { + map.set(key, value); + } + // sorting should be pretty fast as map contains + // a lot of presorted items + this._sortExportsMap(map); + return map.values(); + } + return this._exports.values(); + } + + /** + * Gets other exports info. + * @returns {ExportInfo} the export info of unlisted exports + */ + get otherExportsInfo() { + if (this._redirectTo !== undefined) { + return this._redirectTo.otherExportsInfo; + } + return this._otherExportsInfo; + } + + /** + * Processes the provided export. + * @param {Exports} exports exports + * @private + */ + _sortExportsMap(exports) { + if (exports.size > 1) { + /** @type {ExportInfoName[]} */ + const namesInOrder = []; + for (const entry of exports.values()) { + namesInOrder.push(entry.name); + } + namesInOrder.sort(); + let i = 0; + for (const entry of exports.values()) { + const name = namesInOrder[i]; + if (entry.name !== name) break; + i++; + } + for (; i < namesInOrder.length; i++) { + const name = namesInOrder[i]; + const correctEntry = /** @type {ExportInfo} */ (exports.get(name)); + exports.delete(name); + exports.set(name, correctEntry); + } + } + } + + _sortExports() { + this._sortExportsMap(this._exports); + this._exportsAreOrdered = true; + } + + /** + * Sets redirect named to. + * @param {ExportsInfo | undefined} exportsInfo exports info + * @returns {boolean} result + */ + setRedirectNamedTo(exportsInfo) { + if (this._redirectTo === exportsInfo) return false; + this._redirectTo = exportsInfo; + return true; + } + + setHasProvideInfo() { + for (const exportInfo of this._exports.values()) { + exportInfo.setHasProvideInfo(); + } + if (this._redirectTo !== undefined) { + this._redirectTo.setHasProvideInfo(); + } else { + this._otherExportsInfo.setHasProvideInfo(); + } + } + + setHasUseInfo() { + for (const exportInfo of this._exports.values()) { + exportInfo.setHasUseInfo(); + } + this._sideEffectsOnlyInfo.setHasUseInfo(); + if (this._redirectTo !== undefined) { + this._redirectTo.setHasUseInfo(); + } else { + this._otherExportsInfo.setHasUseInfo(); + } + } + + /** + * Gets own export info. + * @param {ExportInfoName} name export name + * @returns {ExportInfo} export info for this name + */ + getOwnExportInfo(name) { + const info = this._exports.get(name); + if (info !== undefined) return info; + const newInfo = new ExportInfo(name, this._otherExportsInfo); + this._exports.set(name, newInfo); + this._exportsAreOrdered = false; + return newInfo; + } + + /** + * Returns export info for this name. + * @param {ExportInfoName} name export name + * @returns {ExportInfo} export info for this name + */ + getExportInfo(name) { + const info = this._exports.get(name); + if (info !== undefined) return info; + if (this._redirectTo !== undefined) { + return this._redirectTo.getExportInfo(name); + } + const newInfo = new ExportInfo(name, this._otherExportsInfo); + this._exports.set(name, newInfo); + this._exportsAreOrdered = false; + return newInfo; + } + + /** + * Gets read only export info. + * @param {ExportInfoName} name export name + * @returns {ExportInfo} export info for this name + */ + getReadOnlyExportInfo(name) { + const info = this._exports.get(name); + if (info !== undefined) return info; + if (this._redirectTo !== undefined) { + return this._redirectTo.getReadOnlyExportInfo(name); + } + return this._otherExportsInfo; + } + + /** + * Gets read only export info recursive. + * @param {ExportInfoName[]} name export name + * @returns {ExportInfo | undefined} export info for this name + */ + getReadOnlyExportInfoRecursive(name) { + const exportInfo = this.getReadOnlyExportInfo(name[0]); + if (name.length === 1) return exportInfo; + if (!exportInfo.exportsInfo) return; + return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1)); + } + + /** + * Gets nested exports info. + * @param {ExportInfoName[]=} name the export name + * @returns {ExportsInfo | undefined} the nested exports info + */ + getNestedExportsInfo(name) { + if (Array.isArray(name) && name.length > 0) { + const info = this.getReadOnlyExportInfo(name[0]); + if (!info.exportsInfo) return; + return info.exportsInfo.getNestedExportsInfo(name.slice(1)); + } + return this; + } + + /** + * Sets unknown exports provided. + * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false) + * @param {ExportsSpecExcludeExports=} excludeExports list of unaffected exports + * @param {Dependency=} targetKey use this as key for the target + * @param {ModuleGraphConnection=} targetModule set this module as target + * @param {number=} priority priority + * @returns {boolean} true, if this call changed something + */ + setUnknownExportsProvided( + canMangle, + excludeExports, + targetKey, + targetModule, + priority + ) { + let changed = false; + if (excludeExports) { + for (const name of excludeExports) { + // Make sure these entries exist, so they can get different info + this.getExportInfo(name); + } + } + for (const exportInfo of this._exports.values()) { + if (!canMangle && exportInfo.canMangleProvide !== false) { + exportInfo.canMangleProvide = false; + changed = true; + } + if (excludeExports && excludeExports.has(exportInfo.name)) continue; + if (exportInfo.provided !== true && exportInfo.provided !== null) { + exportInfo.provided = null; + changed = true; + } + if (targetKey) { + exportInfo.setTarget( + targetKey, + /** @type {ModuleGraphConnection} */ + (targetModule), + [exportInfo.name], + -1 + ); + } + } + if (this._redirectTo !== undefined) { + if ( + this._redirectTo.setUnknownExportsProvided( + canMangle, + excludeExports, + targetKey, + targetModule, + priority + ) + ) { + changed = true; + } + } else { + if ( + this._otherExportsInfo.provided !== true && + this._otherExportsInfo.provided !== null + ) { + this._otherExportsInfo.provided = null; + changed = true; + } + if (!canMangle && this._otherExportsInfo.canMangleProvide !== false) { + this._otherExportsInfo.canMangleProvide = false; + changed = true; + } + if (targetKey) { + this._otherExportsInfo.setTarget( + targetKey, + /** @type {ModuleGraphConnection} */ (targetModule), + undefined, + priority + ); + } + } + return changed; + } + + /** + * Sets used in unknown way. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, when something changed + */ + setUsedInUnknownWay(runtime) { + let changed = false; + for (const exportInfo of this._exports.values()) { + if (exportInfo.setUsedInUnknownWay(runtime)) { + changed = true; + } + } + if (this._redirectTo !== undefined) { + if (this._redirectTo.setUsedInUnknownWay(runtime)) { + changed = true; + } + } else if (this._otherExportsInfo.setUsedInUnknownWay(runtime)) { + changed = true; + } + return changed; + } + + /** + * Sets used without info. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, when something changed + */ + setUsedWithoutInfo(runtime) { + let changed = false; + for (const exportInfo of this._exports.values()) { + if (exportInfo.setUsedWithoutInfo(runtime)) { + changed = true; + } + } + if (this._redirectTo !== undefined) { + if (this._redirectTo.setUsedWithoutInfo(runtime)) { + changed = true; + } + } else if (this._otherExportsInfo.setUsedWithoutInfo(runtime)) { + changed = true; + } + return changed; + } + + /** + * Sets all known exports used. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, when something changed + */ + setAllKnownExportsUsed(runtime) { + let changed = false; + for (const exportInfo of this._exports.values()) { + if (!exportInfo.provided) continue; + if (exportInfo.setUsed(UsageState.Used, runtime)) { + changed = true; + } + } + return changed; + } + + /** + * Sets used for side effects only. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, when something changed + */ + setUsedForSideEffectsOnly(runtime) { + return this._sideEffectsOnlyInfo.setUsedConditionally( + (used) => used === UsageState.Unused, + UsageState.Used, + runtime + ); + } + + /** + * Checks whether this exports info is used. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, when the module exports are used in any way + */ + isUsed(runtime) { + if (this._redirectTo !== undefined) { + if (this._redirectTo.isUsed(runtime)) { + return true; + } + } else if (this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused) { + return true; + } + for (const exportInfo of this._exports.values()) { + if (exportInfo.getUsed(runtime) !== UsageState.Unused) { + return true; + } + } + return false; + } + + /** + * Checks whether this exports info is module used. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, when the module is used in any way + */ + isModuleUsed(runtime) { + if (this.isUsed(runtime)) return true; + if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused) { + return true; + } + return false; + } + + /** + * Returns set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown). + * @param {RuntimeSpec} runtime the runtime + * @returns {SortableSet | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown) + */ + getUsedExports(runtime) { + switch (this._otherExportsInfo.getUsed(runtime)) { + case UsageState.NoInfo: + return null; + case UsageState.Unknown: + case UsageState.OnlyPropertiesUsed: + case UsageState.Used: + return true; + } + + /** @type {ExportInfoName[]} */ + const array = []; + if (!this._exportsAreOrdered) this._sortExports(); + for (const exportInfo of this._exports.values()) { + switch (exportInfo.getUsed(runtime)) { + case UsageState.NoInfo: + return null; + case UsageState.Unknown: + return true; + case UsageState.OnlyPropertiesUsed: + case UsageState.Used: + array.push(exportInfo.name); + } + } + if (this._redirectTo !== undefined) { + const inner = this._redirectTo.getUsedExports(runtime); + if (inner === null) return null; + if (inner === true) return true; + if (inner !== false) { + for (const item of inner) { + array.push(item); + } + } + } + if (array.length === 0) { + switch (this._sideEffectsOnlyInfo.getUsed(runtime)) { + case UsageState.NoInfo: + return null; + case UsageState.Unused: + return false; + } + } + return /** @type {SortableSet} */ (new SortableSet(array)); + } + + /** + * Gets provided exports. + * @returns {null | true | ExportInfoName[]} list of exports when known + */ + getProvidedExports() { + switch (this._otherExportsInfo.provided) { + case undefined: + return null; + case null: + return true; + case true: + return true; + } + + /** @type {ExportInfoName[]} */ + const array = []; + if (!this._exportsAreOrdered) this._sortExports(); + for (const exportInfo of this._exports.values()) { + switch (exportInfo.provided) { + case undefined: + return null; + case null: + return true; + case true: + array.push(exportInfo.name); + } + } + if (this._redirectTo !== undefined) { + const inner = this._redirectTo.getProvidedExports(); + if (inner === null) return null; + if (inner === true) return true; + for (const item of inner) { + if (!array.includes(item)) { + array.push(item); + } + } + } + return array; + } + + /** + * Gets relevant exports. + * @param {RuntimeSpec} runtime the runtime + * @returns {ExportInfo[]} exports that are relevant (not unused and potential provided) + */ + getRelevantExports(runtime) { + /** @type {ExportInfo[]} */ + const list = []; + for (const exportInfo of this._exports.values()) { + const used = exportInfo.getUsed(runtime); + if (used === UsageState.Unused) continue; + if (exportInfo.provided === false) continue; + list.push(exportInfo); + } + if (this._redirectTo !== undefined) { + for (const exportInfo of this._redirectTo.getRelevantExports(runtime)) { + if (!this._exports.has(exportInfo.name)) list.push(exportInfo); + } + } + if ( + this._otherExportsInfo.provided !== false && + this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused + ) { + list.push(this._otherExportsInfo); + } + return list; + } + + /** + * Checks whether this exports info is export provided. + * @param {ExportInfoName | ExportInfoName[]} name the name of the export + * @returns {boolean | undefined | null} if the export is provided + */ + isExportProvided(name) { + if (Array.isArray(name)) { + const info = this.getReadOnlyExportInfo(name[0]); + if (info.exportsInfo && name.length > 1) { + return info.exportsInfo.isExportProvided(name.slice(1)); + } + return info.provided ? name.length === 1 || undefined : info.provided; + } + const info = this.getReadOnlyExportInfo(name); + return info.provided; + } + + /** + * Returns key representing the usage. + * @param {RuntimeSpec} runtime runtime + * @returns {string} key representing the usage + */ + getUsageKey(runtime) { + /** @type {(string | number)[]} */ + const key = []; + if (this._redirectTo !== undefined) { + key.push(this._redirectTo.getUsageKey(runtime)); + } else { + key.push(this._otherExportsInfo.getUsed(runtime)); + } + key.push(this._sideEffectsOnlyInfo.getUsed(runtime)); + for (const exportInfo of this.orderedOwnedExports) { + key.push(exportInfo.getUsed(runtime)); + } + return key.join("|"); + } + + /** + * Checks whether this exports info is equally used. + * @param {RuntimeSpec} runtimeA first runtime + * @param {RuntimeSpec} runtimeB second runtime + * @returns {boolean} true, when equally used + */ + isEquallyUsed(runtimeA, runtimeB) { + if (this._redirectTo !== undefined) { + if (!this._redirectTo.isEquallyUsed(runtimeA, runtimeB)) return false; + } else if ( + this._otherExportsInfo.getUsed(runtimeA) !== + this._otherExportsInfo.getUsed(runtimeB) + ) { + return false; + } + if ( + this._sideEffectsOnlyInfo.getUsed(runtimeA) !== + this._sideEffectsOnlyInfo.getUsed(runtimeB) + ) { + return false; + } + for (const exportInfo of this.ownedExports) { + if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB)) { + return false; + } + } + return true; + } + + /** + * Returns usage status. + * @param {ExportInfoName | ExportInfoName[]} name export name + * @param {RuntimeSpec} runtime check usage for this runtime only + * @returns {UsageStateType} usage status + */ + getUsed(name, runtime) { + if (Array.isArray(name)) { + if (name.length === 0) return this.otherExportsInfo.getUsed(runtime); + const info = this.getReadOnlyExportInfo(name[0]); + if (info.exportsInfo && name.length > 1) { + return info.exportsInfo.getUsed(name.slice(1), runtime); + } + return info.getUsed(runtime); + } + const info = this.getReadOnlyExportInfo(name); + return info.getUsed(runtime); + } + + /** + * Returns the used name. + * @param {ExportInfoName | ExportInfoName[]} name the export name + * @param {RuntimeSpec} runtime check usage for this runtime only + * @returns {UsedName} the used name + */ + getUsedName(name, runtime) { + if (Array.isArray(name)) { + // TODO improve this + if (name.length === 0) { + if (!this.isUsed(runtime)) return false; + return name; + } + const info = this.getReadOnlyExportInfo(name[0]); + const x = info.getUsedName(name[0], runtime); + if (x === false) return false; + const arr = + /** @type {ExportInfoName[]} */ + (x === name[0] && name.length === 1 ? name : [x]); + if (name.length === 1) { + return arr; + } + if ( + info.exportsInfo && + info.getUsed(runtime) === UsageState.OnlyPropertiesUsed + ) { + const nested = info.exportsInfo.getUsedName(name.slice(1), runtime); + if (!nested) return false; + return [...arr, ...(Array.isArray(nested) ? nested : [nested])]; + } + return [...arr, ...name.slice(1)]; + } + const info = this.getReadOnlyExportInfo(name); + const usedName = info.getUsedName(name, runtime); + return usedName; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash + * @param {RuntimeSpec} runtime the runtime + * @returns {void} + */ + updateHash(hash, runtime) { + this._updateHash(hash, runtime, new Set()); + } + + /** + * Updates hash using the provided hash. + * @param {Hash} hash the hash + * @param {RuntimeSpec} runtime the runtime + * @param {Set} alreadyVisitedExportsInfo for circular references + * @returns {void} + */ + _updateHash(hash, runtime, alreadyVisitedExportsInfo) { + const set = new Set(alreadyVisitedExportsInfo); + set.add(this); + for (const exportInfo of this.orderedExports) { + if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) { + exportInfo._updateHash(hash, runtime, set); + } + } + this._sideEffectsOnlyInfo._updateHash(hash, runtime, set); + this._otherExportsInfo._updateHash(hash, runtime, set); + if (this._redirectTo !== undefined) { + this._redirectTo._updateHash(hash, runtime, set); + } + } + + /** + * Gets restore provided data. + * @returns {RestoreProvidedData} restore provided data + */ + getRestoreProvidedData() { + const otherProvided = this._otherExportsInfo.provided; + const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide; + const otherTerminalBinding = this._otherExportsInfo.terminalBinding; + /** @type {RestoreProvidedDataExports[]} */ + const exports = []; + for (const exportInfo of this.orderedExports) { + if ( + exportInfo.provided !== otherProvided || + exportInfo.canMangleProvide !== otherCanMangleProvide || + exportInfo.terminalBinding !== otherTerminalBinding || + exportInfo.exportsInfoOwned + ) { + exports.push({ + name: exportInfo.name, + provided: exportInfo.provided, + canMangleProvide: exportInfo.canMangleProvide, + terminalBinding: exportInfo.terminalBinding, + exportsInfo: exportInfo.exportsInfoOwned + ? /** @type {NonNullable} */ + (exportInfo.exportsInfo).getRestoreProvidedData() + : undefined + }); + } + } + return new RestoreProvidedData( + exports, + otherProvided, + otherCanMangleProvide, + otherTerminalBinding + ); + } + + /** + * Processes the provided data. + * @param {RestoreProvidedData} data data + */ + restoreProvided({ + otherProvided, + otherCanMangleProvide, + otherTerminalBinding, + exports + }) { + let wasEmpty = true; + for (const exportInfo of this._exports.values()) { + wasEmpty = false; + exportInfo.provided = otherProvided; + exportInfo.canMangleProvide = otherCanMangleProvide; + exportInfo.terminalBinding = otherTerminalBinding; + } + this._otherExportsInfo.provided = otherProvided; + this._otherExportsInfo.canMangleProvide = otherCanMangleProvide; + this._otherExportsInfo.terminalBinding = otherTerminalBinding; + for (const exp of exports) { + const exportInfo = this.getExportInfo(exp.name); + exportInfo.provided = exp.provided; + exportInfo.canMangleProvide = exp.canMangleProvide; + exportInfo.terminalBinding = exp.terminalBinding; + if (exp.exportsInfo) { + const exportsInfo = exportInfo.createNestedExportsInfo(); + exportsInfo.restoreProvided(exp.exportsInfo); + } + } + if (wasEmpty) this._exportsAreOrdered = true; + } +} + +class ExportInfo { + /** + * Creates an instance of ExportInfo. + * @param {ExportInfoName | null} name the original name of the export + * @param {ExportInfo=} initFrom init values from this ExportInfo + */ + constructor(name, initFrom) { + /** @type {ExportInfoName} */ + this.name = /** @type {ExportInfoName} */ (name); + /** + * @private + * @type {ExportInfoUsedName} + */ + this._usedName = initFrom ? initFrom._usedName : null; + /** + * @private + * @type {UsageStateType | undefined} + */ + this._globalUsed = initFrom ? initFrom._globalUsed : undefined; + /** + * @private + * @type {UsedInRuntime | undefined} + */ + this._usedInRuntime = + initFrom && initFrom._usedInRuntime + ? new Map(initFrom._usedInRuntime) + : undefined; + /** + * @private + * @type {boolean} + */ + this._hasUseInRuntimeInfo = initFrom + ? initFrom._hasUseInRuntimeInfo + : false; + /** + * true: it is provided + * false: it is not provided + * null: only the runtime knows if it is provided + * undefined: it was not determined if it is provided + * @type {ExportInfoProvided | undefined} + */ + this.provided = initFrom ? initFrom.provided : undefined; + /** + * is the export a terminal binding that should be checked for export star conflicts + * @type {boolean} + */ + this.terminalBinding = initFrom ? initFrom.terminalBinding : false; + /** + * true: it can be mangled + * false: is can not be mangled + * undefined: it was not determined if it can be mangled + * @type {boolean | undefined} + */ + this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined; + /** + * true: it can be mangled + * false: is can not be mangled + * undefined: it was not determined if it can be mangled + * @type {boolean | undefined} + */ + this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined; + /** @type {boolean} */ + this.exportsInfoOwned = false; + /** @type {ExportsInfo | undefined} */ + this.exportsInfo = undefined; + /** @type {Target | undefined} */ + this._target = undefined; + if (initFrom && initFrom._target) { + this._target = /** @type {Target} */ (new Map()); + for (const [key, value] of initFrom._target) { + this._target.set(key, { + connection: value.connection, + export: value.export || [name], + priority: value.priority + }); + } + } + /** @type {Target | undefined} */ + this._maxTarget = undefined; + } + + get canMangle() { + switch (this.canMangleProvide) { + case undefined: + return this.canMangleUse === false ? false : undefined; + case false: + return false; + case true: + switch (this.canMangleUse) { + case undefined: + return undefined; + case false: + return false; + case true: + return true; + } + } + throw new Error( + `Unexpected flags for canMangle ${this.canMangleProvide} ${this.canMangleUse}` + ); + } + + /** + * Sets used in unknown way. + * @param {RuntimeSpec} runtime only apply to this runtime + * @returns {boolean} true, when something changed + */ + setUsedInUnknownWay(runtime) { + let changed = false; + if ( + this.setUsedConditionally( + (used) => used < UsageState.Unknown, + UsageState.Unknown, + runtime + ) + ) { + changed = true; + } + if (this.canMangleUse !== false) { + this.canMangleUse = false; + changed = true; + } + return changed; + } + + /** + * Sets used without info. + * @param {RuntimeSpec} runtime only apply to this runtime + * @returns {boolean} true, when something changed + */ + setUsedWithoutInfo(runtime) { + let changed = false; + if (this.setUsed(UsageState.NoInfo, runtime)) { + changed = true; + } + if (this.canMangleUse !== false) { + this.canMangleUse = false; + changed = true; + } + return changed; + } + + setHasProvideInfo() { + if (this.provided === undefined) { + this.provided = false; + } + if (this.canMangleProvide === undefined) { + this.canMangleProvide = true; + } + } + + setHasUseInfo() { + if (!this._hasUseInRuntimeInfo) { + this._hasUseInRuntimeInfo = true; + } + if (this.canMangleUse === undefined) { + this.canMangleUse = true; + } + if (this.exportsInfoOwned) { + /** @type {ExportsInfo} */ + (this.exportsInfo).setHasUseInfo(); + } + } + + /** + * Sets used conditionally. + * @param {(condition: UsageStateType) => boolean} condition compare with old value + * @param {UsageStateType} newValue set when condition is true + * @param {RuntimeSpec} runtime only apply to this runtime + * @returns {boolean} true when something has changed + */ + setUsedConditionally(condition, newValue, runtime) { + if (runtime === undefined) { + if (this._globalUsed === undefined) { + this._globalUsed = newValue; + return true; + } + if (this._globalUsed !== newValue && condition(this._globalUsed)) { + this._globalUsed = newValue; + return true; + } + } else if (this._usedInRuntime === undefined) { + if (newValue !== UsageState.Unused && condition(UsageState.Unused)) { + this._usedInRuntime = new Map(); + forEachRuntime(runtime, (runtime) => + /** @type {UsedInRuntime} */ + (this._usedInRuntime).set(/** @type {string} */ (runtime), newValue) + ); + return true; + } + } else { + let changed = false; + forEachRuntime(runtime, (runtime_) => { + const runtime = /** @type {string} */ (runtime_); + const usedInRuntime = + /** @type {UsedInRuntime} */ + (this._usedInRuntime); + let oldValue = + /** @type {UsageStateType} */ + (usedInRuntime.get(runtime)); + if (oldValue === undefined) oldValue = UsageState.Unused; + if (newValue !== oldValue && condition(oldValue)) { + if (newValue === UsageState.Unused) { + usedInRuntime.delete(runtime); + } else { + usedInRuntime.set(runtime, newValue); + } + changed = true; + } + }); + if (changed) { + if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined; + return true; + } + } + return false; + } + + /** + * Updates used using the provided new value. + * @param {UsageStateType} newValue new value of the used state + * @param {RuntimeSpec} runtime only apply to this runtime + * @returns {boolean} true when something has changed + */ + setUsed(newValue, runtime) { + if (runtime === undefined) { + if (this._globalUsed !== newValue) { + this._globalUsed = newValue; + return true; + } + } else if (this._usedInRuntime === undefined) { + if (newValue !== UsageState.Unused) { + this._usedInRuntime = new Map(); + forEachRuntime(runtime, (runtime) => + /** @type {UsedInRuntime} */ + (this._usedInRuntime).set(/** @type {string} */ (runtime), newValue) + ); + return true; + } + } else { + let changed = false; + forEachRuntime(runtime, (_runtime) => { + const runtime = /** @type {string} */ (_runtime); + const usedInRuntime = + /** @type {UsedInRuntime} */ + (this._usedInRuntime); + let oldValue = + /** @type {UsageStateType} */ + (usedInRuntime.get(runtime)); + if (oldValue === undefined) oldValue = UsageState.Unused; + if (newValue !== oldValue) { + if (newValue === UsageState.Unused) { + usedInRuntime.delete(runtime); + } else { + usedInRuntime.set(runtime, newValue); + } + changed = true; + } + }); + if (changed) { + if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined; + return true; + } + } + return false; + } + + /** + * Returns true, if something has changed. + * @param {Dependency} key the key + * @returns {boolean} true, if something has changed + */ + unsetTarget(key) { + if (!this._target) return false; + if (this._target.delete(key)) { + this._maxTarget = undefined; + return true; + } + return false; + } + + /** + * Updates target using the provided key. + * @param {Dependency} key the key + * @param {ModuleGraphConnection} connection the target module if a single one + * @param {ExportInfoName[] | null=} exportName the exported name + * @param {number=} priority priority + * @returns {boolean} true, if something has changed + */ + setTarget(key, connection, exportName, priority = 0) { + if (exportName) exportName = [...exportName]; + if (!this._target) { + this._target = /** @type {Target} */ (new Map()); + this._target.set(key, { + connection, + export: /** @type {ExportInfoName[]} */ (exportName), + priority + }); + return true; + } + const oldTarget = this._target.get(key); + if (!oldTarget) { + if (oldTarget === null && !connection) return false; + this._target.set(key, { + connection, + export: /** @type {ExportInfoName[]} */ (exportName), + priority + }); + this._maxTarget = undefined; + return true; + } + if ( + oldTarget.connection !== connection || + oldTarget.priority !== priority || + (exportName + ? !oldTarget.export || !equals(oldTarget.export, exportName) + : oldTarget.export) + ) { + oldTarget.connection = connection; + oldTarget.export = /** @type {ExportInfoName[]} */ (exportName); + oldTarget.priority = priority; + this._maxTarget = undefined; + return true; + } + return false; + } + + /** + * Returns usage state. + * @param {RuntimeSpec} runtime for this runtime + * @returns {UsageStateType} usage state + */ + getUsed(runtime) { + if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo; + if (this._globalUsed !== undefined) return this._globalUsed; + if (this._usedInRuntime === undefined) { + return UsageState.Unused; + } else if (typeof runtime === "string") { + const value = this._usedInRuntime.get(runtime); + return value === undefined ? UsageState.Unused : value; + } else if (runtime === undefined) { + /** @type {UsageStateType} */ + let max = UsageState.Unused; + for (const value of this._usedInRuntime.values()) { + if (value === UsageState.Used) { + return UsageState.Used; + } + if (max < value) max = value; + } + return max; + } + + /** @type {UsageStateType} */ + let max = UsageState.Unused; + for (const item of runtime) { + const value = this._usedInRuntime.get(item); + if (value !== undefined) { + if (value === UsageState.Used) { + return UsageState.Used; + } + if (max < value) max = value; + } + } + return max; + } + + /** + * Returns used name. + * @param {string | undefined} fallbackName fallback name for used exports with no name + * @param {RuntimeSpec} runtime check usage for this runtime only + * @returns {string | false} used name + */ + getUsedName(fallbackName, runtime) { + if (this._hasUseInRuntimeInfo) { + if (this._globalUsed !== undefined) { + if (this._globalUsed === UsageState.Unused) return false; + } else { + if (this._usedInRuntime === undefined) return false; + if (typeof runtime === "string") { + if (!this._usedInRuntime.has(runtime)) { + return false; + } + } else if ( + runtime !== undefined && + [...runtime].every( + (runtime) => + !(/** @type {UsedInRuntime} */ (this._usedInRuntime).has(runtime)) + ) + ) { + return false; + } + } + } + if (this._usedName !== null) return this._usedName; + return /** @type {string | false} */ (this.name || fallbackName); + } + + /** + * Checks whether this export info has used name. + * @returns {boolean} true, when a mangled name of this export is set + */ + hasUsedName() { + return this._usedName !== null; + } + + /** + * Updates used name using the provided name. + * @param {string} name the new name + * @returns {void} + */ + setUsedName(name) { + this._usedName = name; + } + + /** + * Gets terminal binding. + * @param {ModuleGraph} moduleGraph the module graph + * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target + * @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known + */ + getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) { + if (this.terminalBinding) return this; + const target = this.getTarget(moduleGraph, resolveTargetFilter); + if (!target) return; + const exportsInfo = moduleGraph.getExportsInfo(target.module); + if (!target.export) return exportsInfo; + return exportsInfo.getReadOnlyExportInfoRecursive(target.export); + } + + isReexport() { + return !this.terminalBinding && this._target && this._target.size > 0; + } + + _getMaxTarget() { + if (this._maxTarget !== undefined) return this._maxTarget; + if (/** @type {Target} */ (this._target).size <= 1) { + return (this._maxTarget = this._target); + } + let maxPriority = -Infinity; + let minPriority = Infinity; + for (const { priority } of /** @type {Target} */ (this._target).values()) { + if (maxPriority < priority) maxPriority = priority; + if (minPriority > priority) minPriority = priority; + } + // This should be very common + if (maxPriority === minPriority) return (this._maxTarget = this._target); + + // This is an edge case + /** @type {Target} */ + const map = new Map(); + for (const [key, value] of /** @type {Target} */ (this._target)) { + if (maxPriority === value.priority) { + map.set(key, value); + } + } + this._maxTarget = map; + return map; + } + + /** + * Returns the target, undefined when there is no target, false when no target is valid. + * @param {ModuleGraph} moduleGraph the module graph + * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module + * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid + */ + findTarget(moduleGraph, validTargetModuleFilter) { + return this._findTarget(moduleGraph, validTargetModuleFilter, new Set()); + } + + /** + * Returns the target, undefined when there is no target, false when no target is valid. + * @param {ModuleGraph} moduleGraph the module graph + * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module + * @param {AlreadyVisitedExportInfo} alreadyVisited set of already visited export info to avoid circular references + * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid + */ + _findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) { + if (!this._target || this._target.size === 0) return; + const rawTarget = + /** @type {Target} */ + (this._getMaxTarget()).values().next().value; + if (!rawTarget) return; + /** @type {TargetItemWithoutConnection} */ + let target = { + module: rawTarget.connection.module, + export: rawTarget.export, + deferred: Boolean( + rawTarget.connection.dependency && + ImportPhaseUtils.isDefer( + /** @type {HarmonyImportDependency} */ ( + rawTarget.connection.dependency + ).phase + ) + ) + }; + for (;;) { + if (validTargetModuleFilter(target.module)) return target; + const exportsInfo = moduleGraph.getExportsInfo(target.module); + const exportInfo = exportsInfo.getExportInfo(target.export[0]); + if (alreadyVisited.has(exportInfo)) return null; + const newTarget = exportInfo._findTarget( + moduleGraph, + validTargetModuleFilter, + alreadyVisited + ); + if (!newTarget) return false; + if (target.export.length === 1) { + target = newTarget; + } else { + target = { + module: newTarget.module, + export: newTarget.export + ? [...newTarget.export, ...target.export.slice(1)] + : target.export.slice(1), + deferred: newTarget.deferred + }; + } + } + } + + /** + * Returns the target. + * @param {ModuleGraph} moduleGraph the module graph + * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target + * @returns {TargetItemWithConnection | undefined} the target + */ + getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) { + const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined); + if (result === CIRCULAR) return; + return result; + } + + /** + * Returns the target. + * @param {ModuleGraph} moduleGraph the module graph + * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target + * @param {AlreadyVisitedExportInfo | undefined} alreadyVisited set of already visited export info to avoid circular references + * @returns {TargetItemWithConnection | CIRCULAR | undefined} the target + */ + _getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) { + /** + * Returns resolved target. + * @param {TargetItem | undefined | null} inputTarget unresolved target + * @param {AlreadyVisitedExportInfo} alreadyVisited set of already visited export info to avoid circular references + * @returns {TargetItemWithConnection | CIRCULAR | null} resolved target + */ + const resolveTarget = (inputTarget, alreadyVisited) => { + if (!inputTarget) return null; + if (!inputTarget.export) { + return { + module: inputTarget.connection.module, + connection: inputTarget.connection, + export: undefined + }; + } + /** @type {TargetItemWithConnection} */ + let target = { + module: inputTarget.connection.module, + connection: inputTarget.connection, + export: inputTarget.export + }; + if (!resolveTargetFilter(target)) return target; + let alreadyVisitedOwned = false; + for (;;) { + const exportsInfo = moduleGraph.getExportsInfo(target.module); + const exportInfo = exportsInfo.getExportInfo( + /** @type {NonNullable} */ + (target.export)[0] + ); + if (!exportInfo) return target; + if (alreadyVisited.has(exportInfo)) return CIRCULAR; + const newTarget = exportInfo._getTarget( + moduleGraph, + resolveTargetFilter, + alreadyVisited + ); + if (newTarget === CIRCULAR) return CIRCULAR; + if (!newTarget) return target; + if ( + /** @type {NonNullable} */ + (target.export).length === 1 + ) { + target = newTarget; + if (!target.export) return target; + } else { + target = { + module: newTarget.module, + connection: newTarget.connection, + export: newTarget.export + ? [ + ...newTarget.export, + .../** @type {NonNullable} */ + (target.export).slice(1) + ] + : /** @type {NonNullable} */ + (target.export).slice(1) + }; + } + if (!resolveTargetFilter(target)) return target; + if (!alreadyVisitedOwned) { + alreadyVisited = new Set(alreadyVisited); + alreadyVisitedOwned = true; + } + alreadyVisited.add(exportInfo); + } + }; + + if (!this._target || this._target.size === 0) return; + if (alreadyVisited && alreadyVisited.has(this)) return CIRCULAR; + const newAlreadyVisited = new Set(alreadyVisited); + newAlreadyVisited.add(this); + const values = /** @type {Target} */ (this._getMaxTarget()).values(); + const target = resolveTarget(values.next().value, newAlreadyVisited); + if (target === CIRCULAR) return CIRCULAR; + if (target === null) return; + let result = values.next(); + while (!result.done) { + const t = resolveTarget(result.value, newAlreadyVisited); + if (t === CIRCULAR) return CIRCULAR; + if (t === null) return; + if (t.module !== target.module) return; + if (!t.export !== !target.export) return; + if ( + target.export && + !equals(/** @type {ArrayLike} */ (t.export), target.export) + ) { + return; + } + result = values.next(); + } + return target; + } + + /** + * Move the target forward as long resolveTargetFilter is fulfilled + * @param {ModuleGraph} moduleGraph the module graph + * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target + * @param {(target: TargetItemWithConnection) => ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection + * @returns {TargetItemWithConnection | undefined} the resolved target when moved + */ + moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) { + const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined); + if (target === CIRCULAR) return; + if (!target) return; + const originalTarget = + /** @type {TargetItem} */ + ( + /** @type {Target} */ + (this._getMaxTarget()).values().next().value + ); + if ( + originalTarget.connection === target.connection && + originalTarget.export === target.export + ) { + return; + } + /** @type {Target} */ + (this._target).clear(); + /** @type {Target} */ + (this._target).set(undefined, { + connection: updateOriginalConnection + ? updateOriginalConnection(target) + : target.connection, + export: /** @type {NonNullable} */ ( + target.export + ), + priority: 0 + }); + return target; + } + + /** + * Creates a nested exports info. + * @returns {ExportsInfo} an exports info + */ + createNestedExportsInfo() { + if (this.exportsInfoOwned) { + return /** @type {ExportsInfo} */ (this.exportsInfo); + } + this.exportsInfoOwned = true; + const oldExportsInfo = this.exportsInfo; + this.exportsInfo = new ExportsInfo(); + this.exportsInfo.setHasProvideInfo(); + if (oldExportsInfo) { + this.exportsInfo.setRedirectNamedTo(oldExportsInfo); + } + return this.exportsInfo; + } + + getNestedExportsInfo() { + return this.exportsInfo; + } + + /** + * Checks whether this export info contains the base info. + * @param {ExportInfo} baseInfo base info + * @param {RuntimeSpec} runtime runtime + * @returns {boolean} true when has info, otherwise false + */ + hasInfo(baseInfo, runtime) { + return ( + (this._usedName && this._usedName !== this.name) || + this.provided || + this.terminalBinding || + this.getUsed(runtime) !== baseInfo.getUsed(runtime) + ); + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash + * @param {RuntimeSpec} runtime the runtime + * @returns {void} + */ + updateHash(hash, runtime) { + this._updateHash(hash, runtime, new Set()); + } + + /** + * Updates hash using the provided hash. + * @param {Hash} hash the hash + * @param {RuntimeSpec} runtime the runtime + * @param {Set} alreadyVisitedExportsInfo for circular references + */ + _updateHash(hash, runtime, alreadyVisitedExportsInfo) { + hash.update( + `${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${ + this.terminalBinding + }` + ); + if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) { + this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo); + } + } + + getUsedInfo() { + if (this._globalUsed !== undefined) { + switch (this._globalUsed) { + case UsageState.Unused: + return "unused"; + case UsageState.NoInfo: + return "no usage info"; + case UsageState.Unknown: + return "maybe used (runtime-defined)"; + case UsageState.Used: + return "used"; + case UsageState.OnlyPropertiesUsed: + return "only properties used"; + } + } else if (this._usedInRuntime !== undefined) { + /** @type {Map} */ + const map = new Map(); + for (const [runtime, used] of this._usedInRuntime) { + const list = map.get(used); + if (list !== undefined) list.push(runtime); + else map.set(used, [runtime]); + } + // eslint-disable-next-line array-callback-return + const specificInfo = Array.from(map, ([used, runtimes]) => { + switch (used) { + case UsageState.NoInfo: + return `no usage info in ${runtimes.join(", ")}`; + case UsageState.Unknown: + return `maybe used in ${runtimes.join(", ")} (runtime-defined)`; + case UsageState.Used: + return `used in ${runtimes.join(", ")}`; + case UsageState.OnlyPropertiesUsed: + return `only properties used in ${runtimes.join(", ")}`; + } + }); + if (specificInfo.length > 0) { + return specificInfo.join("; "); + } + } + return this._hasUseInRuntimeInfo ? "unused" : "no usage info"; + } + + getProvidedInfo() { + switch (this.provided) { + case undefined: + return "no provided info"; + case null: + return "maybe provided (runtime-defined)"; + case true: + return "provided"; + case false: + return "not provided"; + } + } + + getRenameInfo() { + if (this._usedName !== null && this._usedName !== this.name) { + return `renamed to ${JSON.stringify(this._usedName).slice(1, -1)}`; + } + switch (this.canMangleProvide) { + case undefined: + switch (this.canMangleUse) { + case undefined: + return "missing provision and use info prevents renaming"; + case false: + return "usage prevents renaming (no provision info)"; + case true: + return "missing provision info prevents renaming"; + } + break; + case true: + switch (this.canMangleUse) { + case undefined: + return "missing usage info prevents renaming"; + case false: + return "usage prevents renaming"; + case true: + return "could be renamed"; + } + break; + case false: + switch (this.canMangleUse) { + case undefined: + return "provision prevents renaming (no use info)"; + case false: + return "usage and provision prevents renaming"; + case true: + return "provision prevents renaming"; + } + break; + } + throw new Error( + `Unexpected flags for getRenameInfo ${this.canMangleProvide} ${this.canMangleUse}` + ); + } +} + +module.exports = ExportsInfo; +module.exports.ExportInfo = ExportInfo; +module.exports.RestoreProvidedData = RestoreProvidedData; +module.exports.UsageState = UsageState; Index: frontend/node_modules/webpack/lib/ExportsInfoApiPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ExportsInfoApiPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ExportsInfoApiPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,88 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const ConstDependency = require("./dependencies/ConstDependency"); +const ExportsInfoDependency = require("./dependencies/ExportsInfoDependency"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ + +const PLUGIN_NAME = "ExportsInfoApiPlugin"; + +class ExportsInfoApiPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyTemplates.set( + ExportsInfoDependency, + new ExportsInfoDependency.Template() + ); + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + * @returns {void} + */ + const handler = (parser) => { + parser.hooks.expressionMemberChain + .for("__webpack_exports_info__") + .tap(PLUGIN_NAME, (expr, members) => { + const dep = + members.length >= 2 + ? new ExportsInfoDependency( + /** @type {Range} */ (expr.range), + members.slice(0, -1), + members[members.length - 1] + ) + : new ExportsInfoDependency( + /** @type {Range} */ (expr.range), + null, + members[0] + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addDependency(dep); + return true; + }); + parser.hooks.expression + .for("__webpack_exports_info__") + .tap(PLUGIN_NAME, (expr) => { + const dep = new ConstDependency( + "true", + /** @type {Range} */ (expr.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return true; + }); + }; + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } +} + +module.exports = ExportsInfoApiPlugin; Index: frontend/node_modules/webpack/lib/ExternalModule.js =================================================================== --- frontend/node_modules/webpack/lib/ExternalModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ExternalModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1305 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { SyncBailHook } = require("tapable"); +const { OriginalSource, RawSource } = require("webpack-sources"); +const ConcatenationScope = require("./ConcatenationScope"); +const { UsageState } = require("./ExportsInfo"); +const InitFragment = require("./InitFragment"); +const Module = require("./Module"); +const { + ASSET_URL_TYPE, + ASSET_URL_TYPES, + CSS_IMPORT_TYPES, + JAVASCRIPT_TYPE, + JAVASCRIPT_TYPES +} = require("./ModuleSourceTypeConstants"); +const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const Template = require("./Template"); +const { DEFAULTS } = require("./config/defaults"); +const { ImportPhaseUtils } = require("./dependencies/ImportPhase"); +const StaticExportsDependency = require("./dependencies/StaticExportsDependency"); +const EnvironmentNotSupportAsyncWarning = require("./errors/EnvironmentNotSupportAsyncWarning"); +const createHash = require("./util/createHash"); +const extractUrlAndGlobal = require("./util/extractUrlAndGlobal"); +const makeSerializable = require("./util/makeSerializable"); +const { propertyAccess } = require("./util/property"); +const { register } = require("./util/serialization"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */ +/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */ +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Compilation").UnsafeCacheData} UnsafeCacheData */ +/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("./ExportsInfo")} ExportsInfo */ +/** @typedef {import("./Generator").GenerateContext} GenerateContext */ +/** @typedef {import("./Generator").SourceTypes} SourceTypes */ +/** @typedef {import("./Module").ModuleId} ModuleId */ +/** @typedef {import("./Module").BuildCallback} BuildCallback */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */ +/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */ +/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */ +/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */ +/** @typedef {import("./Module").LibIdent} LibIdent */ +/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */ +/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */ +/** @typedef {import("./Module").Sources} Sources */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */ +/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */ +/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** @typedef {{ attributes?: ImportAttributes, phase?: ImportPhaseType, externalType: "import" | "module" | undefined }} ImportDependencyMeta */ +/** @typedef {{ layer?: string, supports?: string, media?: string }} CssImportDependencyMeta */ +/** @typedef {{ sourceType: "asset-url" | "css-url" }} AssetDependencyMeta */ + +/** @typedef {ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta} DependencyMeta */ + +/** + * Defines the source data type used by this module. + * @typedef {object} SourceData + * @property {boolean=} iife + * @property {string=} init + * @property {string} expression + * @property {InitFragment[]=} chunkInitFragments + * @property {ReadOnlyRuntimeRequirements=} runtimeRequirements + * @property {[string, string][]=} specifiers + */ + +/** @typedef {true | [string, string][]} Imported */ + +/** @type {RuntimeRequirements} */ +const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]); +/** @type {RuntimeRequirements} */ +const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]); +/** @type {RuntimeRequirements} */ +const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([ + RuntimeGlobals.definePropertyGetters +]); +/** @type {RuntimeRequirements} */ +const EMPTY_RUNTIME_REQUIREMENTS = new Set(); + +/** + * Gets source for global variable external. + * @param {string | string[]} variableName the variable name or path + * @param {string} type the module system + * @returns {SourceData} the generated source + */ +const getSourceForGlobalVariableExternal = (variableName, type) => { + if (!Array.isArray(variableName)) { + // make it an array as the look up works the same basically + variableName = [variableName]; + } + + // needed for e.g. window["some"]["thing"] + const objectLookup = variableName + .map((r) => `[${JSON.stringify(r)}]`) + .join(""); + return { + iife: type === "this", + expression: `${type}${objectLookup}` + }; +}; + +/** @typedef {string | string[]} ModuleAndSpecifiers */ + +/** + * Gets source for common js external. + * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request + * @returns {SourceData} the generated source + */ +const getSourceForCommonJsExternal = (moduleAndSpecifiers) => { + if (!Array.isArray(moduleAndSpecifiers)) { + return { + expression: `require(${JSON.stringify(moduleAndSpecifiers)})` + }; + } + const moduleName = moduleAndSpecifiers[0]; + return { + expression: `require(${JSON.stringify(moduleName)})${propertyAccess( + moduleAndSpecifiers, + 1 + )}` + }; +}; + +/** + * Gets external module node commonjs init fragment. + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @returns {InitFragment} code + */ +const getExternalModuleNodeCommonjsInitFragment = (runtimeTemplate) => { + const importMetaName = runtimeTemplate.outputOptions.importMetaName; + + return new InitFragment( + `import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${runtimeTemplate.renderNodePrefixForCoreModule( + "module" + )};\n${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = __WEBPACK_EXTERNAL_createRequire(${importMetaName}.url);\n`, + InitFragment.STAGE_HARMONY_IMPORTS, + 0, + "external module node-commonjs" + ); +}; + +/** + * Gets source for common js external in node module. + * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @returns {SourceData} the generated source + */ +const getSourceForCommonJsExternalInNodeModule = ( + moduleAndSpecifiers, + runtimeTemplate +) => { + const chunkInitFragments = [ + getExternalModuleNodeCommonjsInitFragment(runtimeTemplate) + ]; + if (!Array.isArray(moduleAndSpecifiers)) { + return { + chunkInitFragments, + expression: `__WEBPACK_EXTERNAL_createRequire_require(${JSON.stringify( + moduleAndSpecifiers + )})` + }; + } + const moduleName = moduleAndSpecifiers[0]; + return { + chunkInitFragments, + expression: `__WEBPACK_EXTERNAL_createRequire_require(${JSON.stringify( + moduleName + )})${propertyAccess(moduleAndSpecifiers, 1)}` + }; +}; + +/** + * Gets source for import external. + * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @param {ImportDependencyMeta=} dependencyMeta the dependency meta + * @returns {SourceData} the generated source + */ +const getSourceForImportExternal = ( + moduleAndSpecifiers, + runtimeTemplate, + dependencyMeta +) => { + const baseImportName = runtimeTemplate.outputOptions.importFunctionName; + if ( + !runtimeTemplate.supportsDynamicImport() && + (baseImportName === "import" || baseImportName === "module-import") + ) { + throw new Error( + "The target environment doesn't support 'import()' so it's not possible to use external type 'import'" + ); + } + const phase = dependencyMeta && dependencyMeta.phase; + // `import.defer(…)` and `import.source(…)` are only valid forms of the + // native `import(…)` function, so we only emit the phase suffix when the + // importFunctionName is the default `"import"`. + const importName = + baseImportName === "import" && ImportPhaseUtils.isDefer(phase) + ? "import.defer" + : baseImportName === "import" && ImportPhaseUtils.isSource(phase) + ? "import.source" + : baseImportName; + const attributes = + dependencyMeta && dependencyMeta.attributes + ? dependencyMeta.attributes._isLegacyAssert + ? `, { assert: ${JSON.stringify( + dependencyMeta.attributes, + importAssertionReplacer + )} }` + : `, { with: ${JSON.stringify(dependencyMeta.attributes)} }` + : ""; + if (!Array.isArray(moduleAndSpecifiers)) { + return { + expression: `${importName}(${JSON.stringify( + moduleAndSpecifiers + )}${attributes});` + }; + } + if (moduleAndSpecifiers.length === 1) { + return { + expression: `${importName}(${JSON.stringify( + moduleAndSpecifiers[0] + )}${attributes});` + }; + } + const moduleName = moduleAndSpecifiers[0]; + return { + expression: `${importName}(${JSON.stringify( + moduleName + )}${attributes}).then(${runtimeTemplate.returningFunction( + `module${propertyAccess(moduleAndSpecifiers, 1)}`, + "module" + )});` + }; +}; + +/** + * Import assertion replacer. + * @param {string} key key + * @param {ImportAttributes | string | boolean | undefined} value value + * @returns {ImportAttributes | string | boolean | undefined} replaced value + */ +const importAssertionReplacer = (key, value) => { + if (key === "_isLegacyAssert") { + return; + } + + return value; +}; + +/** + * Represents ModuleExternalInitFragment. + * @extends {InitFragment} + */ +class ModuleExternalInitFragment extends InitFragment { + /** + * Creates an instance of ModuleExternalInitFragment. + * @param {string} request import source + * @param {Imported} imported the imported specifiers + * @param {string=} ident recomputed ident + * @param {ImportDependencyMeta=} dependencyMeta the dependency meta + * @param {HashFunction=} hashFunction the hash function to use + */ + constructor( + request, + imported, + ident, + dependencyMeta, + hashFunction = DEFAULTS.HASH_FUNCTION + ) { + if (ident === undefined) { + ident = Template.toIdentifier(request); + if (ident !== request) { + ident += `_${createHash(hashFunction) + .update(request) + .digest("hex") + .slice(0, 8)}`; + } + } + + super( + "", + InitFragment.STAGE_HARMONY_IMPORTS, + 0, + `external module import ${ident} ${ + imported === true ? imported : imported.join(" ") + }` + ); + this._ident = ident; + this._request = request; + this._dependencyMeta = dependencyMeta; + this._identifier = this.buildIdentifier(ident); + this._imported = this.buildImported(imported); + } + + /** + * Returns imported. + * @returns {Imported} imported + */ + getImported() { + return this._imported; + } + + /** + * Updates imported using the provided imported. + * @param {Imported} imported imported + */ + setImported(imported) { + this._imported = imported; + } + + /** + * Returns the source code that will be included as initialization code. + * @param {GenerateContext} context context + * @returns {string | Source | undefined} the source code that will be included as initialization code + */ + getContent(context) { + const { + _dependencyMeta: dependencyMeta, + _imported: imported, + _request: request, + _identifier: identifier + } = this; + const attributes = + dependencyMeta && dependencyMeta.attributes + ? dependencyMeta.attributes._isLegacyAssert + ? ` assert ${JSON.stringify( + dependencyMeta.attributes, + importAssertionReplacer + )}` + : ` with ${JSON.stringify(dependencyMeta.attributes)}` + : ""; + const phase = dependencyMeta && dependencyMeta.phase; + let content = ""; + if (imported === true) { + // namespace + const phaseKeyword = ImportPhaseUtils.isDefer(phase) ? "defer " : ""; + content = `import ${phaseKeyword}* as ${identifier} from ${JSON.stringify( + request + )}${attributes};\n`; + } else if (imported.length === 0) { + // just import, no use + content = `import ${JSON.stringify(request)}${attributes};\n`; + } else if ( + ImportPhaseUtils.isSource(phase) && + imported.length === 1 && + imported[0][0] === "default" + ) { + // `import source x from "…"` — the source-phase form binds the source + // object directly to a single identifier (no namespace, no destructuring). + content = `import source ${imported[0][1]} from ${JSON.stringify( + request + )}${attributes};\n`; + } else { + content = `import { ${imported + .map(([name, finalName]) => { + if (name !== finalName) { + return `${name} as ${finalName}`; + } + return name; + }) + .join(", ")} } from ${JSON.stringify(request)}${attributes};\n`; + } + return content; + } + + getNamespaceIdentifier() { + return this._identifier; + } + + /** + * Returns identifier. + * @param {string} ident ident + * @returns {string} identifier + */ + buildIdentifier(ident) { + return `__WEBPACK_EXTERNAL_MODULE_${ident}__`; + } + + /** + * Returns normalized imported. + * @param {Imported} imported imported + * @returns {Imported} normalized imported + */ + buildImported(imported) { + if (Array.isArray(imported)) { + return imported.map(([name]) => { + const ident = `${this._ident}_${name}`; + return [name, this.buildIdentifier(ident)]; + }); + } + return imported; + } +} + +register( + ModuleExternalInitFragment, + "webpack/lib/ExternalModule", + "ModuleExternalInitFragment", + { + serialize(obj, { write }) { + write(obj._request); + write(obj._imported); + write(obj._ident); + write(obj._dependencyMeta); + }, + deserialize({ read }) { + return new ModuleExternalInitFragment(read(), read(), read(), read()); + } + } +); + +/** + * Generates module remapping. + * @param {string} input input + * @param {ExportsInfo} exportsInfo the exports info + * @param {RuntimeSpec=} runtime the runtime + * @param {RuntimeTemplate=} runtimeTemplate the runtime template + * @returns {string | undefined} the module remapping + */ +const generateModuleRemapping = ( + input, + exportsInfo, + runtime, + runtimeTemplate +) => { + if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) { + /** @type {string[]} */ + const properties = []; + for (const exportInfo of exportsInfo.orderedExports) { + const used = exportInfo.getUsedName(exportInfo.name, runtime); + if (!used) continue; + const nestedInfo = exportInfo.getNestedExportsInfo(); + if (nestedInfo) { + const nestedExpr = generateModuleRemapping( + `${input}${propertyAccess([exportInfo.name])}`, + nestedInfo + ); + if (nestedExpr) { + properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`); + continue; + } + } + properties.push( + `[${JSON.stringify(used)}]: ${ + /** @type {RuntimeTemplate} */ (runtimeTemplate).returningFunction( + `${input}${propertyAccess([exportInfo.name])}` + ) + }` + ); + } + return `x({ ${properties.join(", ")} })`; + } +}; + +/** + * Gets source for module external. + * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request + * @param {ExportsInfo} exportsInfo exports info of this module + * @param {RuntimeSpec} runtime the runtime + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @param {ImportDependencyMeta} dependencyMeta the dependency meta + * @param {ConcatenationScope=} concatenationScope concatenationScope + * @returns {SourceData} the generated source + */ +const getSourceForModuleExternal = ( + moduleAndSpecifiers, + exportsInfo, + runtime, + runtimeTemplate, + dependencyMeta, + concatenationScope +) => { + const phase = dependencyMeta && dependencyMeta.phase; + /** @type {Imported} */ + let imported = true; + if (concatenationScope) { + const usedExports = exportsInfo.getUsedExports(runtime); + switch (usedExports) { + case true: + case null: + // unknown exports + imported = true; + break; + case false: + // no used exports + imported = []; + break; + default: + imported = [...usedExports.entries()]; + } + } + + if (!Array.isArray(moduleAndSpecifiers)) { + moduleAndSpecifiers = [moduleAndSpecifiers]; + } + + // Return to `namespace` when the external request includes a specific export + if (moduleAndSpecifiers.length > 1) { + imported = true; + } + + // `import defer …` is only valid as `import defer * as ns from "…"`, so + // keep the namespace form even if usage analysis would otherwise narrow + // the import down to specific names. Defer + concatenation is semantically + // at odds (lazy vs. eager), so we preserve the user-written shape here. + if (ImportPhaseUtils.isDefer(phase)) { + imported = true; + } + + const initFragment = new ModuleExternalInitFragment( + moduleAndSpecifiers[0], + imported, + undefined, + dependencyMeta, + runtimeTemplate.outputOptions.hashFunction + ); + const normalizedImported = initFragment.getImported(); + + const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess( + moduleAndSpecifiers, + 1 + )}`; + let expression = baseAccess; + + const useNamespace = imported === true; + /** @type {undefined | string} */ + let moduleRemapping; + if (useNamespace) { + moduleRemapping = generateModuleRemapping( + baseAccess, + exportsInfo, + runtime, + runtimeTemplate + ); + expression = moduleRemapping || baseAccess; + } + return { + expression, + init: moduleRemapping + ? `var x = ${runtimeTemplate.basicFunction( + "y", + `var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x` + )} \nvar y = ${runtimeTemplate.returningFunction( + runtimeTemplate.returningFunction("x"), + "x" + )}` + : undefined, + specifiers: normalizedImported === true ? undefined : normalizedImported, + runtimeRequirements: moduleRemapping + ? RUNTIME_REQUIREMENTS_FOR_MODULE + : undefined, + chunkInitFragments: [ + /** @type {InitFragment} */ (initFragment) + ] + }; +}; + +/** + * Gets source for script external. + * @param {string | string[]} urlAndGlobal the script request + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @returns {SourceData} the generated source + */ +const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => { + if (typeof urlAndGlobal === "string") { + urlAndGlobal = extractUrlAndGlobal(urlAndGlobal); + } + const url = urlAndGlobal[0]; + const globalName = urlAndGlobal[1]; + return { + init: "var __webpack_error__ = new Error();", + expression: `new Promise(${runtimeTemplate.basicFunction( + "resolve, reject", + [ + `if(typeof ${globalName} !== "undefined") return resolve();`, + `${RuntimeGlobals.loadScript}(${JSON.stringify( + url + )}, ${runtimeTemplate.basicFunction("event", [ + `if(typeof ${globalName} !== "undefined") return resolve();`, + "var errorType = event && (event.type === 'load' ? 'missing' : event.type);", + "var realSrc = event && event.target && event.target.src;", + "__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';", + "__webpack_error__.name = 'ScriptExternalLoadError';", + "__webpack_error__.type = errorType;", + "__webpack_error__.request = realSrc;", + "reject(__webpack_error__);" + ])}, ${JSON.stringify(globalName)});` + ] + )}).then(${runtimeTemplate.returningFunction( + `${globalName}${propertyAccess(urlAndGlobal, 2)}` + )})`, + runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT + }; +}; + +/** + * Checks external variable. + * @param {string} variableName the variable name to check + * @param {string} request the request path + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @returns {string} the generated source + */ +const checkExternalVariable = (variableName, request, runtimeTemplate) => + `if(typeof ${variableName} === 'undefined') { ${runtimeTemplate.throwMissingModuleErrorBlock( + { request } + )} }\n`; + +/** + * Gets source for amd or umd external. + * @param {ModuleId | string} id the module id + * @param {boolean} optional true, if the module is optional + * @param {string | string[]} request the request path + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @returns {SourceData} the generated source + */ +const getSourceForAmdOrUmdExternal = ( + id, + optional, + request, + runtimeTemplate +) => { + const externalVariable = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier( + `${id}` + )}__`; + return { + init: optional + ? checkExternalVariable( + externalVariable, + Array.isArray(request) ? request.join(".") : request, + runtimeTemplate + ) + : undefined, + expression: externalVariable + }; +}; + +/** + * Gets source for default case. + * @param {boolean} optional true, if the module is optional + * @param {string | string[]} request the request path + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @returns {SourceData} the generated source + */ +const getSourceForDefaultCase = (optional, request, runtimeTemplate) => { + if (!Array.isArray(request)) { + // make it an array as the look up works the same basically + request = [request]; + } + + const variableName = request[0]; + const objectLookup = propertyAccess(request, 1); + return { + init: optional + ? checkExternalVariable(variableName, request.join("."), runtimeTemplate) + : undefined, + expression: `${variableName}${objectLookup}` + }; +}; + +/** @typedef {Record} RequestRecord */ +/** @typedef {string | string[] | RequestRecord} ExternalModuleRequest */ + +/** + * Defines the external module hooks type used by this module. + * @typedef {object} ExternalModuleHooks + * @property {SyncBailHook<[Chunk, Compilation], boolean>} chunkCondition + */ + +/** @type {WeakMap} */ +const compilationHooksMap = new WeakMap(); + +class ExternalModule extends Module { + /** + * Creates an instance of ExternalModule. + * @param {ExternalModuleRequest} request request + * @param {ExternalsType} type type + * @param {string} userRequest user request + * @param {DependencyMeta=} dependencyMeta dependency meta + */ + constructor(request, type, userRequest, dependencyMeta) { + super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null); + + // Info from Factory + /** @type {ExternalModuleRequest} */ + this.request = request; + /** @type {ExternalsType} */ + this.externalType = type; + /** @type {string} */ + this.userRequest = userRequest; + /** @type {DependencyMeta=} */ + this.dependencyMeta = dependencyMeta; + } + + /** + * Returns the attached hooks. + * @param {Compilation} compilation the compilation + * @returns {ExternalModuleHooks} the attached hooks + */ + static getCompilationHooks(compilation) { + let hooks = compilationHooksMap.get(compilation); + if (hooks === undefined) { + hooks = { + chunkCondition: new SyncBailHook(["chunk", "compilation"]) + }; + compilationHooksMap.set(compilation, hooks); + } + return hooks; + } + + /** + * Returns the source types this module can generate. + * @returns {SourceTypes} types available (do not mutate) + */ + getSourceTypes() { + if (this.externalType === "asset" && this.dependencyMeta) { + const sourceType = + /** @type {AssetDependencyMeta} */ + (this.dependencyMeta).sourceType; + // TODO webpack 6 drop "css-url" once the alias is removed + if (sourceType === ASSET_URL_TYPE || sourceType === "css-url") { + return ASSET_URL_TYPES; + } + } else if (this.externalType === "css-import") { + return CSS_IMPORT_TYPES; + } + + return JAVASCRIPT_TYPES; + } + + /** + * Gets the library identifier. + * @param {LibIdentOptions} options options + * @returns {LibIdent | null} an identifier for library inclusion + */ + libIdent(options) { + return this.userRequest; + } + + /** + * Returns true if the module can be placed in the chunk. + * @param {Chunk} chunk the chunk which condition should be checked + * @param {Compilation} compilation the compilation + * @returns {boolean} true if the module can be placed in the chunk + */ + chunkCondition(chunk, compilation) { + const { chunkCondition } = ExternalModule.getCompilationHooks(compilation); + const condition = chunkCondition.call(chunk, compilation); + if (condition !== undefined) return condition; + + const type = this._resolveExternalType(this.externalType); + + // For `import()` externals, keep them in the initial chunk to avoid loading + // them asynchronously twice and to improve runtime performance. + if (["css-import", "module"].includes(type)) { + return true; + } + return compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0; + } + + /** + * Returns the unique identifier used to reference this module. + * @returns {string} a unique identifier of the module + */ + identifier() { + let id = `external ${this._resolveExternalType( + this.externalType + )} ${JSON.stringify(this.request)}`; + const meta = /** @type {ImportDependencyMeta | undefined} */ ( + this.dependencyMeta + ); + if (meta) { + if (meta.phase) { + id += `|phase=${ImportPhaseUtils.stringify(meta.phase)}`; + } + if (meta.attributes) { + id += `|attributes=${JSON.stringify(meta.attributes)}`; + } + } + return id; + } + + /** + * Returns a human-readable identifier for this module. + * @param {RequestShortener} requestShortener the request shortener + * @returns {string} a user readable identifier of the module + */ + readableIdentifier(requestShortener) { + return `external ${JSON.stringify(this.request)}`; + } + + /** + * Checks whether the module needs to be rebuilt for the current build state. + * @param {NeedBuildContext} context context info + * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild + * @returns {void} + */ + needBuild(context, callback) { + return callback(null, !this.buildMeta); + } + + /** + * Builds the module using the provided compilation context. + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {BuildCallback} callback callback function + * @returns {void} + */ + build(options, compilation, resolver, fs, callback) { + this.buildMeta = { + async: false, + exportsType: undefined + }; + this.buildInfo = { + strict: true, + topLevelDeclarations: new Set(), + javascriptModule: compilation.outputOptions.module + }; + const { request, externalType } = this._getRequestAndExternalType(); + this.buildMeta.exportsType = "dynamic"; + let canMangle = false; + this.clearDependenciesAndBlocks(); + switch (externalType) { + case "this": + this.buildInfo.strict = false; + break; + case "system": + if (!Array.isArray(request) || request.length === 1) { + this.buildMeta.exportsType = "namespace"; + canMangle = true; + } + break; + case "module": + if (this.buildInfo.javascriptModule) { + if (!Array.isArray(request) || request.length === 1) { + this.buildMeta.exportsType = "namespace"; + canMangle = true; + } + } else { + this.buildMeta.async = true; + EnvironmentNotSupportAsyncWarning.check( + this, + compilation.runtimeTemplate, + "external module" + ); + if (!Array.isArray(request) || request.length === 1) { + this.buildMeta.exportsType = "namespace"; + canMangle = false; + } + } + break; + case "script": + this.buildMeta.async = true; + EnvironmentNotSupportAsyncWarning.check( + this, + compilation.runtimeTemplate, + "external script" + ); + break; + case "promise": + this.buildMeta.async = true; + EnvironmentNotSupportAsyncWarning.check( + this, + compilation.runtimeTemplate, + "external promise" + ); + break; + case "import": + this.buildMeta.async = true; + EnvironmentNotSupportAsyncWarning.check( + this, + compilation.runtimeTemplate, + "external import" + ); + if (!Array.isArray(request) || request.length === 1) { + this.buildMeta.exportsType = "namespace"; + canMangle = false; + } + break; + } + this.addDependency(new StaticExportsDependency(true, canMangle)); + callback(); + } + + /** + * restore unsafe cache data + * @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData + * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching + */ + restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) { + this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory); + } + + /** + * Returns the reason this module cannot be concatenated, when one exists. + * @param {ConcatenationBailoutReasonContext} context context + * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated + */ + getConcatenationBailoutReason(context) { + switch (this.externalType) { + case "amd": + case "amd-require": + case "umd": + case "umd2": + case "system": + case "jsonp": + return `${this.externalType} externals can't be concatenated`; + } + return undefined; + } + + /** + * Get request and external type. + * @private + * @returns {{ request: string | string[], externalType: ExternalsType }} the request and external type + */ + _getRequestAndExternalType() { + let { request, externalType } = this; + if (typeof request === "object" && !Array.isArray(request)) { + request = request[externalType]; + } + externalType = this._resolveExternalType(externalType); + return { request, externalType }; + } + + /** + * Resolve the detailed external type from the raw external type. + * e.g. resolve "module" or "import" from "module-import" type + * @param {ExternalsType} externalType raw external type + * @returns {ExternalsType} resolved external type + */ + _resolveExternalType(externalType) { + if (externalType === "module-import") { + if ( + this.dependencyMeta && + /** @type {ImportDependencyMeta} */ + (this.dependencyMeta).externalType + ) { + return /** @type {ImportDependencyMeta} */ (this.dependencyMeta) + .externalType; + } + return "module"; + } else if (externalType === "asset") { + if ( + this.dependencyMeta && + /** @type {AssetDependencyMeta} */ + (this.dependencyMeta).sourceType + ) { + return /** @type {AssetDependencyMeta} */ (this.dependencyMeta) + .sourceType; + } + + return "asset"; + } + + return externalType; + } + + /** + * Returns the source data. + * @private + * @param {string | string[]} request request + * @param {ExternalsType} externalType the external type + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @param {ModuleGraph} moduleGraph the module graph + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {RuntimeSpec} runtime the runtime + * @param {DependencyMeta | undefined} dependencyMeta the dependency meta + * @param {ConcatenationScope=} concatenationScope concatenationScope + * @returns {SourceData} the source data + */ + _getSourceData( + request, + externalType, + runtimeTemplate, + moduleGraph, + chunkGraph, + runtime, + dependencyMeta, + concatenationScope + ) { + switch (externalType) { + case "this": + case "window": + case "self": + return getSourceForGlobalVariableExternal(request, this.externalType); + case "global": + return getSourceForGlobalVariableExternal( + request, + runtimeTemplate.globalObject + ); + case "commonjs": + case "commonjs2": + case "commonjs-module": + case "commonjs-static": + return getSourceForCommonJsExternal(request); + case "node-commonjs": + return /** @type {BuildInfo} */ (this.buildInfo).javascriptModule + ? getSourceForCommonJsExternalInNodeModule(request, runtimeTemplate) + : getSourceForCommonJsExternal(request); + case "amd": + case "amd-require": + case "umd": + case "umd2": + case "system": + case "jsonp": { + const id = chunkGraph.getModuleId(this); + return getSourceForAmdOrUmdExternal( + id !== null ? id : this.identifier(), + this.isOptional(moduleGraph), + request, + runtimeTemplate + ); + } + case "import": + return getSourceForImportExternal( + request, + runtimeTemplate, + /** @type {ImportDependencyMeta} */ (dependencyMeta) + ); + case "script": + return getSourceForScriptExternal(request, runtimeTemplate); + case "module": { + if (!(/** @type {BuildInfo} */ (this.buildInfo).javascriptModule)) { + if (!runtimeTemplate.supportsDynamicImport()) { + throw new Error( + `The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script${ + runtimeTemplate.supportsEcmaScriptModuleSyntax() + ? "\nDid you mean to build a EcmaScript Module ('output.module: true')?" + : "" + }` + ); + } + return getSourceForImportExternal( + request, + runtimeTemplate, + /** @type {ImportDependencyMeta} */ (dependencyMeta) + ); + } + if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) { + throw new Error( + "The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'" + ); + } + return getSourceForModuleExternal( + request, + moduleGraph.getExportsInfo(this), + runtime, + runtimeTemplate, + /** @type {ImportDependencyMeta} */ (dependencyMeta), + concatenationScope + ); + } + case "var": + case "promise": + case "assign": + default: + return getSourceForDefaultCase( + this.isOptional(moduleGraph), + request, + runtimeTemplate + ); + } + } + + /** + * Generates code and runtime requirements for this module. + * @param {CodeGenerationContext} context context for code generation + * @returns {CodeGenerationResult} result + */ + codeGeneration({ + runtimeTemplate, + moduleGraph, + chunkGraph, + runtime, + concatenationScope + }) { + const { request, externalType } = this._getRequestAndExternalType(); + switch (externalType) { + case "asset": { + /** @type {Sources} */ + const sources = new Map(); + sources.set( + JAVASCRIPT_TYPE, + new RawSource(`module.exports = ${JSON.stringify(request)};`) + ); + /** @type {CodeGenerationResultData} */ + const data = new Map(); + data.set("url", { javascript: /** @type {string} */ (request) }); + return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data }; + } + // TODO webpack 6 remove "css-url" alias + case "css-url": + case "asset-url": { + /** @type {Sources} */ + const sources = new Map(); + /** @type {CodeGenerationResultData} */ + const data = new Map(); + data.set("url", { [ASSET_URL_TYPE]: /** @type {string} */ (request) }); + return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data }; + } + case "css-import": { + /** @type {Sources} */ + const sources = new Map(); + const dependencyMeta = /** @type {CssImportDependencyMeta} */ ( + this.dependencyMeta + ); + const layer = + dependencyMeta.layer !== undefined + ? ` layer(${dependencyMeta.layer})` + : ""; + const supports = dependencyMeta.supports + ? ` supports(${dependencyMeta.supports})` + : ""; + const media = dependencyMeta.media ? ` ${dependencyMeta.media}` : ""; + sources.set( + "css-import", + new RawSource( + `@import url(${JSON.stringify( + request + )})${layer}${supports}${media};` + ) + ); + return { + sources, + runtimeRequirements: EMPTY_RUNTIME_REQUIREMENTS + }; + } + default: { + const sourceData = this._getSourceData( + request, + externalType, + runtimeTemplate, + moduleGraph, + chunkGraph, + runtime, + this.dependencyMeta, + concatenationScope + ); + + // sourceString can be empty str only when there is concatenationScope + let sourceString = sourceData.expression; + if (sourceData.iife) { + sourceString = `(function() { return ${sourceString}; }())`; + } + + const specifiers = sourceData.specifiers; + if (specifiers) { + sourceString = ""; + const scope = /** @type {ConcatenationScope} */ (concatenationScope); + for (const [specifier, finalName] of specifiers) { + scope.registerRawExport(specifier, finalName); + } + } else if (concatenationScope) { + sourceString = `${runtimeTemplate.renderConst()} ${ + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + } = ${sourceString};`; + concatenationScope.registerNamespaceExport( + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + ); + } else { + sourceString = `module.exports = ${sourceString};`; + } + if (sourceData.init) { + sourceString = `${sourceData.init}\n${sourceString}`; + } + + /** @type {undefined | CodeGenerationResultData} */ + let data; + if (sourceData.chunkInitFragments) { + data = new Map(); + data.set("chunkInitFragments", sourceData.chunkInitFragments); + } + + /** @type {Sources} */ + const sources = new Map(); + if (this.useSourceMap || this.useSimpleSourceMap) { + sources.set( + JAVASCRIPT_TYPE, + new OriginalSource(sourceString, this.identifier()) + ); + } else { + sources.set(JAVASCRIPT_TYPE, new RawSource(sourceString)); + } + + let runtimeRequirements = sourceData.runtimeRequirements; + if (!concatenationScope) { + if (!runtimeRequirements) { + runtimeRequirements = RUNTIME_REQUIREMENTS; + } else { + const set = new Set(runtimeRequirements); + set.add(RuntimeGlobals.module); + runtimeRequirements = set; + } + } + + return { + sources, + runtimeRequirements: + runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS, + data + }; + } + } + } + + /** + * Returns the estimated size for the requested source type. + * @param {string=} type the source type for which the size should be estimated + * @returns {number} the estimated size of the module (must be non-zero) + */ + size(type) { + return 42; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) { + const { chunkGraph } = context; + hash.update( + `${this._resolveExternalType(this.externalType)}${JSON.stringify( + this.request + )}${this.isOptional(chunkGraph.moduleGraph)}` + ); + const meta = /** @type {ImportDependencyMeta | undefined} */ ( + this.dependencyMeta + ); + if (meta) { + if (meta.phase) { + hash.update(`|phase=${ImportPhaseUtils.stringify(meta.phase)}`); + } + if (meta.attributes) { + hash.update(`|attributes=${JSON.stringify(meta.attributes)}`); + } + } + super.updateHash(hash, context); + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + + write(this.request); + write(this.externalType); + write(this.userRequest); + write(this.dependencyMeta); + + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + + this.request = read(); + this.externalType = read(); + this.userRequest = read(); + this.dependencyMeta = read(); + + super.deserialize(context); + } +} + +makeSerializable(ExternalModule, "webpack/lib/ExternalModule"); + +module.exports = ExternalModule; +module.exports.ModuleExternalInitFragment = ModuleExternalInitFragment; +module.exports.getExternalModuleNodeCommonjsInitFragment = + getExternalModuleNodeCommonjsInitFragment; Index: frontend/node_modules/webpack/lib/ExternalModuleFactoryPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ExternalModuleFactoryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ExternalModuleFactoryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,386 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const ExternalModule = require("./ExternalModule"); +const { ASSET_URL_TYPE } = require("./ModuleSourceTypeConstants"); +const ContextElementDependency = require("./dependencies/ContextElementDependency"); +const CssImportDependency = require("./dependencies/CssImportDependency"); +const CssUrlDependency = require("./dependencies/CssUrlDependency"); +const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency"); +const ImportDependency = require("./dependencies/ImportDependency"); +const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge"); + +/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */ +/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */ +/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */ +/** @typedef {import("../declarations/WebpackOptions").ExternalItem} ExternalItem */ +/** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */ +/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */ +/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */ +/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */ +/** @typedef {import("./ModuleFactory").IssuerLayer} IssuerLayer */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */ +/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */ + +/** @typedef {((context: string, request: string, callback: (err?: Error | null, result?: string | false, resolveRequest?: import("enhanced-resolve").ResolveRequest) => void) => void)} ExternalItemFunctionDataGetResolveCallbackResult */ +/** @typedef {((context: string, request: string) => Promise)} ExternalItemFunctionDataGetResolveResult */ +/** @typedef {(options?: ResolveOptions) => ExternalItemFunctionDataGetResolveCallbackResult | ExternalItemFunctionDataGetResolveResult} ExternalItemFunctionDataGetResolve */ + +/** + * Defines the external item function data type used by this module. + * @typedef {object} ExternalItemFunctionData + * @property {string} context the directory in which the request is placed + * @property {ModuleFactoryCreateDataContextInfo} contextInfo contextual information + * @property {string} dependencyType the category of the referencing dependency + * @property {ExternalItemFunctionDataGetResolve} getResolve get a resolve function with the current resolver options + * @property {string} request the request as written by the user in the require/import expression/statement + */ + +/** @typedef {((data: ExternalItemFunctionData, callback: (err?: (Error | null), result?: ExternalItemValue) => void) => void)} ExternalItemFunctionCallback */ +/** @typedef {((data: import("../lib/ExternalModuleFactoryPlugin").ExternalItemFunctionData) => Promise)} ExternalItemFunctionPromise */ + +const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /; +const EMPTY_RESOLVE_OPTIONS = {}; + +// TODO webpack 6 remove this +const callDeprecatedExternals = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {EXPECTED_FUNCTION} externalsFunction externals function + * @param {string} context context + * @param {string} request request + * @param {(err: Error | null | undefined, value: ExternalValue | undefined, ty: ExternalsType | undefined) => void} cb cb + */ + (externalsFunction, context, request, cb) => { + // eslint-disable-next-line no-useless-call + externalsFunction.call(null, context, request, cb); + }, + "The externals-function should be defined like ({context, request}, cb) => { ... }", + "DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS" +); + +/** @typedef {(layer: string | null) => ExternalItem} ExternalItemByLayerFn */ +/** @typedef {ExternalItemObjectKnown & ExternalItemObjectUnknown} ExternalItemObject */ + +/** + * Defines the external weak cache type used by this module. + * @template {ExternalItemObject} T + * @typedef {WeakMap>>} ExternalWeakCache + */ + +/** @type {ExternalWeakCache} */ +const cache = new WeakMap(); + +/** + * Returns result. + * @param {ExternalItemObject} obj obj + * @param {IssuerLayer} layer layer + * @returns {Omit} result + */ +const resolveLayer = (obj, layer) => { + let map = cache.get(obj); + if (map === undefined) { + map = new Map(); + cache.set(obj, map); + } else { + const cacheEntry = map.get(layer); + if (cacheEntry !== undefined) return cacheEntry; + } + const result = resolveByProperty(obj, "byLayer", layer); + map.set(layer, result); + return result; +}; + +/** @typedef {string | string[] | boolean | Record} ExternalValue */ + +const PLUGIN_NAME = "ExternalModuleFactoryPlugin"; + +class ExternalModuleFactoryPlugin { + /** + * Creates an instance of ExternalModuleFactoryPlugin. + * @param {ExternalsType | ((dependency: Dependency) => ExternalsType)} type default external type + * @param {Externals} externals externals config + */ + constructor(type, externals) { + this.type = type; + this.externals = externals; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {NormalModuleFactory} normalModuleFactory the normal module factory + * @returns {void} + */ + apply(normalModuleFactory) { + const globalType = this.type; + normalModuleFactory.hooks.factorize.tapAsync( + PLUGIN_NAME, + (data, callback) => { + const context = data.context; + const contextInfo = data.contextInfo; + const dependency = data.dependencies[0]; + const dependencyType = data.dependencyType; + + /** @typedef {(err?: Error | null, externalModule?: ExternalModule) => void} HandleExternalCallback */ + + /** + * Processes the provided value. + * @param {ExternalValue} value the external config + * @param {ExternalsType | undefined} type type of external + * @param {HandleExternalCallback} callback callback + * @returns {void} + */ + const handleExternal = (value, type, callback) => { + if (value === false) { + // Not externals, fallback to original factory + return callback(); + } + /** @type {ExternalValue} */ + let externalConfig = value === true ? dependency.request : value; + // When no explicit type is specified, extract it from the externalConfig + if (type === undefined) { + if ( + typeof externalConfig === "string" && + UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig) + ) { + const idx = externalConfig.indexOf(" "); + type = + /** @type {ExternalsType} */ + (externalConfig.slice(0, idx)); + externalConfig = externalConfig.slice(idx + 1); + } else if ( + Array.isArray(externalConfig) && + externalConfig.length > 0 && + UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig[0]) + ) { + const firstItem = externalConfig[0]; + const idx = firstItem.indexOf(" "); + type = /** @type {ExternalsType} */ (firstItem.slice(0, idx)); + externalConfig = [ + firstItem.slice(idx + 1), + ...externalConfig.slice(1) + ]; + } + } + + const defaultType = + typeof globalType === "function" + ? globalType(dependency) + : globalType; + const resolvedType = type || defaultType; + + // TODO make it pluggable/add hooks to `ExternalModule` to allow output modules own externals? + /** @type {DependencyMeta | undefined} */ + let dependencyMeta; + + if ( + dependency instanceof HarmonyImportDependency || + dependency instanceof ImportDependency || + dependency instanceof ContextElementDependency + ) { + const externalType = + dependency instanceof HarmonyImportDependency + ? "module" + : dependency instanceof ImportDependency + ? "import" + : undefined; + + dependencyMeta = { + attributes: dependency.attributes, + phase: + dependency instanceof HarmonyImportDependency || + dependency instanceof ImportDependency + ? dependency.phase + : undefined, + externalType + }; + } else if (dependency instanceof CssImportDependency) { + dependencyMeta = { + layer: dependency.layer, + supports: dependency.supports, + media: dependency.media + }; + } + + if ( + resolvedType === "asset" && + dependency instanceof CssUrlDependency + ) { + dependencyMeta = { sourceType: ASSET_URL_TYPE }; + } + + callback( + null, + new ExternalModule( + externalConfig, + resolvedType, + dependency.request, + dependencyMeta + ) + ); + }; + + /** + * Processes the provided external. + * @param {Externals} externals externals config + * @param {HandleExternalCallback} callback callback + * @returns {void} + */ + const handleExternals = (externals, callback) => { + if (typeof externals === "string") { + if (externals === dependency.request) { + return handleExternal(dependency.request, undefined, callback); + } + } else if (Array.isArray(externals)) { + let i = 0; + const next = () => { + /** @type {boolean | undefined} */ + let asyncFlag; + /** + * Handle externals and callback. + * @param {(Error | null)=} err err + * @param {ExternalModule=} module module + * @returns {void} + */ + const handleExternalsAndCallback = (err, module) => { + if (err) return callback(err); + if (!module) { + if (asyncFlag) { + asyncFlag = false; + return; + } + return next(); + } + callback(null, module); + }; + + do { + asyncFlag = true; + if (i >= externals.length) return callback(); + handleExternals(externals[i++], handleExternalsAndCallback); + } while (!asyncFlag); + asyncFlag = false; + }; + + next(); + return; + } else if (externals instanceof RegExp) { + if (externals.test(dependency.request)) { + return handleExternal(dependency.request, undefined, callback); + } + } else if (typeof externals === "function") { + /** + * Processes the provided err. + * @param {Error | null | undefined} err err + * @param {ExternalValue=} value value + * @param {ExternalsType=} type type + * @returns {void} + */ + const cb = (err, value, type) => { + if (err) return callback(err); + if (value !== undefined) { + handleExternal(value, type, callback); + } else { + callback(); + } + }; + if (externals.length === 3) { + // TODO webpack 6 remove this + callDeprecatedExternals( + externals, + context, + dependency.request, + cb + ); + } else { + const promise = externals( + { + context, + request: dependency.request, + dependencyType, + contextInfo, + getResolve: (options) => (context, request, callback) => { + /** @type {ResolveContext} */ + const resolveContext = { + fileDependencies: data.fileDependencies, + missingDependencies: data.missingDependencies, + contextDependencies: data.contextDependencies + }; + let resolver = normalModuleFactory.getResolver( + "normal", + dependencyType + ? cachedSetProperty( + data.resolveOptions || EMPTY_RESOLVE_OPTIONS, + "dependencyType", + dependencyType + ) + : data.resolveOptions + ); + if (options) resolver = resolver.withOptions(options); + if (callback) { + resolver.resolve( + {}, + context, + request, + resolveContext, + callback + ); + } else { + return new Promise((resolve, reject) => { + resolver.resolve( + {}, + context, + request, + resolveContext, + (err, result) => { + if (err) reject(err); + else resolve(result); + } + ); + }); + } + } + }, + cb + ); + if (promise && promise.then) { + promise.then((r) => cb(null, r), cb); + } + } + return; + } else if (typeof externals === "object") { + const resolvedExternals = resolveLayer( + externals, + /** @type {IssuerLayer} */ + (contextInfo.issuerLayer) + ); + if ( + Object.prototype.hasOwnProperty.call( + resolvedExternals, + dependency.request + ) + ) { + return handleExternal( + resolvedExternals[dependency.request], + undefined, + callback + ); + } + } + callback(); + }; + + handleExternals(this.externals, callback); + } + ); + } +} + +module.exports = ExternalModuleFactoryPlugin; Index: frontend/node_modules/webpack/lib/ExternalsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ExternalsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ExternalsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,94 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { ModuleExternalInitFragment } = require("./ExternalModule"); +const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin"); +const ConcatenatedModule = require("./optimize/ConcatenatedModule"); + +/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */ +/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./ExternalModule").Imported} Imported */ +/** @typedef {import("./Dependency")} Dependency */ + +const PLUGIN_NAME = "ExternalsPlugin"; + +class ExternalsPlugin { + /** + * Creates an instance of ExternalsPlugin. + * @param {ExternalsType | ((dependency: Dependency) => ExternalsType)} type default external type + * @param {Externals} externals externals config + */ + constructor(type, externals) { + this.type = type; + this.externals = externals; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compile.tap(PLUGIN_NAME, ({ normalModuleFactory }) => { + new ExternalModuleFactoryPlugin(this.type, this.externals).apply( + normalModuleFactory + ); + }); + + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const { concatenatedModuleInfo } = + ConcatenatedModule.getCompilationHooks(compilation); + concatenatedModuleInfo.tap(PLUGIN_NAME, (updatedInfo, moduleInfo) => { + const rawExportMap = updatedInfo.rawExportMap; + + if (!rawExportMap) { + return; + } + + const chunkInitFragments = moduleInfo.chunkInitFragments; + const moduleExternalInitFragments = + /** @type {ModuleExternalInitFragment[]} */ + ( + chunkInitFragments + ? /** @type {unknown[]} */ + (chunkInitFragments).filter( + (fragment) => fragment instanceof ModuleExternalInitFragment + ) + : [] + ); + + let initFragmentChanged = false; + + for (const fragment of moduleExternalInitFragments) { + const imported = fragment.getImported(); + + if (Array.isArray(imported)) { + const newImported = + /** @type {Imported} */ + ( + imported.map(([specifier, finalName]) => [ + specifier, + rawExportMap.has(specifier) + ? rawExportMap.get(specifier) + : finalName + ]) + ); + fragment.setImported(newImported); + initFragmentChanged = true; + } + } + + if (initFragmentChanged) { + return true; + } + }); + }); + } +} + +module.exports = ExternalsPlugin; Index: frontend/node_modules/webpack/lib/FileSystemInfo.js =================================================================== --- frontend/node_modules/webpack/lib/FileSystemInfo.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/FileSystemInfo.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,4353 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const nodeModule = require("module"); +const { isAbsolute } = require("path"); +const { create: createResolver } = require("enhanced-resolve"); +const asyncLib = require("neo-async"); +const { DEFAULTS } = require("./config/defaults"); +const AsyncQueue = require("./util/AsyncQueue"); +const StackedCacheMap = require("./util/StackedCacheMap"); +const createHash = require("./util/createHash"); +const { dirname, join, lstatReadlinkAbsolute, relative } = require("./util/fs"); +const makeSerializable = require("./util/makeSerializable"); +const memoize = require("./util/memoize"); +const processAsyncTree = require("./util/processAsyncTree"); + +/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */ +/** @typedef {import("enhanced-resolve").ResolveFunctionAsync} ResolveFunctionAsync */ +/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */ +/** @typedef {import("./logging/Logger").Logger} Logger */ +/** @typedef {import("./errors/WebpackError")} WebpackError */ +/** @typedef {import("./util/fs").JsonObject} JsonObject */ +/** @typedef {import("./util/fs").IStats} IStats */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** + * Defines the processor callback type used by this module. + * @template T + * @typedef {import("./util/AsyncQueue").Callback} ProcessorCallback + */ +/** + * Defines the processor type used by this module. + * @template T, R + * @typedef {import("./util/AsyncQueue").Processor} Processor + */ + +const supportsEsm = Number(process.versions.modules) >= 83; + +/** @type {Set} */ +const builtinModules = new Set(nodeModule.builtinModules); + +let FS_ACCURACY = 2000; + +/** @type {Set} */ +const EMPTY_SET = new Set(); + +const RBDT_RESOLVE_INITIAL = 0; +const RBDT_RESOLVE_FILE = 1; +const RBDT_RESOLVE_DIRECTORY = 2; +const RBDT_RESOLVE_CJS_FILE = 3; +const RBDT_RESOLVE_CJS_FILE_AS_CHILD = 4; +const RBDT_RESOLVE_ESM_FILE = 5; +const RBDT_DIRECTORY = 6; +const RBDT_FILE = 7; +const RBDT_DIRECTORY_DEPENDENCIES = 8; +const RBDT_FILE_DEPENDENCIES = 9; + +/** @typedef {RBDT_RESOLVE_INITIAL | RBDT_RESOLVE_FILE | RBDT_RESOLVE_DIRECTORY | RBDT_RESOLVE_CJS_FILE | RBDT_RESOLVE_CJS_FILE_AS_CHILD | RBDT_RESOLVE_ESM_FILE | RBDT_DIRECTORY | RBDT_FILE | RBDT_DIRECTORY_DEPENDENCIES | RBDT_FILE_DEPENDENCIES} JobType */ + +const INVALID = Symbol("invalid"); + +// eslint-disable-next-line jsdoc/ts-no-empty-object-type +/** @typedef {{ }} ExistenceOnlyTimeEntry */ + +/** + * Defines the file system info entry type used by this module. + * @typedef {object} FileSystemInfoEntry + * @property {number} safeTime + * @property {number=} timestamp + */ + +/** + * Defines the resolved context file system info entry type used by this module. + * @typedef {object} ResolvedContextFileSystemInfoEntry + * @property {number} safeTime + * @property {string=} timestampHash + */ + +/** @typedef {Set} Symlinks */ + +/** + * Defines the context file system info entry type used by this module. + * @typedef {object} ContextFileSystemInfoEntry + * @property {number} safeTime + * @property {string=} timestampHash + * @property {ResolvedContextFileSystemInfoEntry=} resolved + * @property {Symlinks=} symlinks + */ + +/** + * Defines the timestamp and hash type used by this module. + * @typedef {object} TimestampAndHash + * @property {number} safeTime + * @property {number=} timestamp + * @property {string} hash + */ + +/** + * Defines the resolved context timestamp and hash type used by this module. + * @typedef {object} ResolvedContextTimestampAndHash + * @property {number} safeTime + * @property {string=} timestampHash + * @property {string} hash + */ + +/** + * Defines the context timestamp and hash type used by this module. + * @typedef {object} ContextTimestampAndHash + * @property {number} safeTime + * @property {string=} timestampHash + * @property {string} hash + * @property {ResolvedContextTimestampAndHash=} resolved + * @property {Symlinks=} symlinks + */ + +/** + * Defines the context hash type used by this module. + * @typedef {object} ContextHash + * @property {string} hash + * @property {string=} resolved + * @property {Symlinks=} symlinks + */ + +/** @typedef {Set} SnapshotContent */ + +/** + * Defines the snapshot optimization entry type used by this module. + * @typedef {object} SnapshotOptimizationEntry + * @property {Snapshot} snapshot + * @property {number} shared + * @property {SnapshotContent | undefined} snapshotContent + * @property {Set | undefined} children + */ + +/** @typedef {Map} ResolveResults */ + +/** @typedef {Set} Files */ +/** @typedef {Set} Directories */ +/** @typedef {Set} Missing */ + +/** + * Defines the resolve dependencies type used by this module. + * @typedef {object} ResolveDependencies + * @property {Files} files list of files + * @property {Directories} directories list of directories + * @property {Missing} missing list of missing entries + */ + +/** + * Defines the resolve build dependencies result type used by this module. + * @typedef {object} ResolveBuildDependenciesResult + * @property {Files} files list of files + * @property {Directories} directories list of directories + * @property {Missing} missing list of missing entries + * @property {ResolveResults} resolveResults stored resolve results + * @property {ResolveDependencies} resolveDependencies dependencies of the resolving + */ + +/** + * Defines the snapshot options type used by this module. + * @typedef {object} SnapshotOptions + * @property {boolean=} hash should use hash to snapshot + * @property {boolean=} timestamp should use timestamp to snapshot + */ + +const DONE_ITERATOR_RESULT = new Set().keys().next(); + +// cspell:word tshs +// Tsh = Timestamp + Hash +// Tshs = Timestamp + Hash combinations + +class SnapshotIterator { + /** + * Creates an instance of SnapshotIterator. + * @param {() => IteratorResult} next next + */ + constructor(next) { + this.next = next; + } +} + +/** + * Defines the get maps function type used by this module. + * @template T + * @typedef {(snapshot: Snapshot) => T[]} GetMapsFunction + */ + +/** + * Represents SnapshotIterable. + * @template T + */ +class SnapshotIterable { + /** + * Creates an instance of SnapshotIterable. + * @param {Snapshot} snapshot snapshot + * @param {GetMapsFunction} getMaps get maps function + */ + constructor(snapshot, getMaps) { + this.snapshot = snapshot; + this.getMaps = getMaps; + } + + [Symbol.iterator]() { + let state = 0; + /** @type {IterableIterator} */ + let it; + /** @type {GetMapsFunction} */ + let getMaps; + /** @type {T[]} */ + let maps; + /** @type {Snapshot} */ + let snapshot; + /** @type {Snapshot[] | undefined} */ + let queue; + return new SnapshotIterator(() => { + for (;;) { + switch (state) { + case 0: + snapshot = this.snapshot; + getMaps = this.getMaps; + maps = getMaps(snapshot); + state = 1; + /* falls through */ + case 1: + if (maps.length > 0) { + const map = maps.pop(); + if (map !== undefined) { + it = + /** @type {Set | Map} */ + (map).keys(); + state = 2; + } else { + break; + } + } else { + state = 3; + break; + } + /* falls through */ + case 2: { + const result = it.next(); + if (!result.done) return result; + state = 1; + break; + } + case 3: { + const children = snapshot.children; + if (children !== undefined) { + if (children.size === 1) { + // shortcut for a single child + // avoids allocation of queue + for (const child of children) snapshot = child; + maps = getMaps(snapshot); + state = 1; + break; + } + if (queue === undefined) queue = []; + for (const child of children) { + queue.push(child); + } + } + if (queue !== undefined && queue.length > 0) { + snapshot = /** @type {Snapshot} */ (queue.pop()); + maps = getMaps(snapshot); + state = 1; + break; + } else { + state = 4; + } + } + /* falls through */ + case 4: + return DONE_ITERATOR_RESULT; + } + } + }); + } +} + +/** @typedef {Map} FileTimestamps */ +/** @typedef {Map} FileHashes */ +/** @typedef {Map} FileTshs */ +/** @typedef {Map} ContextTimestamps */ +/** @typedef {Map} ContextHashes */ +/** @typedef {Map} ContextTshs */ +/** @typedef {Map} MissingExistence */ +/** @typedef {Map} ManagedItemInfo */ +/** @typedef {Set} ManagedFiles */ +/** @typedef {Set} ManagedContexts */ +/** @typedef {Set} ManagedMissing */ +/** @typedef {Set} Children */ + +class Snapshot { + constructor() { + this._flags = 0; + /** @type {Iterable | undefined} */ + this._cachedFileIterable = undefined; + /** @type {Iterable | undefined} */ + this._cachedContextIterable = undefined; + /** @type {Iterable | undefined} */ + this._cachedMissingIterable = undefined; + /** @type {number | undefined} */ + this.startTime = undefined; + /** @type {FileTimestamps | undefined} */ + this.fileTimestamps = undefined; + /** @type {FileHashes | undefined} */ + this.fileHashes = undefined; + /** @type {FileTshs | undefined} */ + this.fileTshs = undefined; + /** @type {ContextTimestamps | undefined} */ + this.contextTimestamps = undefined; + /** @type {ContextHashes | undefined} */ + this.contextHashes = undefined; + /** @type {ContextTshs | undefined} */ + this.contextTshs = undefined; + /** @type {MissingExistence | undefined} */ + this.missingExistence = undefined; + /** @type {ManagedItemInfo | undefined} */ + this.managedItemInfo = undefined; + /** @type {ManagedFiles | undefined} */ + this.managedFiles = undefined; + /** @type {ManagedContexts | undefined} */ + this.managedContexts = undefined; + /** @type {ManagedMissing | undefined} */ + this.managedMissing = undefined; + /** @type {Children | undefined} */ + this.children = undefined; + } + + hasStartTime() { + return (this._flags & 1) !== 0; + } + + /** + * Updates start time using the provided value. + * @param {number} value start value + */ + setStartTime(value) { + this._flags |= 1; + this.startTime = value; + } + + /** + * Sets merged start time. + * @param {number | undefined} value value + * @param {Snapshot} snapshot snapshot + */ + setMergedStartTime(value, snapshot) { + if (value) { + if (snapshot.hasStartTime()) { + this.setStartTime( + Math.min( + value, + /** @type {NonNullable} */ + (snapshot.startTime) + ) + ); + } else { + this.setStartTime(value); + } + } else if (snapshot.hasStartTime()) { + this.setStartTime( + /** @type {NonNullable} */ + (snapshot.startTime) + ); + } + } + + hasFileTimestamps() { + return (this._flags & 2) !== 0; + } + + /** + * Sets file timestamps. + * @param {FileTimestamps} value file timestamps + */ + setFileTimestamps(value) { + this._flags |= 2; + this.fileTimestamps = value; + } + + hasFileHashes() { + return (this._flags & 4) !== 0; + } + + /** + * Updates file hashes using the provided value. + * @param {FileHashes} value file hashes + */ + setFileHashes(value) { + this._flags |= 4; + this.fileHashes = value; + } + + hasFileTshs() { + return (this._flags & 8) !== 0; + } + + /** + * Updates file tshs using the provided value. + * @param {FileTshs} value file tshs + */ + setFileTshs(value) { + this._flags |= 8; + this.fileTshs = value; + } + + hasContextTimestamps() { + return (this._flags & 0x10) !== 0; + } + + /** + * Sets context timestamps. + * @param {ContextTimestamps} value context timestamps + */ + setContextTimestamps(value) { + this._flags |= 0x10; + this.contextTimestamps = value; + } + + hasContextHashes() { + return (this._flags & 0x20) !== 0; + } + + /** + * Sets context hashes. + * @param {ContextHashes} value context hashes + */ + setContextHashes(value) { + this._flags |= 0x20; + this.contextHashes = value; + } + + hasContextTshs() { + return (this._flags & 0x40) !== 0; + } + + /** + * Updates context tshs using the provided value. + * @param {ContextTshs} value context tshs + */ + setContextTshs(value) { + this._flags |= 0x40; + this.contextTshs = value; + } + + hasMissingExistence() { + return (this._flags & 0x80) !== 0; + } + + /** + * Sets missing existence. + * @param {MissingExistence} value context tshs + */ + setMissingExistence(value) { + this._flags |= 0x80; + this.missingExistence = value; + } + + hasManagedItemInfo() { + return (this._flags & 0x100) !== 0; + } + + /** + * Sets managed item info. + * @param {ManagedItemInfo} value managed item info + */ + setManagedItemInfo(value) { + this._flags |= 0x100; + this.managedItemInfo = value; + } + + hasManagedFiles() { + return (this._flags & 0x200) !== 0; + } + + /** + * Sets managed files. + * @param {ManagedFiles} value managed files + */ + setManagedFiles(value) { + this._flags |= 0x200; + this.managedFiles = value; + } + + hasManagedContexts() { + return (this._flags & 0x400) !== 0; + } + + /** + * Sets managed contexts. + * @param {ManagedContexts} value managed contexts + */ + setManagedContexts(value) { + this._flags |= 0x400; + this.managedContexts = value; + } + + hasManagedMissing() { + return (this._flags & 0x800) !== 0; + } + + /** + * Sets managed missing. + * @param {ManagedMissing} value managed missing + */ + setManagedMissing(value) { + this._flags |= 0x800; + this.managedMissing = value; + } + + hasChildren() { + return (this._flags & 0x1000) !== 0; + } + + /** + * Updates children using the provided value. + * @param {Children} value children + */ + setChildren(value) { + this._flags |= 0x1000; + this.children = value; + } + + /** + * Adds the provided child to the snapshot. + * @param {Snapshot} child children + */ + addChild(child) { + if (!this.hasChildren()) { + this.setChildren(new Set()); + } + /** @type {Children} */ + (this.children).add(child); + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize({ write }) { + write(this._flags); + if (this.hasStartTime()) write(this.startTime); + if (this.hasFileTimestamps()) write(this.fileTimestamps); + if (this.hasFileHashes()) write(this.fileHashes); + if (this.hasFileTshs()) write(this.fileTshs); + if (this.hasContextTimestamps()) write(this.contextTimestamps); + if (this.hasContextHashes()) write(this.contextHashes); + if (this.hasContextTshs()) write(this.contextTshs); + if (this.hasMissingExistence()) write(this.missingExistence); + if (this.hasManagedItemInfo()) write(this.managedItemInfo); + if (this.hasManagedFiles()) write(this.managedFiles); + if (this.hasManagedContexts()) write(this.managedContexts); + if (this.hasManagedMissing()) write(this.managedMissing); + if (this.hasChildren()) write(this.children); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize({ read }) { + this._flags = read(); + if (this.hasStartTime()) this.startTime = read(); + if (this.hasFileTimestamps()) this.fileTimestamps = read(); + if (this.hasFileHashes()) this.fileHashes = read(); + if (this.hasFileTshs()) this.fileTshs = read(); + if (this.hasContextTimestamps()) this.contextTimestamps = read(); + if (this.hasContextHashes()) this.contextHashes = read(); + if (this.hasContextTshs()) this.contextTshs = read(); + if (this.hasMissingExistence()) this.missingExistence = read(); + if (this.hasManagedItemInfo()) this.managedItemInfo = read(); + if (this.hasManagedFiles()) this.managedFiles = read(); + if (this.hasManagedContexts()) this.managedContexts = read(); + if (this.hasManagedMissing()) this.managedMissing = read(); + if (this.hasChildren()) this.children = read(); + } + + /** + * Creates an iterable from the provided get map. + * @template T + * @param {GetMapsFunction} getMaps first + * @returns {SnapshotIterable} iterable + */ + _createIterable(getMaps) { + return new SnapshotIterable(this, getMaps); + } + + /** + * Gets file iterable. + * @returns {Iterable} iterable + */ + getFileIterable() { + if (this._cachedFileIterable === undefined) { + this._cachedFileIterable = this._createIterable((s) => [ + s.fileTimestamps, + s.fileHashes, + s.fileTshs, + s.managedFiles + ]); + } + return this._cachedFileIterable; + } + + /** + * Gets context iterable. + * @returns {Iterable} iterable + */ + getContextIterable() { + if (this._cachedContextIterable === undefined) { + this._cachedContextIterable = this._createIterable((s) => [ + s.contextTimestamps, + s.contextHashes, + s.contextTshs, + s.managedContexts + ]); + } + return this._cachedContextIterable; + } + + /** + * Gets missing iterable. + * @returns {Iterable} iterable + */ + getMissingIterable() { + if (this._cachedMissingIterable === undefined) { + this._cachedMissingIterable = this._createIterable((s) => [ + s.missingExistence, + s.managedMissing + ]); + } + return this._cachedMissingIterable; + } +} + +makeSerializable(Snapshot, "webpack/lib/FileSystemInfo", "Snapshot"); + +const MIN_COMMON_SNAPSHOT_SIZE = 3; + +/** + * Defines the snapshot optimization value type used by this module. + * @template U, T + * @typedef {U extends true ? Set : Map} SnapshotOptimizationValue + */ + +/** + * Represents SnapshotOptimization. + * @template T + * @template {boolean} [U=false] + */ +class SnapshotOptimization { + /** + * Creates an instance of SnapshotOptimization. + * @param {(snapshot: Snapshot) => boolean} has has value + * @param {(snapshot: Snapshot) => SnapshotOptimizationValue | undefined} get get value + * @param {(snapshot: Snapshot, value: SnapshotOptimizationValue) => void} set set value + * @param {boolean=} useStartTime use the start time of snapshots + * @param {U=} isSet value is an Set instead of a Map + */ + constructor( + has, + get, + set, + useStartTime = true, + isSet = /** @type {U} */ (false) + ) { + this._has = has; + this._get = get; + this._set = set; + this._useStartTime = useStartTime; + /** @type {U} */ + this._isSet = isSet; + /** @type {Map} */ + this._map = new Map(); + this._statItemsShared = 0; + this._statItemsUnshared = 0; + this._statSharedSnapshots = 0; + this._statReusedSharedSnapshots = 0; + } + + getStatisticMessage() { + const total = this._statItemsShared + this._statItemsUnshared; + if (total === 0) return; + return `${ + this._statItemsShared && Math.round((this._statItemsShared * 100) / total) + }% (${this._statItemsShared}/${total}) entries shared via ${ + this._statSharedSnapshots + } shared snapshots (${ + this._statReusedSharedSnapshots + this._statSharedSnapshots + } times referenced)`; + } + + clear() { + this._map.clear(); + this._statItemsShared = 0; + this._statItemsUnshared = 0; + this._statSharedSnapshots = 0; + this._statReusedSharedSnapshots = 0; + } + + /** + * Processes the provided new snapshot. + * @param {Snapshot} newSnapshot snapshot + * @param {Set} capturedFiles files to snapshot/share + * @returns {void} + */ + optimize(newSnapshot, capturedFiles) { + if (capturedFiles.size === 0) { + return; + } + /** + * Increase shared and store optimization entry. + * @param {SnapshotOptimizationEntry} entry optimization entry + * @returns {void} + */ + const increaseSharedAndStoreOptimizationEntry = (entry) => { + if (entry.children !== undefined) { + for (const child of entry.children) { + increaseSharedAndStoreOptimizationEntry(child); + } + } + entry.shared++; + storeOptimizationEntry(entry); + }; + /** + * Stores optimization entry. + * @param {SnapshotOptimizationEntry} entry optimization entry + * @returns {void} + */ + const storeOptimizationEntry = (entry) => { + for (const path of /** @type {SnapshotContent} */ ( + entry.snapshotContent + )) { + const old = + /** @type {SnapshotOptimizationEntry} */ + (this._map.get(path)); + if (old.shared < entry.shared) { + this._map.set(path, entry); + } + capturedFiles.delete(path); + } + }; + + /** @type {SnapshotOptimizationEntry | undefined} */ + let newOptimizationEntry; + + const capturedFilesSize = capturedFiles.size; + + /** @type {Set | undefined} */ + const optimizationEntries = new Set(); + + for (const path of capturedFiles) { + const optimizationEntry = this._map.get(path); + if (optimizationEntry === undefined) { + if (newOptimizationEntry === undefined) { + newOptimizationEntry = { + snapshot: newSnapshot, + shared: 0, + snapshotContent: undefined, + children: undefined + }; + } + this._map.set(path, newOptimizationEntry); + } else { + optimizationEntries.add(optimizationEntry); + } + } + + optimizationEntriesLabel: for (const optimizationEntry of optimizationEntries) { + const snapshot = optimizationEntry.snapshot; + if (optimizationEntry.shared > 0) { + // It's a shared snapshot + // We can't change it, so we can only use it when all files match + // and startTime is compatible + if ( + this._useStartTime && + newSnapshot.startTime && + (!snapshot.startTime || snapshot.startTime > newSnapshot.startTime) + ) { + continue; + } + /** @type {Set} */ + const nonSharedFiles = new Set(); + const snapshotContent = + /** @type {NonNullable} */ + (optimizationEntry.snapshotContent); + const snapshotEntries = + /** @type {SnapshotOptimizationValue} */ + (this._get(snapshot)); + for (const path of snapshotContent) { + if (!capturedFiles.has(path)) { + if (!snapshotEntries.has(path)) { + // File is not shared and can't be removed from the snapshot + // because it's in a child of the snapshot + continue optimizationEntriesLabel; + } + nonSharedFiles.add(path); + } + } + if (nonSharedFiles.size === 0) { + // The complete snapshot is shared + // add it as child + newSnapshot.addChild(snapshot); + increaseSharedAndStoreOptimizationEntry(optimizationEntry); + this._statReusedSharedSnapshots++; + } else { + // Only a part of the snapshot is shared + const sharedCount = snapshotContent.size - nonSharedFiles.size; + if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) { + // Common part it too small + continue; + } + // Extract common timestamps from both snapshots + /** @type {Set | Map} */ + let commonMap; + if (this._isSet) { + commonMap = new Set(); + for (const path of /** @type {Set} */ (snapshotEntries)) { + if (nonSharedFiles.has(path)) continue; + commonMap.add(path); + snapshotEntries.delete(path); + } + } else { + commonMap = new Map(); + const map = /** @type {Map} */ (snapshotEntries); + for (const [path, value] of map) { + if (nonSharedFiles.has(path)) continue; + commonMap.set(path, value); + snapshotEntries.delete(path); + } + } + // Create and attach snapshot + const commonSnapshot = new Snapshot(); + if (this._useStartTime) { + commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot); + } + this._set( + commonSnapshot, + /** @type {SnapshotOptimizationValue} */ (commonMap) + ); + newSnapshot.addChild(commonSnapshot); + snapshot.addChild(commonSnapshot); + // Create optimization entry + const newEntry = { + snapshot: commonSnapshot, + shared: optimizationEntry.shared + 1, + snapshotContent: new Set(commonMap.keys()), + children: undefined + }; + if (optimizationEntry.children === undefined) { + optimizationEntry.children = new Set(); + } + optimizationEntry.children.add(newEntry); + storeOptimizationEntry(newEntry); + this._statSharedSnapshots++; + } + } else { + // It's a unshared snapshot + // We can extract a common shared snapshot + // with all common files + const snapshotEntries = this._get(snapshot); + if (snapshotEntries === undefined) { + // Incomplete snapshot, that can't be used + continue; + } + /** @type {Set | Map} */ + let commonMap; + if (this._isSet) { + commonMap = new Set(); + const set = /** @type {Set} */ (snapshotEntries); + if (capturedFiles.size < set.size) { + for (const path of capturedFiles) { + if (set.has(path)) commonMap.add(path); + } + } else { + for (const path of set) { + if (capturedFiles.has(path)) commonMap.add(path); + } + } + } else { + commonMap = new Map(); + const map = /** @type {Map} */ (snapshotEntries); + for (const path of capturedFiles) { + const ts = map.get(path); + if (ts === undefined) continue; + commonMap.set(path, ts); + } + } + + if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) { + // Common part it too small + continue; + } + // Create and attach snapshot + const commonSnapshot = new Snapshot(); + if (this._useStartTime) { + commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot); + } + this._set( + commonSnapshot, + /** @type {SnapshotOptimizationValue} */ + (commonMap) + ); + newSnapshot.addChild(commonSnapshot); + snapshot.addChild(commonSnapshot); + // Remove files from snapshot + for (const path of commonMap.keys()) snapshotEntries.delete(path); + const sharedCount = commonMap.size; + this._statItemsUnshared -= sharedCount; + this._statItemsShared += sharedCount; + // Create optimization entry + storeOptimizationEntry({ + snapshot: commonSnapshot, + shared: 2, + snapshotContent: new Set(commonMap.keys()), + children: undefined + }); + this._statSharedSnapshots++; + } + } + const unshared = capturedFiles.size; + this._statItemsUnshared += unshared; + this._statItemsShared += capturedFilesSize - unshared; + } +} + +/** + * Returns result. + * @param {string} str input + * @returns {string} result + */ +const parseString = (str) => { + if (str[0] === "'" || str[0] === "`") { + str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`; + } + return JSON.parse(str); +}; + +/* istanbul ignore next */ +/** + * Processes the provided mtime. + * @param {number} mtime mtime + */ +const applyMtime = (mtime) => { + if (FS_ACCURACY > 1 && mtime % 2 !== 0) FS_ACCURACY = 1; + else if (FS_ACCURACY > 10 && mtime % 20 !== 0) FS_ACCURACY = 10; + else if (FS_ACCURACY > 100 && mtime % 200 !== 0) FS_ACCURACY = 100; + else if (FS_ACCURACY > 1000 && mtime % 2000 !== 0) FS_ACCURACY = 1000; +}; + +/** + * Merges the provided values into a single result. + * @template T + * @template K + * @param {Map | undefined} a source map + * @param {Map | undefined} b joining map + * @returns {Map} joined map + */ +const mergeMaps = (a, b) => { + if (!b || b.size === 0) return /** @type {Map} */ (a); + if (!a || a.size === 0) return /** @type {Map} */ (b); + /** @type {Map} */ + const map = new Map(a); + for (const [key, value] of b) { + map.set(key, value); + } + return map; +}; + +/** + * Merges the provided values into a single result. + * @template T + * @param {Set | undefined} a source map + * @param {Set | undefined} b joining map + * @returns {Set} joined map + */ +const mergeSets = (a, b) => { + if (!b || b.size === 0) return /** @type {Set} */ (a); + if (!a || a.size === 0) return /** @type {Set} */ (b); + /** @type {Set} */ + const map = new Set(a); + for (const item of b) { + map.add(item); + } + return map; +}; + +/** + * Finding file or directory to manage + * @param {string} managedPath path that is managing by {@link FileSystemInfo} + * @param {string} path path to file or directory + * @returns {string | null} managed item + * @example + * getManagedItem( + * '/Users/user/my-project/node_modules/', + * '/Users/user/my-project/node_modules/package/index.js' + * ) === '/Users/user/my-project/node_modules/package' + * getManagedItem( + * '/Users/user/my-project/node_modules/', + * '/Users/user/my-project/node_modules/package1/node_modules/package2' + * ) === '/Users/user/my-project/node_modules/package1/node_modules/package2' + * getManagedItem( + * '/Users/user/my-project/node_modules/', + * '/Users/user/my-project/node_modules/.bin/script.js' + * ) === null // hidden files are disallowed as managed items + * getManagedItem( + * '/Users/user/my-project/node_modules/', + * '/Users/user/my-project/node_modules/package' + * ) === '/Users/user/my-project/node_modules/package' + */ +const getManagedItem = (managedPath, path) => { + let i = managedPath.length; + let slashes = 1; + let startingPosition = true; + loop: while (i < path.length) { + switch (path.charCodeAt(i)) { + case 47: // slash + case 92: // backslash + if (--slashes === 0) break loop; + startingPosition = true; + break; + case 46: // . + // hidden files are disallowed as managed items + // it's probably .yarn-integrity or .cache + if (startingPosition) return null; + break; + case 64: // @ + if (!startingPosition) return null; + slashes++; + break; + default: + startingPosition = false; + break; + } + i++; + } + if (i === path.length) slashes--; + // return null when path is incomplete + if (slashes !== 0) return null; + // if (path.slice(i + 1, i + 13) === "node_modules") + if ( + path.length >= i + 13 && + path.charCodeAt(i + 1) === 110 && + path.charCodeAt(i + 2) === 111 && + path.charCodeAt(i + 3) === 100 && + path.charCodeAt(i + 4) === 101 && + path.charCodeAt(i + 5) === 95 && + path.charCodeAt(i + 6) === 109 && + path.charCodeAt(i + 7) === 111 && + path.charCodeAt(i + 8) === 100 && + path.charCodeAt(i + 9) === 117 && + path.charCodeAt(i + 10) === 108 && + path.charCodeAt(i + 11) === 101 && + path.charCodeAt(i + 12) === 115 + ) { + // if this is the end of the path + if (path.length === i + 13) { + // return the node_modules directory + // it's special + return path; + } + const c = path.charCodeAt(i + 13); + // if next symbol is slash or backslash + if (c === 47 || c === 92) { + // Managed subpath + return getManagedItem(path.slice(0, i + 14), path); + } + } + return path.slice(0, i); +}; + +/** + * Gets resolved timestamp. + * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T + * @param {T | null} entry entry + * @returns {T["resolved"] | null | undefined} the resolved entry + */ +const getResolvedTimestamp = (entry) => { + if (entry === null) return null; + if (entry.resolved !== undefined) return entry.resolved; + return entry.symlinks === undefined ? entry : undefined; +}; + +/** + * Gets resolved hash. + * @param {ContextHash | null} entry entry + * @returns {string | null | undefined} the resolved entry + */ +const getResolvedHash = (entry) => { + if (entry === null) return null; + if (entry.resolved !== undefined) return entry.resolved; + return entry.symlinks === undefined ? entry.hash : undefined; +}; + +/** + * Adds the provided source to the snapshot optimization. + * @template T + * @param {Set} source source + * @param {Set} target target + */ +const addAll = (source, target) => { + for (const key of source) target.add(key); +}; + +const getEsModuleLexer = memoize(() => require("es-module-lexer")); + +/** @typedef {Set} LoggedPaths */ + +/** @typedef {FileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} FileTimestamp */ +/** @typedef {ContextFileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} ContextTimestamp */ +/** @typedef {ResolvedContextFileSystemInfoEntry | "ignore" | null} ResolvedContextTimestamp */ + +/** + * `watchpack` may report `{}` (existence-only) for files and directories it + * is watching but has no time information for. Such entries cannot be used + * for snapshot comparison, so cache lookups treat them as "no cached value" + * and fall back to a fresh on-disk read. + * @param {FileTimestamp | ContextTimestamp | undefined} entry cache entry + * @returns {entry is ExistenceOnlyTimeEntry} true if the entry exists but carries no time info + */ +const isExistenceOnly = (entry) => { + if (entry === undefined || entry === null || entry === "ignore") return false; + return ( + /** @type {Partial & Partial} */ + (entry).safeTime === undefined + ); +}; + +/** @typedef {(err?: WebpackError | null, result?: boolean) => void} CheckSnapshotValidCallback */ + +/** + * Used to access information about the filesystem in a cached way + */ +class FileSystemInfo { + /** + * Creates an instance of FileSystemInfo. + * @param {InputFileSystem} fs file system + * @param {object} options options + * @param {Iterable=} options.unmanagedPaths paths that are not managed by a package manager and the contents are subject to change + * @param {Iterable=} options.managedPaths paths that are only managed by a package manager + * @param {Iterable=} options.immutablePaths paths that are immutable + * @param {Logger=} options.logger logger used to log invalid snapshots + * @param {HashFunction=} options.hashFunction the hash function to use + */ + constructor( + fs, + { + unmanagedPaths = [], + managedPaths = [], + immutablePaths = [], + logger, + hashFunction = DEFAULTS.HASH_FUNCTION + } = {} + ) { + this.fs = fs; + this.logger = logger; + this._remainingLogs = logger ? 40 : 0; + /** @type {LoggedPaths | undefined} */ + this._loggedPaths = logger ? new Set() : undefined; + this._hashFunction = hashFunction; + /** @type {WeakMap} */ + this._snapshotCache = new WeakMap(); + this._fileTimestampsOptimization = new SnapshotOptimization( + (s) => s.hasFileTimestamps(), + (s) => s.fileTimestamps, + (s, v) => s.setFileTimestamps(v) + ); + this._fileHashesOptimization = new SnapshotOptimization( + (s) => s.hasFileHashes(), + (s) => s.fileHashes, + (s, v) => s.setFileHashes(v), + false + ); + this._fileTshsOptimization = new SnapshotOptimization( + (s) => s.hasFileTshs(), + (s) => s.fileTshs, + (s, v) => s.setFileTshs(v) + ); + this._contextTimestampsOptimization = new SnapshotOptimization( + (s) => s.hasContextTimestamps(), + (s) => s.contextTimestamps, + (s, v) => s.setContextTimestamps(v) + ); + this._contextHashesOptimization = new SnapshotOptimization( + (s) => s.hasContextHashes(), + (s) => s.contextHashes, + (s, v) => s.setContextHashes(v), + false + ); + this._contextTshsOptimization = new SnapshotOptimization( + (s) => s.hasContextTshs(), + (s) => s.contextTshs, + (s, v) => s.setContextTshs(v) + ); + this._missingExistenceOptimization = new SnapshotOptimization( + (s) => s.hasMissingExistence(), + (s) => s.missingExistence, + (s, v) => s.setMissingExistence(v), + false + ); + this._managedItemInfoOptimization = new SnapshotOptimization( + (s) => s.hasManagedItemInfo(), + (s) => s.managedItemInfo, + (s, v) => s.setManagedItemInfo(v), + false + ); + this._managedFilesOptimization = new SnapshotOptimization( + (s) => s.hasManagedFiles(), + (s) => s.managedFiles, + (s, v) => s.setManagedFiles(v), + false, + true + ); + this._managedContextsOptimization = new SnapshotOptimization( + (s) => s.hasManagedContexts(), + (s) => s.managedContexts, + (s, v) => s.setManagedContexts(v), + false, + true + ); + this._managedMissingOptimization = new SnapshotOptimization( + (s) => s.hasManagedMissing(), + (s) => s.managedMissing, + (s, v) => s.setManagedMissing(v), + false, + true + ); + /** @type {StackedCacheMap} */ + this._fileTimestamps = new StackedCacheMap(); + /** @type {Map} */ + this._fileHashes = new Map(); + /** @type {Map} */ + this._fileTshs = new Map(); + /** @type {StackedCacheMap} */ + this._contextTimestamps = new StackedCacheMap(); + /** @type {Map} */ + this._contextHashes = new Map(); + /** @type {Map} */ + this._contextTshs = new Map(); + /** @type {Map} */ + this._managedItems = new Map(); + /** @type {AsyncQueue} */ + this.fileTimestampQueue = new AsyncQueue({ + name: "file timestamp", + parallelism: 30, + processor: this._readFileTimestamp.bind(this) + }); + /** @type {AsyncQueue} */ + this.fileHashQueue = new AsyncQueue({ + name: "file hash", + parallelism: 10, + processor: this._readFileHash.bind(this) + }); + /** @type {AsyncQueue} */ + this.contextTimestampQueue = new AsyncQueue({ + name: "context timestamp", + parallelism: 2, + processor: this._readContextTimestamp.bind(this) + }); + /** @type {AsyncQueue} */ + this.contextHashQueue = new AsyncQueue({ + name: "context hash", + parallelism: 2, + processor: this._readContextHash.bind(this) + }); + /** @type {AsyncQueue} */ + this.contextTshQueue = new AsyncQueue({ + name: "context hash and timestamp", + parallelism: 2, + processor: this._readContextTimestampAndHash.bind(this) + }); + /** @type {AsyncQueue} */ + this.managedItemQueue = new AsyncQueue({ + name: "managed item info", + parallelism: 10, + processor: this._getManagedItemInfo.bind(this) + }); + /** @type {AsyncQueue>} */ + this.managedItemDirectoryQueue = new AsyncQueue({ + name: "managed item directory info", + parallelism: 10, + processor: this._getManagedItemDirectoryInfo.bind(this) + }); + const _unmanagedPaths = [...unmanagedPaths]; + /** @type {string[]} */ + this.unmanagedPathsWithSlash = _unmanagedPaths + .filter((p) => typeof p === "string") + .map((p) => join(fs, p, "_").slice(0, -1)); + /** @type {RegExp[]} */ + this.unmanagedPathsRegExps = _unmanagedPaths.filter( + (p) => typeof p !== "string" + ); + + this.managedPaths = [...managedPaths]; + /** @type {string[]} */ + this.managedPathsWithSlash = this.managedPaths + .filter((p) => typeof p === "string") + .map((p) => join(fs, p, "_").slice(0, -1)); + /** @type {RegExp[]} */ + this.managedPathsRegExps = this.managedPaths.filter( + (p) => typeof p !== "string" + ); + + this.immutablePaths = [...immutablePaths]; + /** @type {string[]} */ + this.immutablePathsWithSlash = this.immutablePaths + .filter((p) => typeof p === "string") + .map((p) => join(fs, p, "_").slice(0, -1)); + /** @type {RegExp[]} */ + this.immutablePathsRegExps = this.immutablePaths.filter( + (p) => typeof p !== "string" + ); + + this._cachedDeprecatedFileTimestamps = undefined; + this._cachedDeprecatedContextTimestamps = undefined; + + this._warnAboutExperimentalEsmTracking = false; + + this._statCreatedSnapshots = 0; + this._statTestedSnapshotsCached = 0; + this._statTestedSnapshotsNotCached = 0; + this._statTestedChildrenCached = 0; + this._statTestedChildrenNotCached = 0; + this._statTestedEntries = 0; + } + + logStatistics() { + const logger = /** @type {Logger} */ (this.logger); + /** + * Processes the provided header. + * @param {string} header header + * @param {string | undefined} message message + */ + const logWhenMessage = (header, message) => { + if (message) { + logger.log(`${header}: ${message}`); + } + }; + logger.log(`${this._statCreatedSnapshots} new snapshots created`); + logger.log( + `${ + this._statTestedSnapshotsNotCached && + Math.round( + (this._statTestedSnapshotsNotCached * 100) / + (this._statTestedSnapshotsCached + + this._statTestedSnapshotsNotCached) + ) + }% root snapshot uncached (${this._statTestedSnapshotsNotCached} / ${ + this._statTestedSnapshotsCached + this._statTestedSnapshotsNotCached + })` + ); + logger.log( + `${ + this._statTestedChildrenNotCached && + Math.round( + (this._statTestedChildrenNotCached * 100) / + (this._statTestedChildrenCached + this._statTestedChildrenNotCached) + ) + }% children snapshot uncached (${this._statTestedChildrenNotCached} / ${ + this._statTestedChildrenCached + this._statTestedChildrenNotCached + })` + ); + logger.log(`${this._statTestedEntries} entries tested`); + logger.log( + `File info in cache: ${this._fileTimestamps.size} timestamps ${this._fileHashes.size} hashes ${this._fileTshs.size} timestamp hash combinations` + ); + logWhenMessage( + "File timestamp snapshot optimization", + this._fileTimestampsOptimization.getStatisticMessage() + ); + logWhenMessage( + "File hash snapshot optimization", + this._fileHashesOptimization.getStatisticMessage() + ); + logWhenMessage( + "File timestamp hash combination snapshot optimization", + this._fileTshsOptimization.getStatisticMessage() + ); + logger.log( + `Directory info in cache: ${this._contextTimestamps.size} timestamps ${this._contextHashes.size} hashes ${this._contextTshs.size} timestamp hash combinations` + ); + logWhenMessage( + "Directory timestamp snapshot optimization", + this._contextTimestampsOptimization.getStatisticMessage() + ); + logWhenMessage( + "Directory hash snapshot optimization", + this._contextHashesOptimization.getStatisticMessage() + ); + logWhenMessage( + "Directory timestamp hash combination snapshot optimization", + this._contextTshsOptimization.getStatisticMessage() + ); + logWhenMessage( + "Missing items snapshot optimization", + this._missingExistenceOptimization.getStatisticMessage() + ); + logger.log(`Managed items info in cache: ${this._managedItems.size} items`); + logWhenMessage( + "Managed items snapshot optimization", + this._managedItemInfoOptimization.getStatisticMessage() + ); + logWhenMessage( + "Managed files snapshot optimization", + this._managedFilesOptimization.getStatisticMessage() + ); + logWhenMessage( + "Managed contexts snapshot optimization", + this._managedContextsOptimization.getStatisticMessage() + ); + logWhenMessage( + "Managed missing snapshot optimization", + this._managedMissingOptimization.getStatisticMessage() + ); + } + + /** + * Processes the provided path. + * @private + * @param {string} path path + * @param {string} reason reason + * @param {EXPECTED_ANY[]} args arguments + */ + _log(path, reason, ...args) { + const key = path + reason; + const loggedPaths = /** @type {LoggedPaths} */ (this._loggedPaths); + if (loggedPaths.has(key)) return; + loggedPaths.add(key); + /** @type {Logger} */ + (this.logger).debug(`${path} invalidated because ${reason}`, ...args); + if (--this._remainingLogs === 0) { + /** @type {Logger} */ + (this.logger).debug( + "Logging limit has been reached and no further logging will be emitted by FileSystemInfo" + ); + } + } + + clear() { + this._remainingLogs = this.logger ? 40 : 0; + if (this._loggedPaths !== undefined) this._loggedPaths.clear(); + + this._snapshotCache = new WeakMap(); + this._fileTimestampsOptimization.clear(); + this._fileHashesOptimization.clear(); + this._fileTshsOptimization.clear(); + this._contextTimestampsOptimization.clear(); + this._contextHashesOptimization.clear(); + this._contextTshsOptimization.clear(); + this._missingExistenceOptimization.clear(); + this._managedItemInfoOptimization.clear(); + this._managedFilesOptimization.clear(); + this._managedContextsOptimization.clear(); + this._managedMissingOptimization.clear(); + this._fileTimestamps.clear(); + this._fileHashes.clear(); + this._fileTshs.clear(); + this._contextTimestamps.clear(); + this._contextHashes.clear(); + this._contextTshs.clear(); + this._managedItems.clear(); + this._managedItems.clear(); + + this._cachedDeprecatedFileTimestamps = undefined; + this._cachedDeprecatedContextTimestamps = undefined; + + this._statCreatedSnapshots = 0; + this._statTestedSnapshotsCached = 0; + this._statTestedSnapshotsNotCached = 0; + this._statTestedChildrenCached = 0; + this._statTestedChildrenNotCached = 0; + this._statTestedEntries = 0; + } + + /** + * Adds file timestamps. + * @param {ReadonlyMap} map timestamps + * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it + * @returns {void} + */ + addFileTimestamps(map, immutable) { + this._fileTimestamps.addAll(map, immutable); + this._cachedDeprecatedFileTimestamps = undefined; + } + + /** + * Adds context timestamps. + * @param {ReadonlyMap} map timestamps + * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it + * @returns {void} + */ + addContextTimestamps(map, immutable) { + this._contextTimestamps.addAll(map, immutable); + this._cachedDeprecatedContextTimestamps = undefined; + } + + /** + * Gets file timestamp. + * @param {string} path file path + * @param {(err?: WebpackError | null, fileTimestamp?: FileSystemInfoEntry | "ignore" | null) => void} callback callback function + * @returns {void} + */ + getFileTimestamp(path, callback) { + const cache = this._fileTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + return callback( + null, + /** @type {FileSystemInfoEntry | "ignore" | null} */ (cache) + ); + } + this.fileTimestampQueue.add(path, callback); + } + + /** + * Gets context timestamp. + * @param {string} path context path + * @param {(err?: WebpackError | null, resolvedContextTimestamp?: ResolvedContextTimestamp) => void} callback callback function + * @returns {void} + */ + getContextTimestamp(path, callback) { + const cache = this._contextTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + if (cache === "ignore") return callback(null, "ignore"); + const fullEntry = + /** @type {ContextFileSystemInfoEntry | null} */ + (cache); + const resolved = getResolvedTimestamp(fullEntry); + if (resolved !== undefined) return callback(null, resolved); + return this._resolveContextTimestamp( + /** @type {ContextFileSystemInfoEntry} */ + (fullEntry), + callback + ); + } + this._readFreshContextTimestamp(path, callback); + } + + /** + * Reads a context timestamp directly from disk, bypassing any cached + * entry. Used by `getContextTimestamp` and the snapshot validity + * checks when the cached entry is missing or is an `ExistenceOnlyTimeEntry` + * (`{}`) supplied by watchpack — both cases require a fresh read to + * obtain the `timestampHash`. + * @private + * @param {string} path context path + * @param {(err?: WebpackError | null, resolvedContextTimestamp?: ResolvedContextTimestamp) => void} callback callback function + * @returns {void} + */ + _readFreshContextTimestamp(path, callback) { + this.contextTimestampQueue.add(path, (err, _entry) => { + if (err) return callback(err); + const entry = /** @type {ContextFileSystemInfoEntry | null} */ (_entry); + if (entry === null) return callback(null, null); + const resolved = getResolvedTimestamp(entry); + if (resolved !== undefined) return callback(null, resolved); + this._resolveContextTimestamp(entry, callback); + }); + } + + /** + * Get unresolved context timestamp. Existence-only cache entries (`{}`) + * are bypassed so the callback always receives a complete entry, "ignore" + * or null. + * @private + * @param {string} path context path + * @param {(err?: WebpackError | null, contextTimestamp?: ContextFileSystemInfoEntry | "ignore" | null) => void} callback callback function + * @returns {void} + */ + _getUnresolvedContextTimestamp(path, callback) { + const cache = this._contextTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + return callback( + null, + /** @type {ContextFileSystemInfoEntry | "ignore" | null} */ (cache) + ); + } + this.contextTimestampQueue.add(path, callback); + } + + /** + * Returns file hash. + * @param {string} path file path + * @param {(err?: WebpackError | null, hash?: string | null) => void} callback callback function + * @returns {void} + */ + getFileHash(path, callback) { + const cache = this._fileHashes.get(path); + if (cache !== undefined) return callback(null, cache); + this.fileHashQueue.add(path, callback); + } + + /** + * Returns context hash. + * @param {string} path context path + * @param {(err?: WebpackError | null, contextHash?: string) => void} callback callback function + * @returns {void} + */ + getContextHash(path, callback) { + const cache = this._contextHashes.get(path); + if (cache !== undefined) { + const resolved = getResolvedHash(cache); + if (resolved !== undefined) { + return callback(null, /** @type {string} */ (resolved)); + } + return this._resolveContextHash(cache, callback); + } + this.contextHashQueue.add(path, (err, _entry) => { + if (err) return callback(err); + const entry = /** @type {ContextHash} */ (_entry); + const resolved = getResolvedHash(entry); + if (resolved !== undefined) { + return callback(null, /** @type {string} */ (resolved)); + } + this._resolveContextHash(entry, callback); + }); + } + + /** + * Get unresolved context hash. + * @private + * @param {string} path context path + * @param {(err?: WebpackError | null, contextHash?: ContextHash | null) => void} callback callback function + * @returns {void} + */ + _getUnresolvedContextHash(path, callback) { + const cache = this._contextHashes.get(path); + if (cache !== undefined) return callback(null, cache); + this.contextHashQueue.add(path, callback); + } + + /** + * Returns context tsh. + * @param {string} path context path + * @param {(err?: WebpackError | null, resolvedContextTimestampAndHash?: ResolvedContextTimestampAndHash | null) => void} callback callback function + * @returns {void} + */ + getContextTsh(path, callback) { + const cache = this._contextTshs.get(path); + if (cache !== undefined) { + const resolved = getResolvedTimestamp(cache); + if (resolved !== undefined) return callback(null, resolved); + return this._resolveContextTsh(cache, callback); + } + this.contextTshQueue.add(path, (err, _entry) => { + if (err) return callback(err); + const entry = /** @type {ContextTimestampAndHash} */ (_entry); + const resolved = getResolvedTimestamp(entry); + if (resolved !== undefined) return callback(null, resolved); + this._resolveContextTsh(entry, callback); + }); + } + + /** + * Get unresolved context tsh. + * @private + * @param {string} path context path + * @param {(err?: WebpackError | null, contextTimestampAndHash?: ContextTimestampAndHash | null) => void} callback callback function + * @returns {void} + */ + _getUnresolvedContextTsh(path, callback) { + const cache = this._contextTshs.get(path); + if (cache !== undefined) return callback(null, cache); + this.contextTshQueue.add(path, callback); + } + + _createBuildDependenciesResolvers() { + const resolveContext = createResolver({ + resolveToContext: true, + exportsFields: [], + fileSystem: this.fs + }); + const resolveCjs = createResolver({ + extensions: [".js", ".json", ".node"], + conditionNames: ["require", "module-sync", "node"], + exportsFields: ["exports"], + fileSystem: this.fs + }); + const resolveCjsAsChild = createResolver({ + extensions: [".js", ".json", ".node"], + conditionNames: ["require", "module-sync", "node"], + exportsFields: [], + fileSystem: this.fs + }); + const resolveEsm = createResolver({ + extensions: [".js", ".json", ".node"], + fullySpecified: true, + conditionNames: ["import", "module-sync", "node"], + exportsFields: ["exports"], + fileSystem: this.fs + }); + return { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild }; + } + + /** + * Resolves build dependencies. + * @param {string} context context directory + * @param {Iterable} deps dependencies + * @param {(err?: Error | null, resolveBuildDependenciesResult?: ResolveBuildDependenciesResult) => void} callback callback function + * @returns {void} + */ + resolveBuildDependencies(context, deps, callback) { + const { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild } = + this._createBuildDependenciesResolvers(); + + /** @type {Files} */ + const files = new Set(); + /** @type {Symlinks} */ + const fileSymlinks = new Set(); + /** @type {Directories} */ + const directories = new Set(); + /** @type {Symlinks} */ + const directorySymlinks = new Set(); + /** @type {Missing} */ + const missing = new Set(); + /** @type {ResolveDependencies["files"]} */ + const resolveFiles = new Set(); + /** @type {ResolveDependencies["directories"]} */ + const resolveDirectories = new Set(); + /** @type {ResolveDependencies["missing"]} */ + const resolveMissing = new Set(); + /** @type {ResolveResults} */ + const resolveResults = new Map(); + /** @type {Set} */ + const invalidResolveResults = new Set(); + const resolverContext = { + fileDependencies: resolveFiles, + contextDependencies: resolveDirectories, + missingDependencies: resolveMissing + }; + /** + * Expected to string. + * @param {undefined | boolean | string} expected expected result + * @returns {string} expected result + */ + const expectedToString = (expected) => + expected ? ` (expected ${expected})` : ""; + /** @typedef {{ type: JobType, context: string | undefined, path: string, issuer: Job | undefined, expected: undefined | boolean | string }} Job */ + + /** + * Returns result. + * @param {Job} job job + * @returns {string} result + */ + const jobToString = (job) => { + switch (job.type) { + case RBDT_RESOLVE_FILE: + return `resolve file ${job.path}${expectedToString(job.expected)}`; + case RBDT_RESOLVE_DIRECTORY: + return `resolve directory ${job.path}`; + case RBDT_RESOLVE_CJS_FILE: + return `resolve commonjs file ${job.path}${expectedToString( + job.expected + )}`; + case RBDT_RESOLVE_ESM_FILE: + return `resolve esm file ${job.path}${expectedToString( + job.expected + )}`; + case RBDT_DIRECTORY: + return `directory ${job.path}`; + case RBDT_FILE: + return `file ${job.path}`; + case RBDT_DIRECTORY_DEPENDENCIES: + return `directory dependencies ${job.path}`; + case RBDT_FILE_DEPENDENCIES: + return `file dependencies ${job.path}`; + } + return `unknown ${job.type} ${job.path}`; + }; + /** + * Returns string value. + * @param {Job} job job + * @returns {string} string value + */ + const pathToString = (job) => { + let result = ` at ${jobToString(job)}`; + /** @type {Job | undefined} */ + (job) = job.issuer; + while (job !== undefined) { + result += `\n at ${jobToString(job)}`; + job = /** @type {Job} */ (job.issuer); + } + return result; + }; + const logger = /** @type {Logger} */ (this.logger); + processAsyncTree( + Array.from( + deps, + (dep) => + /** @type {Job} */ ({ + type: RBDT_RESOLVE_INITIAL, + context, + path: dep, + expected: undefined, + issuer: undefined + }) + ), + 20, + (job, push, callback) => { + const { type, context, path, expected } = job; + /** + * Resolves directory. + * @param {string} path path + * @returns {void} + */ + const resolveDirectory = (path) => { + const key = `d\n${context}\n${path}`; + if (resolveResults.has(key)) { + return callback(); + } + resolveResults.set(key, undefined); + resolveContext( + /** @type {string} */ (context), + path, + resolverContext, + (err, _, result) => { + if (err) { + if (expected === false) { + resolveResults.set(key, false); + return callback(); + } + invalidResolveResults.add(key); + err.message += `\nwhile resolving '${path}' in ${context} to a directory`; + return callback(err); + } + const resultPath = /** @type {ResolveRequest} */ (result).path; + resolveResults.set(key, resultPath); + push({ + type: RBDT_DIRECTORY, + context: undefined, + path: /** @type {string} */ (resultPath), + expected: undefined, + issuer: job + }); + callback(); + } + ); + }; + /** + * Processes the provided path. + * @param {string} path path + * @param {("f" | "c" | "e")=} symbol symbol + * @param {(ResolveFunctionAsync)=} resolve resolve fn + * @returns {void} + */ + const resolveFile = (path, symbol, resolve) => { + const key = `${symbol}\n${context}\n${path}`; + if (resolveResults.has(key)) { + return callback(); + } + resolveResults.set(key, undefined); + /** @type {ResolveFunctionAsync} */ + (resolve)( + /** @type {string} */ (context), + path, + resolverContext, + (err, _, result) => { + if (typeof expected === "string") { + if (!err && result && result.path === expected) { + resolveResults.set(key, result.path); + } else { + invalidResolveResults.add(key); + logger.warn( + `Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${ + err || (result && result.path) + }' instead. Resolving dependencies are ignored for this path.\n${pathToString( + job + )}` + ); + } + } else { + if (err) { + if (expected === false) { + resolveResults.set(key, false); + return callback(); + } + invalidResolveResults.add(key); + err.message += `\nwhile resolving '${path}' in ${context} as file\n${pathToString( + job + )}`; + return callback(err); + } + const resultPath = /** @type {ResolveRequest} */ (result).path; + resolveResults.set(key, resultPath); + push({ + type: RBDT_FILE, + context: undefined, + path: /** @type {string} */ (resultPath), + expected: undefined, + issuer: job + }); + } + callback(); + } + ); + }; + const resolvedType = + type === RBDT_RESOLVE_INITIAL + ? /[\\/]$/.test(path) + ? RBDT_RESOLVE_DIRECTORY + : RBDT_RESOLVE_FILE + : type; + switch (resolvedType) { + case RBDT_RESOLVE_FILE: { + resolveFile( + path, + "f", + /\.mjs$/.test(path) ? resolveEsm : resolveCjs + ); + break; + } + case RBDT_RESOLVE_DIRECTORY: { + resolveDirectory( + type === RBDT_RESOLVE_INITIAL ? path.slice(0, -1) : path + ); + break; + } + case RBDT_RESOLVE_CJS_FILE: { + resolveFile(path, "f", resolveCjs); + break; + } + case RBDT_RESOLVE_CJS_FILE_AS_CHILD: { + resolveFile(path, "c", resolveCjsAsChild); + break; + } + case RBDT_RESOLVE_ESM_FILE: { + resolveFile(path, "e", resolveEsm); + break; + } + case RBDT_FILE: { + if (files.has(path)) { + callback(); + break; + } + files.add(path); + /** @type {NonNullable} */ + (this.fs.realpath)(path, (err, _realPath) => { + if (err) return callback(err); + const realPath = /** @type {string} */ (_realPath); + if (realPath !== path) { + fileSymlinks.add(path); + resolveFiles.add(path); + if (files.has(realPath)) return callback(); + files.add(realPath); + } + push({ + type: RBDT_FILE_DEPENDENCIES, + context: undefined, + path: realPath, + expected: undefined, + issuer: job + }); + callback(); + }); + break; + } + case RBDT_DIRECTORY: { + if (directories.has(path)) { + callback(); + break; + } + directories.add(path); + /** @type {NonNullable} */ + (this.fs.realpath)(path, (err, _realPath) => { + if (err) return callback(err); + const realPath = /** @type {string} */ (_realPath); + if (realPath !== path) { + directorySymlinks.add(path); + resolveFiles.add(path); + if (directories.has(realPath)) return callback(); + directories.add(realPath); + } + push({ + type: RBDT_DIRECTORY_DEPENDENCIES, + context: undefined, + path: realPath, + expected: undefined, + issuer: job + }); + callback(); + }); + break; + } + case RBDT_FILE_DEPENDENCIES: { + // Check for known files without dependencies + if (/\.json5?$|\.yarn-integrity$|yarn\.lock$|\.ya?ml/.test(path)) { + process.nextTick(callback); + break; + } + // Check commonjs cache for the module + /** @type {NodeModule | undefined} */ + const module = require.cache[path]; + if ( + module && + Array.isArray(module.children) && + // https://github.com/nodejs/node/issues/59868 + // Force use `es-module-lexer` for mjs + !/\.mjs$/.test(path) + ) { + children: for (const child of module.children) { + const childPath = child.filename; + if (childPath) { + push({ + type: RBDT_FILE, + context: undefined, + path: childPath, + expected: undefined, + issuer: job + }); + const context = dirname(this.fs, path); + for (const modulePath of module.paths) { + if (childPath.startsWith(modulePath)) { + const subPath = childPath.slice(modulePath.length + 1); + const packageMatch = /^@[^\\/]+[\\/][^\\/]+/.exec( + subPath + ); + if (packageMatch) { + push({ + type: RBDT_FILE, + context: undefined, + path: `${ + modulePath + + childPath[modulePath.length] + + packageMatch[0] + + childPath[modulePath.length] + }package.json`, + expected: false, + issuer: job + }); + } + let request = subPath.replace(/\\/g, "/"); + if (request.endsWith(".js")) { + request = request.slice(0, -3); + } + push({ + type: RBDT_RESOLVE_CJS_FILE_AS_CHILD, + context, + path: request, + expected: child.filename, + issuer: job + }); + continue children; + } + } + let request = relative(this.fs, context, childPath); + if (request.endsWith(".js")) request = request.slice(0, -3); + request = request.replace(/\\/g, "/"); + if (!request.startsWith("../") && !isAbsolute(request)) { + request = `./${request}`; + } + push({ + type: RBDT_RESOLVE_CJS_FILE, + context, + path: request, + expected: child.filename, + issuer: job + }); + } + } + } else if (supportsEsm && /\.m?js$/.test(path)) { + if (!this._warnAboutExperimentalEsmTracking) { + logger.log( + "Node.js doesn't offer a (nice) way to introspect the ESM dependency graph yet.\n" + + "Until a full solution is available webpack uses an experimental ESM tracking based on parsing.\n" + + "As best effort webpack parses the ESM files to guess dependencies. But this can lead to expensive and incorrect tracking." + ); + this._warnAboutExperimentalEsmTracking = true; + } + + const lexer = getEsModuleLexer(); + + lexer.init.then(() => { + this.fs.readFile(path, (err, content) => { + if (err) return callback(err); + try { + const context = dirname(this.fs, path); + const source = /** @type {Buffer} */ (content).toString(); + const [imports] = lexer.parse(source); + /** @type {Set} */ + const added = new Set(); + for (const imp of imports) { + try { + /** @type {string} */ + let dependency; + if (imp.d === -1) { + // import ... from "..." + dependency = parseString( + source.slice(imp.s - 1, imp.e + 1) + ); + } else if (imp.d > -1) { + // import() + const expr = source.slice(imp.s, imp.e).trim(); + dependency = parseString(expr); + } else { + // e.g. import.meta + continue; + } + + // We should not track Node.js build dependencies + if (dependency.startsWith("node:")) continue; + if (builtinModules.has(dependency)) continue; + // Avoid extra jobs for identical imports + if (added.has(dependency)) continue; + + push({ + type: RBDT_RESOLVE_ESM_FILE, + context, + path: dependency, + expected: imp.d > -1 ? false : undefined, + issuer: job + }); + added.add(dependency); + } catch (err1) { + logger.warn( + `Parsing of ${path} for build dependencies failed at 'import(${source.slice( + imp.s, + imp.e + )})'.\n` + + "Build dependencies behind this expression are ignored and might cause incorrect cache invalidation." + ); + logger.debug(pathToString(job)); + logger.debug(/** @type {Error} */ (err1).stack); + } + } + } catch (err2) { + logger.warn( + `Parsing of ${path} for build dependencies failed and all dependencies of this file are ignored, which might cause incorrect cache invalidation..` + ); + logger.debug(pathToString(job)); + logger.debug(/** @type {Error} */ (err2).stack); + } + process.nextTick(callback); + }); + }, callback); + break; + } else { + logger.log( + `Assuming ${path} has no dependencies as we were unable to assign it to any module system.` + ); + logger.debug(pathToString(job)); + } + process.nextTick(callback); + break; + } + case RBDT_DIRECTORY_DEPENDENCIES: { + const match = + /(^.+[\\/]node_modules[\\/](?:@[^\\/]+[\\/])?[^\\/]+)/.exec(path); + const packagePath = match ? match[1] : path; + const packageJson = join(this.fs, packagePath, "package.json"); + this.fs.readFile(packageJson, (err, content) => { + if (err) { + if (err.code === "ENOENT") { + resolveMissing.add(packageJson); + const parent = dirname(this.fs, packagePath); + if (parent !== packagePath) { + push({ + type: RBDT_DIRECTORY_DEPENDENCIES, + context: undefined, + path: parent, + expected: undefined, + issuer: job + }); + } + callback(); + return; + } + return callback(err); + } + resolveFiles.add(packageJson); + /** @type {JsonObject} */ + let packageData; + try { + packageData = JSON.parse( + /** @type {Buffer} */ + (content).toString("utf8") + ); + } catch (parseErr) { + return callback(/** @type {Error} */ (parseErr)); + } + const depsObject = packageData.dependencies; + const optionalDepsObject = packageData.optionalDependencies; + /** @type {Set} */ + const allDeps = new Set(); + /** @type {Set} */ + const optionalDeps = new Set(); + if (typeof depsObject === "object" && depsObject) { + for (const dep of Object.keys(depsObject)) { + allDeps.add(dep); + } + } + if ( + typeof optionalDepsObject === "object" && + optionalDepsObject + ) { + for (const dep of Object.keys(optionalDepsObject)) { + allDeps.add(dep); + optionalDeps.add(dep); + } + } + for (const dep of allDeps) { + push({ + type: RBDT_RESOLVE_DIRECTORY, + context: packagePath, + path: dep, + expected: !optionalDeps.has(dep), + issuer: job + }); + } + callback(); + }); + break; + } + } + }, + (err) => { + if (err) return callback(err); + for (const l of fileSymlinks) files.delete(l); + for (const l of directorySymlinks) directories.delete(l); + for (const k of invalidResolveResults) resolveResults.delete(k); + callback(null, { + files, + directories, + missing, + resolveResults, + resolveDependencies: { + files: resolveFiles, + directories: resolveDirectories, + missing: resolveMissing + } + }); + } + ); + } + + /** + * Checks resolve results valid. + * @param {ResolveResults} resolveResults results from resolving + * @param {(err?: Error | null, result?: boolean) => void} callback callback with true when resolveResults resolve the same way + * @returns {void} + */ + checkResolveResultsValid(resolveResults, callback) { + const { resolveCjs, resolveCjsAsChild, resolveEsm, resolveContext } = + this._createBuildDependenciesResolvers(); + asyncLib.eachLimit( + resolveResults, + 20, + ([key, expectedResult], callback) => { + const [type, context, path] = key.split("\n"); + switch (type) { + case "d": + resolveContext(context, path, {}, (err, _, result) => { + if (expectedResult === false) { + return callback(err ? undefined : INVALID); + } + if (err) return callback(err); + const resultPath = /** @type {ResolveRequest} */ (result).path; + if (resultPath !== expectedResult) return callback(INVALID); + callback(); + }); + break; + case "f": + resolveCjs(context, path, {}, (err, _, result) => { + if (expectedResult === false) { + return callback(err ? undefined : INVALID); + } + if (err) return callback(err); + const resultPath = /** @type {ResolveRequest} */ (result).path; + if (resultPath !== expectedResult) return callback(INVALID); + callback(); + }); + break; + case "c": + resolveCjsAsChild(context, path, {}, (err, _, result) => { + if (expectedResult === false) { + return callback(err ? undefined : INVALID); + } + if (err) return callback(err); + const resultPath = /** @type {ResolveRequest} */ (result).path; + if (resultPath !== expectedResult) return callback(INVALID); + callback(); + }); + break; + case "e": + resolveEsm(context, path, {}, (err, _, result) => { + if (expectedResult === false) { + return callback(err ? undefined : INVALID); + } + if (err) return callback(err); + const resultPath = /** @type {ResolveRequest} */ (result).path; + if (resultPath !== expectedResult) return callback(INVALID); + callback(); + }); + break; + default: + callback(new Error("Unexpected type in resolve result key")); + break; + } + }, + /** + * Processes the provided err. + * @param {Error | typeof INVALID=} err error or invalid flag + * @returns {void} + */ + /** @type {import("neo-async").ErrorCallback} */ ( + (err) => { + if (err === INVALID) { + return callback(null, false); + } + if (err) { + return callback(err); + } + return callback(null, true); + } + ) + ); + } + + /** + * Creates a snapshot. + * @param {number | null | undefined} startTime when processing the files has started + * @param {Iterable | null | undefined} files all files + * @param {Iterable | null | undefined} directories all directories + * @param {Iterable | null | undefined} missing all missing files or directories + * @param {SnapshotOptions | null | undefined} options options object (for future extensions) + * @param {(err: WebpackError | null, snapshot: Snapshot | null) => void} callback callback function + * @returns {void} + */ + createSnapshot(startTime, files, directories, missing, options, callback) { + /** @type {FileTimestamps} */ + const fileTimestamps = new Map(); + /** @type {FileHashes} */ + const fileHashes = new Map(); + /** @type {FileTshs} */ + const fileTshs = new Map(); + /** @type {ContextTimestamps} */ + const contextTimestamps = new Map(); + /** @type {ContextHashes} */ + const contextHashes = new Map(); + /** @type {ContextTshs} */ + const contextTshs = new Map(); + /** @type {MissingExistence} */ + const missingExistence = new Map(); + /** @type {ManagedItemInfo} */ + const managedItemInfo = new Map(); + /** @type {ManagedFiles} */ + const managedFiles = new Set(); + /** @type {ManagedContexts} */ + const managedContexts = new Set(); + /** @type {ManagedMissing} */ + const managedMissing = new Set(); + /** @type {Children} */ + const children = new Set(); + + const snapshot = new Snapshot(); + if (startTime) snapshot.setStartTime(startTime); + + /** @type {Set} */ + const managedItems = new Set(); + + /** 1 = timestamp, 2 = hash, 3 = timestamp + hash */ + const mode = options && options.hash ? (options.timestamp ? 3 : 2) : 1; + + let jobs = 1; + const jobDone = () => { + if (--jobs === 0) { + if (fileTimestamps.size !== 0) { + snapshot.setFileTimestamps(fileTimestamps); + } + if (fileHashes.size !== 0) { + snapshot.setFileHashes(fileHashes); + } + if (fileTshs.size !== 0) { + snapshot.setFileTshs(fileTshs); + } + if (contextTimestamps.size !== 0) { + snapshot.setContextTimestamps(contextTimestamps); + } + if (contextHashes.size !== 0) { + snapshot.setContextHashes(contextHashes); + } + if (contextTshs.size !== 0) { + snapshot.setContextTshs(contextTshs); + } + if (missingExistence.size !== 0) { + snapshot.setMissingExistence(missingExistence); + } + if (managedItemInfo.size !== 0) { + snapshot.setManagedItemInfo(managedItemInfo); + } + this._managedFilesOptimization.optimize(snapshot, managedFiles); + if (managedFiles.size !== 0) { + snapshot.setManagedFiles(managedFiles); + } + this._managedContextsOptimization.optimize(snapshot, managedContexts); + if (managedContexts.size !== 0) { + snapshot.setManagedContexts(managedContexts); + } + this._managedMissingOptimization.optimize(snapshot, managedMissing); + if (managedMissing.size !== 0) { + snapshot.setManagedMissing(managedMissing); + } + if (children.size !== 0) { + snapshot.setChildren(children); + } + this._snapshotCache.set(snapshot, true); + this._statCreatedSnapshots++; + + callback(null, snapshot); + } + }; + const jobError = () => { + if (jobs > 0) { + // large negative number instead of NaN or something else to keep jobs to stay a SMI (v8) + jobs = -100000000; + callback(null, null); + } + }; + /** + * Checks true when managed. + * @param {string} path path + * @param {ManagedFiles} managedSet managed set + * @returns {boolean} true when managed + */ + const checkManaged = (path, managedSet) => { + for (const unmanagedPath of this.unmanagedPathsRegExps) { + if (unmanagedPath.test(path)) return false; + } + for (const unmanagedPath of this.unmanagedPathsWithSlash) { + if (path.startsWith(unmanagedPath)) return false; + } + for (const immutablePath of this.immutablePathsRegExps) { + if (immutablePath.test(path)) { + managedSet.add(path); + return true; + } + } + for (const immutablePath of this.immutablePathsWithSlash) { + if (path.startsWith(immutablePath)) { + managedSet.add(path); + return true; + } + } + for (const managedPath of this.managedPathsRegExps) { + const match = managedPath.exec(path); + if (match) { + const managedItem = getManagedItem(match[1], path); + if (managedItem) { + managedItems.add(managedItem); + managedSet.add(path); + return true; + } + } + } + for (const managedPath of this.managedPathsWithSlash) { + if (path.startsWith(managedPath)) { + const managedItem = getManagedItem(managedPath, path); + if (managedItem) { + managedItems.add(managedItem); + managedSet.add(path); + return true; + } + } + } + return false; + }; + /** + * Capture non managed. + * @param {Iterable} items items + * @param {Set} managedSet managed set + * @returns {Set} result + */ + const captureNonManaged = (items, managedSet) => { + /** @type {Set} */ + const capturedItems = new Set(); + for (const path of items) { + if (!checkManaged(path, managedSet)) capturedItems.add(path); + } + return capturedItems; + }; + /** + * Process captured files. + * @param {ManagedFiles} capturedFiles captured files + */ + const processCapturedFiles = (capturedFiles) => { + if (capturedFiles.size === 0) { + return; + } + switch (mode) { + case 3: + this._fileTshsOptimization.optimize(snapshot, capturedFiles); + for (const path of capturedFiles) { + const cache = this._fileTshs.get(path); + if (cache !== undefined) { + fileTshs.set(path, cache); + } else { + jobs++; + this._getFileTimestampAndHash(path, (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting file timestamp hash combination of ${path}: ${err.stack}` + ); + } + jobError(); + } else { + fileTshs.set(path, /** @type {TimestampAndHash} */ (entry)); + jobDone(); + } + }); + } + } + break; + case 2: + this._fileHashesOptimization.optimize(snapshot, capturedFiles); + for (const path of capturedFiles) { + const cache = this._fileHashes.get(path); + if (cache !== undefined) { + fileHashes.set(path, cache); + } else { + jobs++; + this.fileHashQueue.add(path, (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting file hash of ${path}: ${err.stack}` + ); + } + jobError(); + } else { + fileHashes.set(path, /** @type {string} */ (entry)); + jobDone(); + } + }); + } + } + break; + case 1: + this._fileTimestampsOptimization.optimize(snapshot, capturedFiles); + for (const path of capturedFiles) { + const cache = this._fileTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + if (cache !== "ignore") { + fileTimestamps.set( + path, + /** @type {FileSystemInfoEntry | null} */ (cache) + ); + } + } else { + jobs++; + this.fileTimestampQueue.add(path, (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting file timestamp of ${path}: ${err.stack}` + ); + } + jobError(); + } else { + fileTimestamps.set( + path, + /** @type {FileSystemInfoEntry} */ + (entry) + ); + jobDone(); + } + }); + } + } + break; + } + }; + if (files) { + processCapturedFiles(captureNonManaged(files, managedFiles)); + } + /** + * Process captured directories. + * @param {ManagedContexts} capturedDirectories captured directories + */ + const processCapturedDirectories = (capturedDirectories) => { + if (capturedDirectories.size === 0) { + return; + } + switch (mode) { + case 3: + this._contextTshsOptimization.optimize(snapshot, capturedDirectories); + for (const path of capturedDirectories) { + const cache = this._contextTshs.get(path); + /** @type {ResolvedContextTimestampAndHash | null | undefined} */ + let resolved; + if ( + cache !== undefined && + (resolved = getResolvedTimestamp(cache)) !== undefined + ) { + contextTshs.set(path, resolved); + } else { + jobs++; + /** + * Processes the provided err. + * @param {(WebpackError | null)=} err error + * @param {(ResolvedContextTimestampAndHash | null)=} entry entry + * @returns {void} + */ + const callback = (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting context timestamp hash combination of ${path}: ${err.stack}` + ); + } + jobError(); + } else { + contextTshs.set( + path, + /** @type {ResolvedContextTimestampAndHash | null} */ + (entry) + ); + jobDone(); + } + }; + if (cache !== undefined) { + this._resolveContextTsh(cache, callback); + } else { + this.getContextTsh(path, callback); + } + } + } + break; + case 2: + this._contextHashesOptimization.optimize( + snapshot, + capturedDirectories + ); + for (const path of capturedDirectories) { + const cache = this._contextHashes.get(path); + /** @type {undefined | null | string} */ + let resolved; + if ( + cache !== undefined && + (resolved = getResolvedHash(cache)) !== undefined + ) { + contextHashes.set(path, resolved); + } else { + jobs++; + /** + * Processes the provided err. + * @param {(WebpackError | null)=} err err + * @param {string=} entry entry + */ + const callback = (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting context hash of ${path}: ${err.stack}` + ); + } + jobError(); + } else { + contextHashes.set(path, /** @type {string} */ (entry)); + jobDone(); + } + }; + if (cache !== undefined) { + this._resolveContextHash(cache, callback); + } else { + this.getContextHash(path, callback); + } + } + } + break; + case 1: + this._contextTimestampsOptimization.optimize( + snapshot, + capturedDirectories + ); + for (const path of capturedDirectories) { + const cache = this._contextTimestamps.get(path); + if (cache === "ignore") continue; + /** @type {ContextFileSystemInfoEntry | null | undefined} */ + const usableCache = + cache === undefined || isExistenceOnly(cache) + ? undefined + : /** @type {ContextFileSystemInfoEntry | null} */ (cache); + // A non-null cache entry without `timestampHash` cannot be + // used to populate the snapshot — the snapshot would then + // miss directory-change detection, since validity relies on + // `timestampHash`. Re-read the directory in that case. + const cacheLacksHash = + usableCache !== undefined && + usableCache !== null && + usableCache.timestampHash === undefined; + /** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */ + let resolved; + if ( + usableCache !== undefined && + !cacheLacksHash && + (resolved = getResolvedTimestamp(usableCache)) !== undefined + ) { + contextTimestamps.set(path, resolved); + } else { + jobs++; + /** + * Processes the provided err. + * @param {(WebpackError | null)=} err error + * @param {ResolvedContextTimestamp=} entry entry + * @returns {void} + */ + const callback = (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting context timestamp of ${path}: ${err.stack}` + ); + } + jobError(); + } else { + contextTimestamps.set( + path, + /** @type {ResolvedContextFileSystemInfoEntry | null} */ + (entry) + ); + jobDone(); + } + }; + if (cacheLacksHash) { + this._readFreshContextTimestamp(path, callback); + } else if (usableCache !== undefined && usableCache !== null) { + this._resolveContextTimestamp(usableCache, callback); + } else { + // Force a fresh on-disk read so the snapshot stores a + // complete entry (with `timestampHash`). + this._readFreshContextTimestamp(path, callback); + } + } + } + break; + } + }; + if (directories) { + processCapturedDirectories( + captureNonManaged(directories, managedContexts) + ); + } + /** + * Process captured missing. + * @param {ManagedMissing} capturedMissing captured missing + */ + const processCapturedMissing = (capturedMissing) => { + if (capturedMissing.size === 0) { + return; + } + this._missingExistenceOptimization.optimize(snapshot, capturedMissing); + for (const path of capturedMissing) { + const cache = this._fileTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + if (cache !== "ignore") { + missingExistence.set(path, Boolean(cache)); + } + } else { + jobs++; + this.fileTimestampQueue.add(path, (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting missing timestamp of ${path}: ${err.stack}` + ); + } + jobError(); + } else { + missingExistence.set(path, Boolean(entry)); + jobDone(); + } + }); + } + } + }; + if (missing) { + processCapturedMissing(captureNonManaged(missing, managedMissing)); + } + this._managedItemInfoOptimization.optimize(snapshot, managedItems); + for (const path of managedItems) { + const cache = this._managedItems.get(path); + if (cache !== undefined) { + if (!cache.startsWith("*")) { + managedFiles.add(join(this.fs, path, "package.json")); + } else if (cache === "*nested") { + managedMissing.add(join(this.fs, path, "package.json")); + } + managedItemInfo.set(path, cache); + } else { + jobs++; + this.managedItemQueue.add(path, (err, entry) => { + if (err) { + if (this.logger) { + this.logger.debug( + `Error snapshotting managed item ${path}: ${err.stack}` + ); + } + jobError(); + } else if (entry) { + if (!entry.startsWith("*")) { + managedFiles.add(join(this.fs, path, "package.json")); + } else if (cache === "*nested") { + managedMissing.add(join(this.fs, path, "package.json")); + } + managedItemInfo.set(path, entry); + jobDone(); + } else { + // Fallback to normal snapshotting + /** + * Processes the provided set. + * @param {Set} set set + * @param {(set: Set) => void} fn fn + */ + const process = (set, fn) => { + if (set.size === 0) return; + /** @type {Set} */ + const captured = new Set(); + for (const file of set) { + if (file.startsWith(path)) captured.add(file); + } + if (captured.size > 0) fn(captured); + }; + process(managedFiles, processCapturedFiles); + process(managedContexts, processCapturedDirectories); + process(managedMissing, processCapturedMissing); + jobDone(); + } + }); + } + } + jobDone(); + } + + /** + * Merges the provided values into a single result. + * @param {Snapshot} snapshot1 a snapshot + * @param {Snapshot} snapshot2 a snapshot + * @returns {Snapshot} merged snapshot + */ + mergeSnapshots(snapshot1, snapshot2) { + const snapshot = new Snapshot(); + if (snapshot1.hasStartTime() && snapshot2.hasStartTime()) { + snapshot.setStartTime( + Math.min( + /** @type {NonNullable} */ + (snapshot1.startTime), + /** @type {NonNullable} */ + (snapshot2.startTime) + ) + ); + } else if (snapshot2.hasStartTime()) { + snapshot.startTime = snapshot2.startTime; + } else if (snapshot1.hasStartTime()) { + snapshot.startTime = snapshot1.startTime; + } + if (snapshot1.hasFileTimestamps() || snapshot2.hasFileTimestamps()) { + snapshot.setFileTimestamps( + mergeMaps(snapshot1.fileTimestamps, snapshot2.fileTimestamps) + ); + } + if (snapshot1.hasFileHashes() || snapshot2.hasFileHashes()) { + snapshot.setFileHashes( + mergeMaps(snapshot1.fileHashes, snapshot2.fileHashes) + ); + } + if (snapshot1.hasFileTshs() || snapshot2.hasFileTshs()) { + snapshot.setFileTshs(mergeMaps(snapshot1.fileTshs, snapshot2.fileTshs)); + } + if (snapshot1.hasContextTimestamps() || snapshot2.hasContextTimestamps()) { + snapshot.setContextTimestamps( + mergeMaps(snapshot1.contextTimestamps, snapshot2.contextTimestamps) + ); + } + if (snapshot1.hasContextHashes() || snapshot2.hasContextHashes()) { + snapshot.setContextHashes( + mergeMaps(snapshot1.contextHashes, snapshot2.contextHashes) + ); + } + if (snapshot1.hasContextTshs() || snapshot2.hasContextTshs()) { + snapshot.setContextTshs( + mergeMaps(snapshot1.contextTshs, snapshot2.contextTshs) + ); + } + if (snapshot1.hasMissingExistence() || snapshot2.hasMissingExistence()) { + snapshot.setMissingExistence( + mergeMaps(snapshot1.missingExistence, snapshot2.missingExistence) + ); + } + if (snapshot1.hasManagedItemInfo() || snapshot2.hasManagedItemInfo()) { + snapshot.setManagedItemInfo( + mergeMaps(snapshot1.managedItemInfo, snapshot2.managedItemInfo) + ); + } + if (snapshot1.hasManagedFiles() || snapshot2.hasManagedFiles()) { + snapshot.setManagedFiles( + mergeSets(snapshot1.managedFiles, snapshot2.managedFiles) + ); + } + if (snapshot1.hasManagedContexts() || snapshot2.hasManagedContexts()) { + snapshot.setManagedContexts( + mergeSets(snapshot1.managedContexts, snapshot2.managedContexts) + ); + } + if (snapshot1.hasManagedMissing() || snapshot2.hasManagedMissing()) { + snapshot.setManagedMissing( + mergeSets(snapshot1.managedMissing, snapshot2.managedMissing) + ); + } + if (snapshot1.hasChildren() || snapshot2.hasChildren()) { + snapshot.setChildren(mergeSets(snapshot1.children, snapshot2.children)); + } + if ( + this._snapshotCache.get(snapshot1) === true && + this._snapshotCache.get(snapshot2) === true + ) { + this._snapshotCache.set(snapshot, true); + } + return snapshot; + } + + /** + * Checks snapshot valid. + * @param {Snapshot} snapshot the snapshot made + * @param {CheckSnapshotValidCallback} callback callback function + * @returns {void} + */ + checkSnapshotValid(snapshot, callback) { + const cachedResult = this._snapshotCache.get(snapshot); + if (cachedResult !== undefined) { + this._statTestedSnapshotsCached++; + if (typeof cachedResult === "boolean") { + callback(null, cachedResult); + } else { + cachedResult.push(callback); + } + return; + } + this._statTestedSnapshotsNotCached++; + this._checkSnapshotValidNoCache(snapshot, callback); + } + + /** + * Check snapshot valid no cache. + * @private + * @param {Snapshot} snapshot the snapshot made + * @param {CheckSnapshotValidCallback} callback callback function + * @returns {void} + */ + _checkSnapshotValidNoCache(snapshot, callback) { + /** @type {number | undefined} */ + let startTime; + if (snapshot.hasStartTime()) { + startTime = snapshot.startTime; + } + let jobs = 1; + const jobDone = () => { + if (--jobs === 0) { + this._snapshotCache.set(snapshot, true); + callback(null, true); + } + }; + const invalid = () => { + if (jobs > 0) { + // large negative number instead of NaN or something else to keep jobs to stay a SMI (v8) + jobs = -100000000; + this._snapshotCache.set(snapshot, false); + callback(null, false); + } + }; + /** + * Invalid with error. + * @param {string} path path + * @param {WebpackError} err err + */ + const invalidWithError = (path, err) => { + if (this._remainingLogs > 0) { + this._log(path, "error occurred: %s", err); + } + invalid(); + }; + /** + * Checks true, if ok. + * @param {string} path file path + * @param {string | null} current current hash + * @param {string | null} snap snapshot hash + * @returns {boolean} true, if ok + */ + const checkHash = (path, current, snap) => { + if (current !== snap) { + // If hash differ it's invalid + if (this._remainingLogs > 0) { + this._log(path, "hashes differ (%s != %s)", current, snap); + } + return false; + } + return true; + }; + /** + * Checks true, if ok. + * @param {string} path file path + * @param {boolean} current current entry + * @param {boolean} snap entry from snapshot + * @returns {boolean} true, if ok + */ + const checkExistence = (path, current, snap) => { + if (!current !== !snap) { + // If existence of item differs + // it's invalid + if (this._remainingLogs > 0) { + this._log( + path, + current ? "it didn't exist before" : "it does no longer exist" + ); + } + return false; + } + return true; + }; + /** + * Checks true, if ok. + * @param {string} path file path + * @param {FileSystemInfoEntry | null} c current entry + * @param {FileSystemInfoEntry | null} s entry from snapshot + * @param {boolean} log log reason + * @returns {boolean} true, if ok + */ + const checkFile = (path, c, s, log = true) => { + if (c === s) return true; + if (!checkExistence(path, Boolean(c), Boolean(s))) return false; + if (c) { + // For existing items only + if (typeof startTime === "number" && c.safeTime > startTime) { + // If a change happened after starting reading the item + // this may no longer be valid + if (log && this._remainingLogs > 0) { + this._log( + path, + "it may have changed (%d) after the start time of the snapshot (%d)", + c.safeTime, + startTime + ); + } + return false; + } + const snap = /** @type {FileSystemInfoEntry} */ (s); + if (snap.timestamp !== undefined && c.timestamp !== snap.timestamp) { + // If we have a timestamp (it was a file or symlink) and it differs from current timestamp + // it's invalid + if (log && this._remainingLogs > 0) { + this._log( + path, + "timestamps differ (%d != %d)", + c.timestamp, + snap.timestamp + ); + } + return false; + } + } + return true; + }; + /** + * Checks true, if ok. + * @param {string} path file path + * @param {ResolvedContextFileSystemInfoEntry | null} c current entry + * @param {ResolvedContextFileSystemInfoEntry | null} s entry from snapshot + * @param {boolean} log log reason + * @returns {boolean} true, if ok + */ + const checkContext = (path, c, s, log = true) => { + if (c === s) return true; + if (!checkExistence(path, Boolean(c), Boolean(s))) return false; + if (c) { + // For existing items only + if (typeof startTime === "number" && c.safeTime > startTime) { + // If a change happened after starting reading the item + // this may no longer be valid + if (log && this._remainingLogs > 0) { + this._log( + path, + "it may have changed (%d) after the start time of the snapshot (%d)", + c.safeTime, + startTime + ); + } + return false; + } + const snap = /** @type {ResolvedContextFileSystemInfoEntry} */ (s); + if ( + snap.timestampHash !== undefined && + c.timestampHash !== snap.timestampHash + ) { + // If we have a timestampHash (it was a directory) and it differs from current timestampHash + // it's invalid + if (log && this._remainingLogs > 0) { + this._log( + path, + "timestamps hashes differ (%s != %s)", + c.timestampHash, + snap.timestampHash + ); + } + return false; + } + } + return true; + }; + if (snapshot.hasChildren()) { + /** + * Processes the provided err. + * @param {(WebpackError | null)=} err err + * @param {boolean=} result result + * @returns {void} + */ + const childCallback = (err, result) => { + if (err || !result) return invalid(); + jobDone(); + }; + for (const child of /** @type {Children} */ (snapshot.children)) { + const cache = this._snapshotCache.get(child); + if (cache !== undefined) { + this._statTestedChildrenCached++; + /* istanbul ignore else */ + if (typeof cache === "boolean") { + if (cache === false) { + invalid(); + return; + } + } else { + jobs++; + cache.push(childCallback); + } + } else { + this._statTestedChildrenNotCached++; + jobs++; + this._checkSnapshotValidNoCache(child, childCallback); + } + } + } + if (snapshot.hasFileTimestamps()) { + const fileTimestamps = + /** @type {FileTimestamps} */ + (snapshot.fileTimestamps); + this._statTestedEntries += fileTimestamps.size; + for (const [path, ts] of fileTimestamps) { + const cache = this._fileTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + if ( + cache !== "ignore" && + !checkFile( + path, + /** @type {FileSystemInfoEntry | null} */ (cache), + ts + ) + ) { + invalid(); + return; + } + } else { + jobs++; + this.fileTimestampQueue.add(path, (err, entry) => { + if (err) return invalidWithError(path, err); + if ( + !checkFile( + path, + /** @type {FileSystemInfoEntry | null} */ (entry), + ts + ) + ) { + invalid(); + } else { + jobDone(); + } + }); + } + } + } + /** + * Process file hash snapshot. + * @param {string} path file path + * @param {string | null} hash hash + */ + const processFileHashSnapshot = (path, hash) => { + const cache = this._fileHashes.get(path); + if (cache !== undefined) { + if (cache !== "ignore" && !checkHash(path, cache, hash)) { + invalid(); + } + } else { + jobs++; + this.fileHashQueue.add(path, (err, entry) => { + if (err) return invalidWithError(path, err); + if (!checkHash(path, /** @type {string} */ (entry), hash)) { + invalid(); + } else { + jobDone(); + } + }); + } + }; + if (snapshot.hasFileHashes()) { + const fileHashes = /** @type {FileHashes} */ (snapshot.fileHashes); + this._statTestedEntries += fileHashes.size; + for (const [path, hash] of fileHashes) { + processFileHashSnapshot(path, hash); + } + } + if (snapshot.hasFileTshs()) { + const fileTshs = /** @type {FileTshs} */ (snapshot.fileTshs); + this._statTestedEntries += fileTshs.size; + for (const [path, tsh] of fileTshs) { + if (typeof tsh === "string") { + processFileHashSnapshot(path, tsh); + } else { + const cache = this._fileTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + if ( + cache === "ignore" || + !checkFile( + path, + /** @type {FileSystemInfoEntry | null} */ (cache), + tsh, + false + ) + ) { + processFileHashSnapshot(path, tsh && tsh.hash); + } + } else { + jobs++; + this.fileTimestampQueue.add(path, (err, entry) => { + if (err) return invalidWithError(path, err); + if ( + !checkFile( + path, + /** @type {FileSystemInfoEntry | null} */ + (entry), + tsh, + false + ) + ) { + processFileHashSnapshot(path, tsh && tsh.hash); + } + jobDone(); + }); + } + } + } + } + if (snapshot.hasContextTimestamps()) { + const contextTimestamps = + /** @type {ContextTimestamps} */ + (snapshot.contextTimestamps); + this._statTestedEntries += contextTimestamps.size; + for (const [path, ts] of contextTimestamps) { + const cache = this._contextTimestamps.get(path); + if (cache === "ignore") continue; + // Treat existence-only entries (`{}` from watchpack) as a cache + // miss — they carry no time info, so we cannot compare them to + // the snapshot. + /** @type {ContextFileSystemInfoEntry | null | undefined} */ + const usableCache = + cache === undefined || isExistenceOnly(cache) + ? undefined + : /** @type {ContextFileSystemInfoEntry | null} */ (cache); + // A non-null cache entry that lacks `timestampHash` while the + // snapshot has one cannot be used either; we re-read the + // directory through the disk-backed queue instead. + const cacheLacksHash = + usableCache !== undefined && + usableCache !== null && + usableCache.timestampHash === undefined && + ts !== null && + ts.timestampHash !== undefined; + /** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */ + let resolved; + if ( + usableCache !== undefined && + !cacheLacksHash && + (resolved = getResolvedTimestamp(usableCache)) !== undefined + ) { + if (!checkContext(path, resolved, ts)) { + invalid(); + return; + } + } else { + jobs++; + /** + * Processes the provided err. + * @param {(WebpackError | null)=} err error + * @param {ResolvedContextTimestamp=} entry entry + * @returns {void} + */ + const callback = (err, entry) => { + if (err) return invalidWithError(path, err); + if ( + !checkContext( + path, + /** @type {ResolvedContextFileSystemInfoEntry | null} */ + (entry), + ts + ) + ) { + invalid(); + } else { + jobDone(); + } + }; + if (cacheLacksHash) { + this._readFreshContextTimestamp(path, callback); + } else if (usableCache !== undefined && usableCache !== null) { + this._resolveContextTimestamp(usableCache, callback); + } else { + this.getContextTimestamp(path, callback); + } + } + } + } + /** + * Process context hash snapshot. + * @param {string} path path + * @param {string | null} hash hash + */ + const processContextHashSnapshot = (path, hash) => { + const cache = this._contextHashes.get(path); + /** @type {undefined | null | string} */ + let resolved; + if ( + cache !== undefined && + (resolved = getResolvedHash(cache)) !== undefined + ) { + if (!checkHash(path, resolved, hash)) { + invalid(); + } + } else { + jobs++; + /** + * Processes the provided err. + * @param {(WebpackError | null)=} err err + * @param {string=} entry entry + * @returns {void} + */ + const callback = (err, entry) => { + if (err) return invalidWithError(path, err); + if (!checkHash(path, /** @type {string} */ (entry), hash)) { + invalid(); + } else { + jobDone(); + } + }; + if (cache !== undefined) { + this._resolveContextHash(cache, callback); + } else { + this.getContextHash(path, callback); + } + } + }; + if (snapshot.hasContextHashes()) { + const contextHashes = + /** @type {ContextHashes} */ + (snapshot.contextHashes); + this._statTestedEntries += contextHashes.size; + for (const [path, hash] of contextHashes) { + processContextHashSnapshot(path, hash); + } + } + if (snapshot.hasContextTshs()) { + const contextTshs = /** @type {ContextTshs} */ (snapshot.contextTshs); + this._statTestedEntries += contextTshs.size; + for (const [path, tsh] of contextTshs) { + if (typeof tsh === "string") { + processContextHashSnapshot(path, tsh); + } else { + const cache = this._contextTimestamps.get(path); + if (cache === "ignore") continue; + // See the matching block in `hasContextTimestamps` above. + /** @type {ContextFileSystemInfoEntry | null | undefined} */ + const usableCache = + cache === undefined || isExistenceOnly(cache) + ? undefined + : /** @type {ContextFileSystemInfoEntry | null} */ (cache); + const cacheLacksHash = + usableCache !== undefined && + usableCache !== null && + usableCache.timestampHash === undefined && + tsh !== null && + tsh.timestampHash !== undefined; + /** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */ + let resolved; + if ( + usableCache !== undefined && + !cacheLacksHash && + (resolved = getResolvedTimestamp(usableCache)) !== undefined + ) { + if (!checkContext(path, resolved, tsh, false)) { + processContextHashSnapshot(path, tsh && tsh.hash); + } + } else { + jobs++; + /** + * Processes the provided err. + * @param {(WebpackError | null)=} err error + * @param {ResolvedContextTimestamp=} entry entry + * @returns {void} + */ + const callback = (err, entry) => { + if (err) return invalidWithError(path, err); + if ( + !checkContext( + path, + // TODO: test with `"ignore"` + /** @type {ResolvedContextFileSystemInfoEntry | null} */ + (entry), + tsh, + false + ) + ) { + processContextHashSnapshot(path, tsh && tsh.hash); + } + jobDone(); + }; + if (cacheLacksHash) { + this._readFreshContextTimestamp(path, callback); + } else if (usableCache !== undefined && usableCache !== null) { + this._resolveContextTimestamp(usableCache, callback); + } else { + this.getContextTimestamp(path, callback); + } + } + } + } + } + if (snapshot.hasMissingExistence()) { + const missingExistence = + /** @type {MissingExistence} */ + (snapshot.missingExistence); + this._statTestedEntries += missingExistence.size; + for (const [path, existence] of missingExistence) { + const cache = this._fileTimestamps.get(path); + if (cache !== undefined && !isExistenceOnly(cache)) { + if ( + cache !== "ignore" && + !checkExistence(path, Boolean(cache), Boolean(existence)) + ) { + invalid(); + return; + } + } else { + jobs++; + this.fileTimestampQueue.add(path, (err, entry) => { + if (err) return invalidWithError(path, err); + if (!checkExistence(path, Boolean(entry), Boolean(existence))) { + invalid(); + } else { + jobDone(); + } + }); + } + } + } + if (snapshot.hasManagedItemInfo()) { + const managedItemInfo = + /** @type {ManagedItemInfo} */ + (snapshot.managedItemInfo); + this._statTestedEntries += managedItemInfo.size; + for (const [path, info] of managedItemInfo) { + const cache = this._managedItems.get(path); + if (cache !== undefined) { + if (!checkHash(path, cache, info)) { + invalid(); + return; + } + } else { + jobs++; + this.managedItemQueue.add(path, (err, entry) => { + if (err) return invalidWithError(path, err); + if (!checkHash(path, /** @type {string} */ (entry), info)) { + invalid(); + } else { + jobDone(); + } + }); + } + } + } + jobDone(); + + // if there was an async action + // try to join multiple concurrent request for this snapshot + if (jobs > 0) { + const callbacks = [callback]; + callback = (err, result) => { + for (const callback of callbacks) callback(err, result); + }; + this._snapshotCache.set(snapshot, callbacks); + } + } + + /** + * @private + * @type {Processor} + */ + _readFileTimestamp(path, callback) { + this.fs.stat(path, (err, _stat) => { + if (err) { + if (err.code === "ENOENT") { + this._fileTimestamps.set(path, null); + this._cachedDeprecatedFileTimestamps = undefined; + return callback(null, null); + } + return callback(/** @type {WebpackError} */ (err)); + } + const stat = /** @type {IStats} */ (_stat); + /** @type {FileSystemInfoEntry} */ + let ts; + if (stat.isDirectory()) { + ts = { + safeTime: 0, + timestamp: undefined + }; + } else { + const mtime = Number(stat.mtime); + + if (mtime) applyMtime(mtime); + + ts = { + safeTime: mtime ? mtime + FS_ACCURACY : Infinity, + timestamp: mtime + }; + } + + this._fileTimestamps.set(path, ts); + this._cachedDeprecatedFileTimestamps = undefined; + + callback(null, ts); + }); + } + + /** + * @private + * @type {Processor} + */ + _readFileHash(path, callback) { + this.fs.readFile(path, (err, content) => { + if (err) { + if (err.code === "EISDIR") { + this._fileHashes.set(path, "directory"); + return callback(null, "directory"); + } + if (err.code === "ENOENT") { + this._fileHashes.set(path, null); + return callback(null, null); + } + if (err.code === "ERR_FS_FILE_TOO_LARGE") { + /** @type {Logger} */ + (this.logger).warn(`Ignoring ${path} for hashing as it's very large`); + this._fileHashes.set(path, "too large"); + return callback(null, "too large"); + } + return callback(/** @type {WebpackError} */ (err)); + } + + const hash = createHash(this._hashFunction); + + hash.update(/** @type {string | Buffer} */ (content)); + + const digest = hash.digest("hex"); + + this._fileHashes.set(path, digest); + + callback(null, digest); + }); + } + + /** + * Get file timestamp and hash. + * @private + * @param {string} path path + * @param {(err: WebpackError | null, timestampAndHash?: TimestampAndHash | string) => void} callback callback + */ + _getFileTimestampAndHash(path, callback) { + /** + * Continue with hash. + * @param {string} hash hash + * @returns {void} + */ + const continueWithHash = (hash) => { + const cache = this._fileTimestamps.get(path); + if (cache !== undefined) { + if (cache !== "ignore") { + /** @type {TimestampAndHash} */ + const result = { + .../** @type {FileSystemInfoEntry} */ (cache), + hash + }; + this._fileTshs.set(path, result); + return callback(null, result); + } + this._fileTshs.set(path, hash); + return callback(null, hash); + } + this.fileTimestampQueue.add(path, (err, entry) => { + if (err) { + return callback(err); + } + /** @type {TimestampAndHash} */ + const result = { + .../** @type {FileSystemInfoEntry} */ (entry), + hash + }; + this._fileTshs.set(path, result); + return callback(null, result); + }); + }; + + const cache = this._fileHashes.get(path); + if (cache !== undefined) { + continueWithHash(/** @type {string} */ (cache)); + } else { + this.fileHashQueue.add(path, (err, entry) => { + if (err) { + return callback(err); + } + continueWithHash(/** @type {string} */ (entry)); + }); + } + } + + /** + * Processes the provided object. + * @private + * @template T + * @template ItemType + * @param {object} options options + * @param {string} options.path path + * @param {(value: string) => ItemType} options.fromImmutablePath called when context item is an immutable path + * @param {(value: string) => ItemType} options.fromManagedItem called when context item is a managed path + * @param {(value: string, result: string, callback: (err?: WebpackError | null, itemType?: ItemType) => void) => void} options.fromSymlink called when context item is a symlink + * @param {(value: string, stats: IStats, callback: (err?: WebpackError | null, itemType?: ItemType | null) => void) => void} options.fromFile called when context item is a file + * @param {(value: string, stats: IStats, callback: (err?: WebpackError | null, itemType?: ItemType) => void) => void} options.fromDirectory called when context item is a directory + * @param {(arr: string[], arr1: ItemType[]) => T} options.reduce called from all context items + * @param {(err?: Error | null, result?: T | null) => void} callback callback + */ + _readContext( + { + path, + fromImmutablePath, + fromManagedItem, + fromSymlink, + fromFile, + fromDirectory, + reduce + }, + callback + ) { + this.fs.readdir(path, (err, _files) => { + if (err) { + if (err.code === "ENOENT") { + return callback(null, null); + } + return callback(err); + } + const files = /** @type {string[]} */ (_files) + .map((file) => file.normalize("NFC")) + .filter((file) => !/^\./.test(file)) + .sort(); + asyncLib.map( + files, + (file, callback) => { + const child = join(this.fs, path, file); + for (const immutablePath of this.immutablePathsRegExps) { + if (immutablePath.test(path)) { + // ignore any immutable path for timestamping + return callback(null, fromImmutablePath(path)); + } + } + for (const immutablePath of this.immutablePathsWithSlash) { + if (path.startsWith(immutablePath)) { + // ignore any immutable path for timestamping + return callback(null, fromImmutablePath(path)); + } + } + for (const managedPath of this.managedPathsRegExps) { + const match = managedPath.exec(path); + if (match) { + const managedItem = getManagedItem(match[1], path); + if (managedItem) { + // construct timestampHash from managed info + return this.managedItemQueue.add(managedItem, (err, info) => { + if (err) return callback(err); + return callback( + null, + fromManagedItem(/** @type {string} */ (info)) + ); + }); + } + } + } + for (const managedPath of this.managedPathsWithSlash) { + if (path.startsWith(managedPath)) { + const managedItem = getManagedItem(managedPath, child); + if (managedItem) { + // construct timestampHash from managed info + return this.managedItemQueue.add(managedItem, (err, info) => { + if (err) return callback(err); + return callback( + null, + fromManagedItem(/** @type {string} */ (info)) + ); + }); + } + } + } + + lstatReadlinkAbsolute(this.fs, child, (err, _stat) => { + if (err) return callback(err); + + const stat = /** @type {IStats | string} */ (_stat); + + if (typeof stat === "string") { + return fromSymlink(child, stat, callback); + } + + if (stat.isFile()) { + return fromFile(child, stat, callback); + } + if (stat.isDirectory()) { + return fromDirectory(child, stat, callback); + } + callback(null, null); + }); + }, + (err, results) => { + if (err) return callback(err); + const result = reduce(files, /** @type {ItemType[]} */ (results)); + callback(null, result); + } + ); + }); + } + + /** + * @private + * @type {Processor} + */ + _readContextTimestamp(path, callback) { + this._readContext( + { + path, + fromImmutablePath: () => + /** @type {ContextFileSystemInfoEntry | FileSystemInfoEntry | "ignore" | null} */ + (null), + fromManagedItem: (info) => ({ + safeTime: 0, + timestampHash: info + }), + fromSymlink: (file, target, callback) => { + callback( + null, + /** @type {ContextFileSystemInfoEntry} */ + ({ + timestampHash: target, + symlinks: new Set([target]) + }) + ); + }, + fromFile: (file, stat, callback) => { + // Prefer the cached value over our new stat to report consistent results + const cache = this._fileTimestamps.get(file); + if (cache !== undefined && !isExistenceOnly(cache)) { + return callback( + null, + cache === "ignore" + ? null + : /** @type {FileSystemInfoEntry | null} */ (cache) + ); + } + + const mtime = Number(stat.mtime); + + if (mtime) applyMtime(mtime); + + /** @type {FileSystemInfoEntry} */ + const ts = { + safeTime: mtime ? mtime + FS_ACCURACY : Infinity, + timestamp: mtime + }; + + this._fileTimestamps.set(file, ts); + this._cachedDeprecatedFileTimestamps = undefined; + callback(null, ts); + }, + fromDirectory: (directory, stat, callback) => { + this.contextTimestampQueue.increaseParallelism(); + this._getUnresolvedContextTimestamp(directory, (err, tsEntry) => { + this.contextTimestampQueue.decreaseParallelism(); + callback(err, tsEntry); + }); + }, + reduce: (files, tsEntries) => { + /** @type {undefined | Symlinks} */ + let symlinks; + + const hash = createHash(this._hashFunction); + + for (const file of files) hash.update(file); + let safeTime = 0; + for (const _e of tsEntries) { + if (!_e) { + hash.update("n"); + continue; + } + const entry = + /** @type {FileSystemInfoEntry | ContextFileSystemInfoEntry} */ + (_e); + if (/** @type {FileSystemInfoEntry} */ (entry).timestamp) { + hash.update("f"); + hash.update( + `${/** @type {FileSystemInfoEntry} */ (entry).timestamp}` + ); + } else if ( + /** @type {ContextFileSystemInfoEntry} */ (entry).timestampHash + ) { + hash.update("d"); + hash.update( + `${/** @type {ContextFileSystemInfoEntry} */ (entry).timestampHash}` + ); + } + if ( + /** @type {ContextFileSystemInfoEntry} */ + (entry).symlinks !== undefined + ) { + if (symlinks === undefined) symlinks = new Set(); + addAll( + /** @type {ContextFileSystemInfoEntry} */ (entry).symlinks, + symlinks + ); + } + if (entry.safeTime) { + safeTime = Math.max(safeTime, entry.safeTime); + } + } + + const digest = hash.digest("hex"); + /** @type {ContextFileSystemInfoEntry} */ + const result = { + safeTime, + timestampHash: digest + }; + if (symlinks) result.symlinks = symlinks; + return result; + } + }, + (err, result) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + this._contextTimestamps.set(path, result); + this._cachedDeprecatedContextTimestamps = undefined; + + callback(null, result); + } + ); + } + + /** + * Resolve context timestamp. + * @private + * @param {ContextFileSystemInfoEntry} entry entry + * @param {(err?: WebpackError | null, resolvedContextTimestamp?: ResolvedContextTimestamp) => void} callback callback + * @returns {void} + */ + _resolveContextTimestamp(entry, callback) { + /** @type {string[]} */ + const hashes = []; + let safeTime = 0; + processAsyncTree( + /** @type {NonNullable} */ (entry.symlinks), + 10, + (target, push, callback) => { + this._getUnresolvedContextTimestamp(target, (err, entry) => { + if (err) return callback(err); + if (entry && entry !== "ignore") { + hashes.push(/** @type {string} */ (entry.timestampHash)); + if (entry.safeTime) { + safeTime = Math.max(safeTime, entry.safeTime); + } + if (entry.symlinks !== undefined) { + for (const target of entry.symlinks) push(target); + } + } + callback(); + }); + }, + (err) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + const hash = createHash(this._hashFunction); + hash.update(/** @type {string} */ (entry.timestampHash)); + if (entry.safeTime) { + safeTime = Math.max(safeTime, entry.safeTime); + } + hashes.sort(); + for (const h of hashes) { + hash.update(h); + } + callback( + null, + (entry.resolved = { + safeTime, + timestampHash: hash.digest("hex") + }) + ); + } + ); + } + + /** + * @private + * @type {Processor} + */ + _readContextHash(path, callback) { + this._readContext( + { + path, + fromImmutablePath: () => /** @type {ContextHash | ""} */ (""), + fromManagedItem: (info) => info || "", + fromSymlink: (file, target, callback) => { + callback( + null, + /** @type {ContextHash} */ + ({ + hash: target, + symlinks: new Set([target]) + }) + ); + }, + fromFile: (file, stat, callback) => + this.getFileHash(file, (err, hash) => { + callback(err, hash || ""); + }), + fromDirectory: (directory, stat, callback) => { + this.contextHashQueue.increaseParallelism(); + this._getUnresolvedContextHash(directory, (err, hash) => { + this.contextHashQueue.decreaseParallelism(); + callback(err, hash || ""); + }); + }, + /** + * Returns reduced hash. + * @param {string[]} files files + * @param {(string | ContextHash)[]} fileHashes hashes + * @returns {ContextHash} reduced hash + */ + reduce: (files, fileHashes) => { + /** @type {undefined | Symlinks} */ + let symlinks; + const hash = createHash(this._hashFunction); + + for (const file of files) hash.update(file); + for (const entry of fileHashes) { + if (typeof entry === "string") { + hash.update(entry); + } else { + hash.update(entry.hash); + if (entry.symlinks) { + if (symlinks === undefined) symlinks = new Set(); + addAll(entry.symlinks, symlinks); + } + } + } + + /** @type {ContextHash} */ + const result = { + hash: hash.digest("hex") + }; + if (symlinks) result.symlinks = symlinks; + return result; + } + }, + (err, _result) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + const result = /** @type {ContextHash} */ (_result); + this._contextHashes.set(path, result); + return callback(null, result); + } + ); + } + + /** + * Resolve context hash. + * @private + * @param {ContextHash} entry context hash + * @param {(err: WebpackError | null, contextHash?: string) => void} callback callback + * @returns {void} + */ + _resolveContextHash(entry, callback) { + /** @type {string[]} */ + const hashes = []; + processAsyncTree( + /** @type {NonNullable} */ (entry.symlinks), + 10, + (target, push, callback) => { + this._getUnresolvedContextHash(target, (err, hash) => { + if (err) return callback(err); + if (hash) { + hashes.push(hash.hash); + if (hash.symlinks !== undefined) { + for (const target of hash.symlinks) push(target); + } + } + callback(); + }); + }, + (err) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + const hash = createHash(this._hashFunction); + hash.update(entry.hash); + hashes.sort(); + for (const h of hashes) { + hash.update(h); + } + callback(null, (entry.resolved = hash.digest("hex"))); + } + ); + } + + /** + * @private + * @type {Processor} + */ + _readContextTimestampAndHash(path, callback) { + /** + * Processes the provided timestamp. + * @param {ContextTimestamp} timestamp timestamp + * @param {ContextHash} hash hash + */ + const finalize = (timestamp, hash) => { + const result = + /** @type {ContextTimestampAndHash} */ + (timestamp === "ignore" ? hash : { ...timestamp, ...hash }); + this._contextTshs.set(path, result); + callback(null, result); + }; + const cachedHash = this._contextHashes.get(path); + const cachedTimestamp = this._contextTimestamps.get(path); + if (cachedHash !== undefined) { + if (cachedTimestamp !== undefined) { + finalize(cachedTimestamp, cachedHash); + } else { + this.contextTimestampQueue.add(path, (err, entry) => { + if (err) return callback(err); + finalize( + /** @type {ContextFileSystemInfoEntry} */ + (entry), + cachedHash + ); + }); + } + } else if (cachedTimestamp !== undefined) { + this.contextHashQueue.add(path, (err, entry) => { + if (err) return callback(err); + finalize(cachedTimestamp, /** @type {ContextHash} */ (entry)); + }); + } else { + this._readContext( + { + path, + fromImmutablePath: () => + /** @type {ContextTimestampAndHash | Omit | string | null} */ ( + null + ), + fromManagedItem: (info) => ({ + safeTime: 0, + timestampHash: info, + hash: info || "" + }), + fromSymlink: (file, target, callback) => { + callback(null, { + timestampHash: target, + hash: target, + symlinks: new Set([target]) + }); + }, + fromFile: (file, stat, callback) => { + this._getFileTimestampAndHash(file, callback); + }, + fromDirectory: (directory, stat, callback) => { + this.contextTshQueue.increaseParallelism(); + this.contextTshQueue.add(directory, (err, result) => { + this.contextTshQueue.decreaseParallelism(); + callback(err, result); + }); + }, + /** + * Returns tsh. + * @param {string[]} files files + * @param {(Partial & Partial | string | null)[]} results results + * @returns {ContextTimestampAndHash} tsh + */ + reduce: (files, results) => { + /** @type {undefined | Symlinks} */ + let symlinks; + + const tsHash = createHash(this._hashFunction); + const hash = createHash(this._hashFunction); + + for (const file of files) { + tsHash.update(file); + hash.update(file); + } + let safeTime = 0; + for (const entry of results) { + if (!entry) { + tsHash.update("n"); + continue; + } + if (typeof entry === "string") { + tsHash.update("n"); + hash.update(entry); + continue; + } + if (entry.timestamp) { + tsHash.update("f"); + tsHash.update(`${entry.timestamp}`); + } else if (entry.timestampHash) { + tsHash.update("d"); + tsHash.update(`${entry.timestampHash}`); + } + if (entry.symlinks !== undefined) { + if (symlinks === undefined) symlinks = new Set(); + addAll(entry.symlinks, symlinks); + } + if (entry.safeTime) { + safeTime = Math.max(safeTime, entry.safeTime); + } + hash.update(/** @type {string} */ (entry.hash)); + } + + /** @type {ContextTimestampAndHash} */ + const result = { + safeTime, + timestampHash: tsHash.digest("hex"), + hash: hash.digest("hex") + }; + if (symlinks) result.symlinks = symlinks; + return result; + } + }, + (err, _result) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + const result = /** @type {ContextTimestampAndHash} */ (_result); + this._contextTshs.set(path, result); + return callback(null, result); + } + ); + } + } + + /** + * Resolve context tsh. + * @private + * @param {ContextTimestampAndHash} entry entry + * @param {ProcessorCallback} callback callback + * @returns {void} + */ + _resolveContextTsh(entry, callback) { + /** @type {string[]} */ + const hashes = []; + /** @type {string[]} */ + const tsHashes = []; + let safeTime = 0; + processAsyncTree( + /** @type {NonNullable} */ (entry.symlinks), + 10, + (target, push, callback) => { + this._getUnresolvedContextTsh(target, (err, entry) => { + if (err) return callback(err); + if (entry) { + hashes.push(entry.hash); + if (entry.timestampHash) tsHashes.push(entry.timestampHash); + if (entry.safeTime) { + safeTime = Math.max(safeTime, entry.safeTime); + } + if (entry.symlinks !== undefined) { + for (const target of entry.symlinks) push(target); + } + } + callback(); + }); + }, + (err) => { + if (err) return callback(/** @type {WebpackError} */ (err)); + const hash = createHash(this._hashFunction); + const tsHash = createHash(this._hashFunction); + hash.update(entry.hash); + if (entry.timestampHash) tsHash.update(entry.timestampHash); + if (entry.safeTime) { + safeTime = Math.max(safeTime, entry.safeTime); + } + hashes.sort(); + for (const h of hashes) { + hash.update(h); + } + tsHashes.sort(); + for (const h of tsHashes) { + tsHash.update(h); + } + callback( + null, + (entry.resolved = { + safeTime, + timestampHash: tsHash.digest("hex"), + hash: hash.digest("hex") + }) + ); + } + ); + } + + /** + * @private + * @type {Processor>} + */ + _getManagedItemDirectoryInfo(path, callback) { + this.fs.readdir(path, (err, elements) => { + if (err) { + if (err.code === "ENOENT" || err.code === "ENOTDIR") { + return callback(null, EMPTY_SET); + } + return callback(/** @type {WebpackError} */ (err)); + } + const set = new Set( + /** @type {string[]} */ + (elements).map((element) => join(this.fs, path, element)) + ); + callback(null, set); + }); + } + + /** + * @private + * @type {Processor} + */ + _getManagedItemInfo(path, callback) { + const dir = dirname(this.fs, path); + this.managedItemDirectoryQueue.add(dir, (err, elements) => { + if (err) { + return callback(err); + } + if (!(/** @type {Set} */ (elements).has(path))) { + // file or directory doesn't exist + this._managedItems.set(path, "*missing"); + return callback(null, "*missing"); + } + // something exists + // it may be a file or directory + if ( + path.endsWith("node_modules") && + (path.endsWith("/node_modules") || path.endsWith("\\node_modules")) + ) { + // we are only interested in existence of this special directory + this._managedItems.set(path, "*node_modules"); + return callback(null, "*node_modules"); + } + + // we assume it's a directory, as files shouldn't occur in managed paths + const packageJsonPath = join(this.fs, path, "package.json"); + this.fs.readFile(packageJsonPath, (err, content) => { + if (err) { + if (err.code === "ENOENT" || err.code === "ENOTDIR") { + // no package.json or path is not a directory + this.fs.readdir(path, (err, elements) => { + if ( + !err && + /** @type {string[]} */ (elements).length === 1 && + /** @type {string[]} */ (elements)[0] === "node_modules" + ) { + // This is only a grouping folder e.g. used by yarn + // we are only interested in existence of this special directory + this._managedItems.set(path, "*nested"); + return callback(null, "*nested"); + } + /** @type {Logger} */ + (this.logger).warn( + `Managed item ${path} isn't a directory or doesn't contain a package.json (see snapshot.managedPaths option)` + ); + return callback(); + }); + return; + } + return callback(/** @type {WebpackError} */ (err)); + } + /** @type {JsonObject} */ + let data; + try { + data = JSON.parse(/** @type {Buffer} */ (content).toString("utf8")); + } catch (parseErr) { + return callback(/** @type {WebpackError} */ (parseErr)); + } + if (!data.name) { + /** @type {Logger} */ + (this.logger).warn( + `${packageJsonPath} doesn't contain a "name" property (see snapshot.managedPaths option)` + ); + return callback(); + } + const info = `${data.name || ""}@${data.version || ""}`; + this._managedItems.set(path, info); + callback(null, info); + }); + }); + } + + getDeprecatedFileTimestamps() { + if (this._cachedDeprecatedFileTimestamps !== undefined) { + return this._cachedDeprecatedFileTimestamps; + } + /** @type {Map} */ + const map = new Map(); + for (const [path, info] of this._fileTimestamps) { + if (info) { + const safeTime = + typeof info === "object" + ? /** @type {Partial} */ (info).safeTime + : undefined; + map.set(path, safeTime === undefined ? null : safeTime); + } + } + return (this._cachedDeprecatedFileTimestamps = map); + } + + getDeprecatedContextTimestamps() { + if (this._cachedDeprecatedContextTimestamps !== undefined) { + return this._cachedDeprecatedContextTimestamps; + } + /** @type {Map} */ + const map = new Map(); + for (const [path, info] of this._contextTimestamps) { + if (info) { + const safeTime = + typeof info === "object" + ? /** @type {Partial} */ (info).safeTime + : undefined; + map.set(path, safeTime === undefined ? null : safeTime); + } + } + return (this._cachedDeprecatedContextTimestamps = map); + } +} + +module.exports = FileSystemInfo; +module.exports.Snapshot = Snapshot; Index: frontend/node_modules/webpack/lib/FlagAllModulesAsUsedPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/FlagAllModulesAsUsedPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/FlagAllModulesAsUsedPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,56 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Module").FactoryMeta} FactoryMeta */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +const PLUGIN_NAME = "FlagAllModulesAsUsedPlugin"; +class FlagAllModulesAsUsedPlugin { + /** + * Creates an instance of FlagAllModulesAsUsedPlugin. + * @param {string} explanation explanation + */ + constructor(explanation) { + this.explanation = explanation; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const moduleGraph = compilation.moduleGraph; + compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => { + /** @type {RuntimeSpec} */ + let runtime; + for (const [name, { options }] of compilation.entries) { + runtime = mergeRuntimeOwned( + runtime, + getEntryRuntime(compilation, name, options) + ); + } + for (const module of modules) { + const exportsInfo = moduleGraph.getExportsInfo(module); + exportsInfo.setUsedInUnknownWay(runtime); + moduleGraph.addExtraReason(module, this.explanation); + if (module.factoryMeta === undefined) { + module.factoryMeta = {}; + } + /** @type {FactoryMeta} */ + (module.factoryMeta).sideEffectFree = false; + } + }); + }); + } +} + +module.exports = FlagAllModulesAsUsedPlugin; Index: frontend/node_modules/webpack/lib/FlagDependencyExportsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/FlagDependencyExportsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/FlagDependencyExportsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,440 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const asyncLib = require("neo-async"); +const Queue = require("./util/Queue"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./DependenciesBlock")} DependenciesBlock */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").ExportSpec} ExportSpec */ +/** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */ +/** @typedef {import("./ExportsInfo")} ExportsInfo */ +/** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */ +/** @typedef {import("./ExportsInfo").RestoreProvidedData} RestoreProvidedData */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ + +const PLUGIN_NAME = "FlagDependencyExportsPlugin"; +const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`; + +class FlagDependencyExportsPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const moduleGraph = compilation.moduleGraph; + const cache = compilation.getCache(PLUGIN_NAME); + compilation.hooks.finishModules.tapAsync( + PLUGIN_NAME, + (modules, callback) => { + const logger = compilation.getLogger(PLUGIN_LOGGER_NAME); + let statRestoredFromMemCache = 0; + let statRestoredFromCache = 0; + let statNoExports = 0; + let statFlaggedUncached = 0; + let statNotCached = 0; + let statQueueItemsProcessed = 0; + + const { moduleMemCaches } = compilation; + + /** @type {Queue} */ + const queue = new Queue(); + + // Step 1: Try to restore cached provided export info from cache + logger.time("restore cached provided exports"); + asyncLib.each( + /** @type {import("neo-async").IterableCollection} */ ( + /** @type {unknown} */ (modules) + ), + (module, callback) => { + const exportsInfo = moduleGraph.getExportsInfo(module); + // If the module doesn't have an exportsType, it's a module + // without declared exports. + if ( + (!module.buildMeta || !module.buildMeta.exportsType) && + exportsInfo.otherExportsInfo.provided !== null + ) { + // It's a module without declared exports + statNoExports++; + exportsInfo.setHasProvideInfo(); + exportsInfo.setUnknownExportsProvided(); + return callback(); + } + // If the module has no hash, it's uncacheable + if ( + typeof (/** @type {BuildInfo} */ (module.buildInfo).hash) !== + "string" + ) { + statFlaggedUncached++; + // Enqueue uncacheable module for determining the exports + queue.enqueue(module); + exportsInfo.setHasProvideInfo(); + return callback(); + } + const memCache = moduleMemCaches && moduleMemCaches.get(module); + const memCacheValue = memCache && memCache.get(this); + if (memCacheValue !== undefined) { + statRestoredFromMemCache++; + exportsInfo.restoreProvided(memCacheValue); + return callback(); + } + cache.get( + module.identifier(), + /** @type {BuildInfo} */ + (module.buildInfo).hash, + (err, result) => { + if (err) return callback(err); + + if (result !== undefined) { + statRestoredFromCache++; + exportsInfo.restoreProvided(result); + } else { + statNotCached++; + // Without cached info enqueue module for determining the exports + queue.enqueue(module); + exportsInfo.setHasProvideInfo(); + } + callback(); + } + ); + }, + (err) => { + logger.timeEnd("restore cached provided exports"); + if (err) return callback(err); + + /** @type {Set} */ + const modulesToStore = new Set(); + + /** @type {Map>} */ + const dependencies = new Map(); + + /** @type {Module} */ + let module; + + /** @type {ExportsInfo} */ + let exportsInfo; + + /** @type {Map} */ + const exportsSpecsFromDependencies = new Map(); + + let cacheable = true; + let changed = false; + + /** + * Process dependencies block. + * @param {DependenciesBlock} depBlock the dependencies block + * @returns {void} + */ + const processDependenciesBlock = (depBlock) => { + for (const dep of depBlock.dependencies) { + processDependency(dep); + } + for (const block of depBlock.blocks) { + processDependenciesBlock(block); + } + }; + + /** + * Process dependency. + * @param {Dependency} dep the dependency + * @returns {void} + */ + const processDependency = (dep) => { + const exportDesc = dep.getExports(moduleGraph); + if (!exportDesc) return; + exportsSpecsFromDependencies.set(dep, exportDesc); + }; + + /** + * Process exports spec. + * @param {Dependency} dep dependency + * @param {ExportsSpec} exportDesc info + * @returns {void} + */ + const processExportsSpec = (dep, exportDesc) => { + const exports = exportDesc.exports; + const globalCanMangle = exportDesc.canMangle; + const globalFrom = exportDesc.from; + const globalPriority = exportDesc.priority; + const globalTerminalBinding = + exportDesc.terminalBinding || false; + const exportDeps = exportDesc.dependencies; + if (exportDesc.hideExports) { + for (const name of exportDesc.hideExports) { + const exportInfo = exportsInfo.getExportInfo(name); + exportInfo.unsetTarget(dep); + } + } + if (exports === true) { + // unknown exports + if ( + exportsInfo.setUnknownExportsProvided( + globalCanMangle, + exportDesc.excludeExports, + globalFrom && dep, + globalFrom, + globalPriority + ) + ) { + changed = true; + } + } else if (Array.isArray(exports)) { + /** + * merge in new exports + * @param {ExportsInfo} exportsInfo own exports info + * @param {(ExportSpec | string)[]} exports list of exports + */ + const mergeExports = (exportsInfo, exports) => { + for (const exportNameOrSpec of exports) { + /** @type {ExportInfoName} */ + let name; + let canMangle = globalCanMangle; + let terminalBinding = globalTerminalBinding; + /** @type {ExportSpec["exports"]} */ + let exports; + let from = globalFrom; + /** @type {ExportSpec["export"]} */ + let fromExport; + let priority = globalPriority; + let hidden = false; + if (typeof exportNameOrSpec === "string") { + name = exportNameOrSpec; + } else { + name = exportNameOrSpec.name; + if (exportNameOrSpec.canMangle !== undefined) { + canMangle = exportNameOrSpec.canMangle; + } + if (exportNameOrSpec.export !== undefined) { + fromExport = exportNameOrSpec.export; + } + if (exportNameOrSpec.exports !== undefined) { + exports = exportNameOrSpec.exports; + } + if (exportNameOrSpec.from !== undefined) { + from = exportNameOrSpec.from; + } + if (exportNameOrSpec.priority !== undefined) { + priority = exportNameOrSpec.priority; + } + if (exportNameOrSpec.terminalBinding !== undefined) { + terminalBinding = exportNameOrSpec.terminalBinding; + } + if (exportNameOrSpec.hidden !== undefined) { + hidden = exportNameOrSpec.hidden; + } + } + const exportInfo = exportsInfo.getExportInfo(name); + + if ( + exportInfo.provided === false || + exportInfo.provided === null + ) { + exportInfo.provided = true; + changed = true; + } + + if ( + exportInfo.canMangleProvide !== false && + canMangle === false + ) { + exportInfo.canMangleProvide = false; + changed = true; + } + + if (terminalBinding && !exportInfo.terminalBinding) { + exportInfo.terminalBinding = true; + changed = true; + } + + if (exports) { + const nestedExportsInfo = + exportInfo.createNestedExportsInfo(); + mergeExports( + /** @type {ExportsInfo} */ (nestedExportsInfo), + exports + ); + } + + if ( + from && + (hidden + ? exportInfo.unsetTarget(dep) + : exportInfo.setTarget( + dep, + from, + fromExport === undefined ? [name] : fromExport, + priority + )) + ) { + changed = true; + } + + // Recalculate target exportsInfo + const target = exportInfo.getTarget(moduleGraph); + /** @type {undefined | ExportsInfo} */ + let targetExportsInfo; + if (target) { + const targetModuleExportsInfo = + moduleGraph.getExportsInfo(target.module); + targetExportsInfo = + targetModuleExportsInfo.getNestedExportsInfo( + target.export + ); + // add dependency for this module + const set = dependencies.get(target.module); + if (set === undefined) { + dependencies.set(target.module, new Set([module])); + } else { + set.add(module); + } + } + + if (exportInfo.exportsInfoOwned) { + if ( + /** @type {ExportsInfo} */ + (exportInfo.exportsInfo).setRedirectNamedTo( + targetExportsInfo + ) + ) { + changed = true; + } + } else if (exportInfo.exportsInfo !== targetExportsInfo) { + exportInfo.exportsInfo = targetExportsInfo; + changed = true; + } + } + }; + mergeExports(exportsInfo, exports); + } + // store dependencies + if (exportDeps) { + cacheable = false; + for (const exportDependency of exportDeps) { + // add dependency for this module + const set = dependencies.get(exportDependency); + if (set === undefined) { + dependencies.set(exportDependency, new Set([module])); + } else { + set.add(module); + } + } + } + }; + + const notifyDependencies = () => { + const deps = dependencies.get(module); + if (deps !== undefined) { + for (const dep of deps) { + queue.enqueue(dep); + } + } + }; + + logger.time("figure out provided exports"); + while (queue.length > 0) { + module = /** @type {Module} */ (queue.dequeue()); + + statQueueItemsProcessed++; + + exportsInfo = moduleGraph.getExportsInfo(module); + + cacheable = true; + changed = false; + + exportsSpecsFromDependencies.clear(); + moduleGraph.freeze(); + processDependenciesBlock(module); + moduleGraph.unfreeze(); + for (const [dep, exportsSpec] of exportsSpecsFromDependencies) { + processExportsSpec(dep, exportsSpec); + } + + if (cacheable) { + modulesToStore.add(module); + } + + if (changed) { + notifyDependencies(); + } + } + logger.timeEnd("figure out provided exports"); + + logger.log( + `${Math.round( + (100 * (statFlaggedUncached + statNotCached)) / + (statRestoredFromMemCache + + statRestoredFromCache + + statNotCached + + statFlaggedUncached + + statNoExports) + )}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${ + statQueueItemsProcessed - statNotCached - statFlaggedUncached + } additional calculations due to dependencies)` + ); + + logger.time("store provided exports into cache"); + asyncLib.each( + modulesToStore, + (module, callback) => { + if ( + typeof ( + /** @type {BuildInfo} */ + (module.buildInfo).hash + ) !== "string" + ) { + // not cacheable + return callback(); + } + const cachedData = moduleGraph + .getExportsInfo(module) + .getRestoreProvidedData(); + const memCache = + moduleMemCaches && moduleMemCaches.get(module); + if (memCache) { + memCache.set(this, cachedData); + } + cache.store( + module.identifier(), + /** @type {BuildInfo} */ + (module.buildInfo).hash, + cachedData, + callback + ); + }, + (err) => { + logger.timeEnd("store provided exports into cache"); + callback(err); + } + ); + } + ); + } + ); + + /** @type {WeakMap} */ + const providedExportsCache = new WeakMap(); + compilation.hooks.rebuildModule.tap(PLUGIN_NAME, (module) => { + providedExportsCache.set( + module, + moduleGraph.getExportsInfo(module).getRestoreProvidedData() + ); + }); + compilation.hooks.finishRebuildingModule.tap(PLUGIN_NAME, (module) => { + moduleGraph.getExportsInfo(module).restoreProvided( + /** @type {RestoreProvidedData} */ + (providedExportsCache.get(module)) + ); + }); + }); + } +} + +module.exports = FlagDependencyExportsPlugin; Index: frontend/node_modules/webpack/lib/FlagDependencyUsagePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/FlagDependencyUsagePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/FlagDependencyUsagePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,352 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Dependency = require("./Dependency"); +const { UsageState } = require("./ExportsInfo"); +const ModuleGraphConnection = require("./ModuleGraphConnection"); +const { STAGE_DEFAULT } = require("./OptimizationStages"); +const ArrayQueue = require("./util/ArrayQueue"); +const TupleQueue = require("./util/TupleQueue"); +const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./DependenciesBlock")} DependenciesBlock */ +/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */ +/** @typedef {import("./Dependency").ReferencedExports} ReferencedExports */ +/** @typedef {import("./ExportsInfo")} ExportsInfo */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency; + +const PLUGIN_NAME = "FlagDependencyUsagePlugin"; +const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`; + +class FlagDependencyUsagePlugin { + /** + * Creates an instance of FlagDependencyUsagePlugin. + * @param {boolean} global do a global analysis instead of per runtime + */ + constructor(global) { + /** @type {boolean} */ + this.global = global; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const moduleGraph = compilation.moduleGraph; + compilation.hooks.optimizeDependencies.tap( + { name: PLUGIN_NAME, stage: STAGE_DEFAULT }, + (modules) => { + if (compilation.moduleMemCaches) { + throw new Error( + "optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect" + ); + } + + const logger = compilation.getLogger(PLUGIN_LOGGER_NAME); + /** @type {Map} */ + const exportInfoToModuleMap = new Map(); + + /** @type {TupleQueue} */ + const queue = new TupleQueue(); + + /** + * Process referenced module. + * @param {Module} module module to process + * @param {ReferencedExports} usedExports list of used exports + * @param {RuntimeSpec} runtime part of which runtime + * @param {boolean} forceSideEffects always apply side effects + * @returns {void} + */ + const processReferencedModule = ( + module, + usedExports, + runtime, + forceSideEffects + ) => { + const exportsInfo = moduleGraph.getExportsInfo(module); + if (usedExports.length > 0) { + if (!module.buildMeta || !module.buildMeta.exportsType) { + if (exportsInfo.setUsedWithoutInfo(runtime)) { + queue.enqueue(module, runtime); + } + return; + } + for (const usedExportInfo of usedExports) { + /** @type {string[]} */ + let usedExport; + let canMangle = true; + if (Array.isArray(usedExportInfo)) { + usedExport = usedExportInfo; + } else { + usedExport = usedExportInfo.name; + canMangle = usedExportInfo.canMangle !== false; + } + if (usedExport.length === 0) { + if (exportsInfo.setUsedInUnknownWay(runtime)) { + queue.enqueue(module, runtime); + } + } else { + let currentExportsInfo = exportsInfo; + for (let i = 0; i < usedExport.length; i++) { + const exportInfo = currentExportsInfo.getExportInfo( + usedExport[i] + ); + if (canMangle === false) { + exportInfo.canMangleUse = false; + } + const lastOne = i === usedExport.length - 1; + if (!lastOne) { + const nestedInfo = exportInfo.getNestedExportsInfo(); + if (nestedInfo) { + if ( + exportInfo.setUsedConditionally( + (used) => used === UsageState.Unused, + UsageState.OnlyPropertiesUsed, + runtime + ) + ) { + const currentModule = + currentExportsInfo === exportsInfo + ? module + : exportInfoToModuleMap.get(currentExportsInfo); + if (currentModule) { + queue.enqueue(currentModule, runtime); + } + } + currentExportsInfo = nestedInfo; + continue; + } + } + if ( + exportInfo.setUsedConditionally( + (v) => v !== UsageState.Used, + UsageState.Used, + runtime + ) + ) { + const currentModule = + currentExportsInfo === exportsInfo + ? module + : exportInfoToModuleMap.get(currentExportsInfo); + if (currentModule) { + queue.enqueue(currentModule, runtime); + } + } + break; + } + } + } + } else { + // for a module without side effects we stop tracking usage here when no export is used + // This module won't be evaluated in this case + // TODO webpack 6 remove this check + if ( + !forceSideEffects && + module.factoryMeta !== undefined && + module.factoryMeta.sideEffectFree + ) { + return; + } + if (exportsInfo.setUsedForSideEffectsOnly(runtime)) { + queue.enqueue(module, runtime); + } + } + }; + + /** + * Processes the provided module. + * @param {DependenciesBlock} module the module + * @param {RuntimeSpec} runtime part of which runtime + * @param {boolean} forceSideEffects always apply side effects + * @returns {void} + */ + const processModule = (module, runtime, forceSideEffects) => { + /** @typedef {Map} ExportMaps */ + /** @type {Map} */ + const map = new Map(); + + /** @type {ArrayQueue} */ + const queue = new ArrayQueue(); + queue.enqueue(module); + for (;;) { + const block = queue.dequeue(); + if (block === undefined) break; + for (const b of block.blocks) { + if (b.groupOptions && b.groupOptions.entryOptions) { + processModule( + b, + this.global + ? undefined + : b.groupOptions.entryOptions.runtime || undefined, + true + ); + } else { + queue.enqueue(b); + } + } + for (const dep of block.dependencies) { + const connection = moduleGraph.getConnection(dep); + if (!connection || !connection.module) { + continue; + } + const activeState = connection.getActiveState(runtime); + if (activeState === false) continue; + const { module } = connection; + if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) { + processModule(module, runtime, false); + continue; + } + const oldReferencedExports = map.get(module); + if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) { + continue; + } + const referencedExports = + compilation.getDependencyReferencedExports(dep, runtime); + if ( + oldReferencedExports === undefined || + oldReferencedExports === NO_EXPORTS_REFERENCED || + referencedExports === EXPORTS_OBJECT_REFERENCED + ) { + map.set(module, referencedExports); + } else if ( + oldReferencedExports !== undefined && + referencedExports === NO_EXPORTS_REFERENCED + ) { + continue; + } else { + /** @type {undefined | ExportMaps} */ + let exportsMap; + if (Array.isArray(oldReferencedExports)) { + exportsMap = new Map(); + for (const item of oldReferencedExports) { + if (Array.isArray(item)) { + exportsMap.set(item.join("\n"), item); + } else { + exportsMap.set(item.name.join("\n"), item); + } + } + map.set(module, exportsMap); + } else { + exportsMap = oldReferencedExports; + } + for (const item of referencedExports) { + if (Array.isArray(item)) { + const key = item.join("\n"); + const oldItem = exportsMap.get(key); + if (oldItem === undefined) { + exportsMap.set(key, item); + } + // if oldItem is already an array we have to do nothing + // if oldItem is an ReferencedExport object, we don't have to do anything + // as canMangle defaults to true for arrays + } else { + const key = item.name.join("\n"); + const oldItem = exportsMap.get(key); + if (oldItem === undefined || Array.isArray(oldItem)) { + exportsMap.set(key, item); + } else { + exportsMap.set(key, { + name: item.name, + canMangle: item.canMangle && oldItem.canMangle + }); + } + } + } + } + } + } + + for (const [module, referencedExports] of map) { + if (Array.isArray(referencedExports)) { + processReferencedModule( + module, + referencedExports, + runtime, + forceSideEffects + ); + } else { + processReferencedModule( + module, + [...referencedExports.values()], + runtime, + forceSideEffects + ); + } + } + }; + + logger.time("initialize exports usage"); + for (const module of modules) { + const exportsInfo = moduleGraph.getExportsInfo(module); + exportInfoToModuleMap.set(exportsInfo, module); + exportsInfo.setHasUseInfo(); + } + logger.timeEnd("initialize exports usage"); + + logger.time("trace exports usage in graph"); + + /** + * Process entry dependency. + * @param {Dependency} dep dependency + * @param {RuntimeSpec} runtime runtime + */ + const processEntryDependency = (dep, runtime) => { + const module = moduleGraph.getModule(dep); + if (module) { + processReferencedModule( + module, + NO_EXPORTS_REFERENCED, + runtime, + true + ); + } + }; + /** @type {RuntimeSpec} */ + let globalRuntime; + for (const [ + entryName, + { dependencies: deps, includeDependencies: includeDeps, options } + ] of compilation.entries) { + const runtime = this.global + ? undefined + : getEntryRuntime(compilation, entryName, options); + for (const dep of deps) { + processEntryDependency(dep, runtime); + } + for (const dep of includeDeps) { + processEntryDependency(dep, runtime); + } + globalRuntime = mergeRuntimeOwned(globalRuntime, runtime); + } + for (const dep of compilation.globalEntry.dependencies) { + processEntryDependency(dep, globalRuntime); + } + for (const dep of compilation.globalEntry.includeDependencies) { + processEntryDependency(dep, globalRuntime); + } + + while (queue.length) { + const [module, runtime] = /** @type {[Module, RuntimeSpec]} */ ( + queue.dequeue() + ); + processModule(module, runtime, false); + } + logger.timeEnd("trace exports usage in graph"); + } + ); + }); + } +} + +module.exports = FlagDependencyUsagePlugin; Index: frontend/node_modules/webpack/lib/FlagEntryExportAsUsedPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/FlagEntryExportAsUsedPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/FlagEntryExportAsUsedPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,57 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { getEntryRuntime } = require("./util/runtime"); + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "FlagEntryExportAsUsedPlugin"; + +class FlagEntryExportAsUsedPlugin { + /** + * Creates an instance of FlagEntryExportAsUsedPlugin. + * @param {boolean} nsObjectUsed true, if the ns object is used + * @param {string} explanation explanation for the reason + */ + constructor(nsObjectUsed, explanation) { + this.nsObjectUsed = nsObjectUsed; + this.explanation = explanation; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => { + const moduleGraph = compilation.moduleGraph; + compilation.hooks.seal.tap(PLUGIN_NAME, () => { + for (const [ + entryName, + { dependencies: deps, options } + ] of compilation.entries) { + const runtime = getEntryRuntime(compilation, entryName, options); + for (const dep of deps) { + const module = moduleGraph.getModule(dep); + if (module) { + const exportsInfo = moduleGraph.getExportsInfo(module); + if (this.nsObjectUsed) { + exportsInfo.setUsedInUnknownWay(runtime); + } else { + exportsInfo.setAllKnownExportsUsed(runtime); + } + moduleGraph.addExtraReason(module, this.explanation); + } + } + } + }); + }); + } +} + +module.exports = FlagEntryExportAsUsedPlugin; Index: frontend/node_modules/webpack/lib/Generator.js =================================================================== --- frontend/node_modules/webpack/lib/Generator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Generator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,201 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */ +/** @typedef {import("./ConcatenationScope")} ConcatenationScope */ +/** @typedef {import("./DependencyTemplates")} DependencyTemplates */ +/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */ +/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./Module").SourceType} SourceType */ +/** @typedef {import("./Module").SourceTypes} SourceTypes */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./NormalModule")} NormalModule */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** + * Defines the generate context type used by this module. + * @typedef {object} GenerateContext + * @property {DependencyTemplates} dependencyTemplates mapping from dependencies to templates + * @property {RuntimeTemplate} runtimeTemplate the runtime template + * @property {ModuleGraph} moduleGraph the module graph + * @property {ChunkGraph} chunkGraph the chunk graph + * @property {RuntimeRequirements} runtimeRequirements the requirements for runtime + * @property {RuntimeSpec} runtime the runtime + * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules + * @property {CodeGenerationResults=} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that) + * @property {SourceType} type which kind of code should be generated + * @property {() => CodeGenerationResultData=} getData get access to the code generation data + */ + +/** + * Defines the generate error fn callback. + * @callback GenerateErrorFn + * @param {Error} error the error + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + +/** + * Represents the generator runtime component. + * @typedef {object} UpdateHashContext + * @property {NormalModule} module the module + * @property {ChunkGraph} chunkGraph + * @property {RuntimeSpec} runtime + * @property {RuntimeTemplate=} runtimeTemplate + */ + +class Generator { + /** + * Returns generator by type. + * @param {{ [key in SourceType]?: Generator }} map map of types + * @returns {ByTypeGenerator} generator by type + */ + static byType(map) { + return new ByTypeGenerator(map); + } + + /* istanbul ignore next */ + /** + * Returns the source types available for this module. + * @abstract + * @param {NormalModule} module fresh module + * @returns {SourceTypes} available types (do not mutate) + */ + getTypes(module) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /* istanbul ignore next */ + /** + * Returns the estimated size for the requested source type. + * @abstract + * @param {NormalModule} module the module + * @param {SourceType=} type source type + * @returns {number} estimate size of the module + */ + getSize(module, type) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /* istanbul ignore next */ + /** + * Generates generated code for this runtime module. + * @abstract + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generate( + module, + { dependencyTemplates, runtimeTemplate, moduleGraph, type } + ) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /** + * Returns the reason this module cannot be concatenated, when one exists. + * @param {NormalModule} module module for which the bailout reason should be determined + * @param {ConcatenationBailoutReasonContext} context context + * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated + */ + getConcatenationBailoutReason(module, context) { + return `Module Concatenation is not implemented for ${this.constructor.name}`; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash hash that will be modified + * @param {UpdateHashContext} updateHashContext context for updating hash + */ + updateHash(hash, { module, runtime }) { + // no nothing + } +} + +/** + * @this {ByTypeGenerator} + * @type {GenerateErrorFn} + */ +function generateError(error, module, generateContext) { + const type = generateContext.type; + const generator = + /** @type {Generator & { generateError?: GenerateErrorFn }} */ + (this.map[type]); + if (!generator) { + throw new Error(`Generator.byType: no generator specified for ${type}`); + } + if (typeof generator.generateError === "undefined") { + return null; + } + return generator.generateError(error, module, generateContext); +} + +class ByTypeGenerator extends Generator { + /** + * Creates an instance of ByTypeGenerator. + * @param {{ [key in SourceType]?: Generator }} map map of types + */ + constructor(map) { + super(); + this.map = map; + this._types = /** @type {SourceTypes} */ (new Set(Object.keys(map))); + /** @type {GenerateErrorFn | undefined} */ + this.generateError = generateError.bind(this); + } + + /** + * Returns the source types available for this module. + * @param {NormalModule} module fresh module + * @returns {SourceTypes} available types (do not mutate) + */ + getTypes(module) { + return this._types; + } + + /** + * Returns the estimated size for the requested source type. + * @param {NormalModule} module the module + * @param {SourceType=} type source type + * @returns {number} estimate size of the module + */ + getSize(module, type = JAVASCRIPT_TYPE) { + const t = type; + const generator = this.map[t]; + return generator ? generator.getSize(module, t) : 0; + } + + /** + * Generates generated code for this runtime module. + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generate(module, generateContext) { + const type = generateContext.type; + const generator = this.map[type]; + if (!generator) { + throw new Error(`Generator.byType: no generator specified for ${type}`); + } + return generator.generate(module, generateContext); + } +} + +module.exports = Generator; Index: frontend/node_modules/webpack/lib/HotModuleReplacementPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/HotModuleReplacementPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/HotModuleReplacementPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,956 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { SyncBailHook } = require("tapable"); +const { RawSource } = require("webpack-sources"); +const ChunkGraph = require("./ChunkGraph"); +const Compilation = require("./Compilation"); +const HotUpdateChunk = require("./HotUpdateChunk"); +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM, + WEBPACK_MODULE_TYPE_RUNTIME +} = require("./ModuleTypeConstants"); +const NormalModule = require("./NormalModule"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const { chunkHasCss } = require("./css/CssModulesPlugin"); +const ConstDependency = require("./dependencies/ConstDependency"); +const ImportMetaHotAcceptDependency = require("./dependencies/ImportMetaHotAcceptDependency"); +const ImportMetaHotDeclineDependency = require("./dependencies/ImportMetaHotDeclineDependency"); +const ModuleHotAcceptDependency = require("./dependencies/ModuleHotAcceptDependency"); +const ModuleHotDeclineDependency = require("./dependencies/ModuleHotDeclineDependency"); +const WebpackError = require("./errors/WebpackError"); +const HotModuleReplacementRuntimeModule = require("./hmr/HotModuleReplacementRuntimeModule"); +const JavascriptParser = require("./javascript/JavascriptParser"); +const { + evaluateToIdentifier +} = require("./javascript/JavascriptParserHelpers"); +const ConcatenatedModule = require("./optimize/ConcatenatedModule"); +const { find, isSubset } = require("./util/SetHelpers"); +const TupleSet = require("./util/TupleSet"); +const { compareModulesById } = require("./util/comparators"); +const { + forEachRuntime, + getRuntimeKey, + intersectRuntime, + keyToRuntime, + mergeRuntimeOwned, + subtractRuntime +} = require("./util/runtime"); + +/** @typedef {import("estree").CallExpression} CallExpression */ +/** @typedef {import("estree").Expression} Expression */ +/** @typedef {import("estree").SpreadElement} SpreadElement */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Chunk").ChunkId} ChunkId */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ +/** @typedef {import("./Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("./Compilation").Records} Records */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./RuntimeModule")} RuntimeModule */ +/** @typedef {import("./javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */ +/** @typedef {import("./javascript/JavascriptParserHelpers").Range} Range */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** @typedef {string[]} Requests */ + +/** + * Defines the hmr javascript parser hooks type used by this module. + * @typedef {object} HMRJavascriptParserHooks + * @property {SyncBailHook<[Expression | SpreadElement, Requests], void>} hotAcceptCallback + * @property {SyncBailHook<[CallExpression, Requests], void>} hotAcceptWithoutCallback + */ + +/** @typedef {number} HotIndex */ +/** @typedef {Record} FullHashChunkModuleHashes */ +/** @typedef {Record} ChunkModuleHashes */ +/** @typedef {Record} ChunkHashes */ +/** @typedef {Record} ChunkRuntime */ +/** @typedef {Record} ChunkModuleIds */ + +/** @typedef {Set} ChunkIds */ +/** @typedef {Set} ModuleSet */ + +/** @typedef {{ updatedChunkIds: ChunkIds, removedChunkIds: ChunkIds, removedModules: ModuleSet, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */ +/** @typedef {Map} HotUpdateMainContentByRuntime */ + +/** @type {WeakMap} */ +const parserHooksMap = new WeakMap(); + +const PLUGIN_NAME = "HotModuleReplacementPlugin"; + +class HotModuleReplacementPlugin { + /** + * Returns the attached hooks. + * @param {JavascriptParser} parser the parser + * @returns {HMRJavascriptParserHooks} the attached hooks + */ + static getParserHooks(parser) { + if (!(parser instanceof JavascriptParser)) { + throw new TypeError( + "The 'parser' argument must be an instance of JavascriptParser" + ); + } + let hooks = parserHooksMap.get(parser); + if (hooks === undefined) { + hooks = { + hotAcceptCallback: new SyncBailHook(["expression", "requests"]), + hotAcceptWithoutCallback: new SyncBailHook(["expression", "requests"]) + }; + parserHooksMap.set(parser, hooks); + } + return hooks; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const { _backCompat: backCompat } = compiler; + if (compiler.options.output.strictModuleErrorHandling === undefined) { + compiler.options.output.strictModuleErrorHandling = true; + } + const runtimeRequirements = [RuntimeGlobals.module]; + + /** + * Creates an accept handler. + * @param {JavascriptParser} parser the parser + * @param {typeof ModuleHotAcceptDependency} ParamDependency dependency + * @returns {(expr: CallExpression) => boolean | undefined} callback + */ + const createAcceptHandler = (parser, ParamDependency) => { + const { hotAcceptCallback, hotAcceptWithoutCallback } = + HotModuleReplacementPlugin.getParserHooks(parser); + + return (expr) => { + const module = parser.state.module; + const dep = new ConstDependency( + `${module.moduleArgument}.hot.accept`, + /** @type {Range} */ (expr.callee.range), + runtimeRequirements + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + module.addPresentationalDependency(dep); + /** @type {BuildInfo} */ + (module.buildInfo).moduleConcatenationBailout = + "Hot Module Replacement"; + + if (expr.arguments.length >= 1) { + const arg = parser.evaluateExpression(expr.arguments[0]); + /** @type {BasicEvaluatedExpression[]} */ + let params = []; + if (arg.isString()) { + params = [arg]; + } else if (arg.isArray()) { + params = + /** @type {BasicEvaluatedExpression[]} */ + (arg.items).filter((param) => param.isString()); + } + /** @type {Requests} */ + const requests = []; + if (params.length > 0) { + for (const [idx, param] of params.entries()) { + const request = /** @type {string} */ (param.string); + const dep = new ParamDependency( + request, + /** @type {Range} */ (param.range) + ); + dep.optional = true; + dep.loc = Object.create( + /** @type {DependencyLocation} */ (expr.loc) + ); + dep.loc.index = idx; + module.addDependency(dep); + requests.push(request); + } + if (expr.arguments.length > 1) { + hotAcceptCallback.call(expr.arguments[1], requests); + for (let i = 1; i < expr.arguments.length; i++) { + parser.walkExpression(expr.arguments[i]); + } + return true; + } + hotAcceptWithoutCallback.call(expr, requests); + return true; + } + } + parser.walkExpressions(expr.arguments); + return true; + }; + }; + + /** + * Creates a decline handler. + * @param {JavascriptParser} parser the parser + * @param {typeof ModuleHotDeclineDependency} ParamDependency dependency + * @returns {(expr: CallExpression) => boolean | undefined} callback + */ + const createDeclineHandler = (parser, ParamDependency) => (expr) => { + const module = parser.state.module; + const dep = new ConstDependency( + `${module.moduleArgument}.hot.decline`, + /** @type {Range} */ (expr.callee.range), + runtimeRequirements + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + module.addPresentationalDependency(dep); + /** @type {BuildInfo} */ + (module.buildInfo).moduleConcatenationBailout = "Hot Module Replacement"; + if (expr.arguments.length === 1) { + const arg = parser.evaluateExpression(expr.arguments[0]); + /** @type {BasicEvaluatedExpression[]} */ + let params = []; + if (arg.isString()) { + params = [arg]; + } else if (arg.isArray()) { + params = + /** @type {BasicEvaluatedExpression[]} */ + (arg.items).filter((param) => param.isString()); + } + for (const [idx, param] of params.entries()) { + const dep = new ParamDependency( + /** @type {string} */ (param.string), + /** @type {Range} */ (param.range) + ); + dep.optional = true; + dep.loc = Object.create(/** @type {DependencyLocation} */ (expr.loc)); + dep.loc.index = idx; + module.addDependency(dep); + } + } + return true; + }; + + /** + * Creates a hmr expression handler. + * @param {JavascriptParser} parser the parser + * @returns {(expr: Expression) => boolean | undefined} callback + */ + const createHMRExpressionHandler = (parser) => (expr) => { + const module = parser.state.module; + const dep = new ConstDependency( + `${module.moduleArgument}.hot`, + /** @type {Range} */ (expr.range), + runtimeRequirements + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + module.addPresentationalDependency(dep); + /** @type {BuildInfo} */ + (module.buildInfo).moduleConcatenationBailout = "Hot Module Replacement"; + return true; + }; + + /** + * Processes the provided parser. + * @param {JavascriptParser} parser the parser + * @returns {void} + */ + const applyModuleHot = (parser) => { + parser.hooks.evaluateIdentifier.for("module.hot").tap( + { + name: PLUGIN_NAME, + before: "NodeStuffPlugin" + }, + (expr) => + evaluateToIdentifier( + "module.hot", + "module", + () => ["hot"], + true + )(expr) + ); + parser.hooks.call + .for("module.hot.accept") + .tap( + PLUGIN_NAME, + createAcceptHandler(parser, ModuleHotAcceptDependency) + ); + parser.hooks.call + .for("module.hot.decline") + .tap( + PLUGIN_NAME, + createDeclineHandler(parser, ModuleHotDeclineDependency) + ); + parser.hooks.expression + .for("module.hot") + .tap(PLUGIN_NAME, createHMRExpressionHandler(parser)); + }; + + /** + * Apply import meta hot. + * @param {JavascriptParser} parser the parser + * @returns {void} + */ + const applyImportMetaHot = (parser) => { + parser.hooks.evaluateIdentifier + .for("import.meta.webpackHot") + .tap(PLUGIN_NAME, (expr) => + evaluateToIdentifier( + "import.meta.webpackHot", + "import.meta", + () => ["webpackHot"], + true + )(expr) + ); + parser.hooks.call + .for("import.meta.webpackHot.accept") + .tap( + PLUGIN_NAME, + createAcceptHandler(parser, ImportMetaHotAcceptDependency) + ); + parser.hooks.call + .for("import.meta.webpackHot.decline") + .tap( + PLUGIN_NAME, + createDeclineHandler(parser, ImportMetaHotDeclineDependency) + ); + parser.hooks.expression + .for("import.meta.webpackHot") + .tap(PLUGIN_NAME, createHMRExpressionHandler(parser)); + }; + + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + // This applies the HMR plugin only to the targeted compiler + // It should not affect child compilations + if (compilation.compiler !== compiler) return; + + // #region module.hot.* API + compilation.dependencyFactories.set( + ModuleHotAcceptDependency, + normalModuleFactory + ); + compilation.dependencyTemplates.set( + ModuleHotAcceptDependency, + new ModuleHotAcceptDependency.Template() + ); + compilation.dependencyFactories.set( + ModuleHotDeclineDependency, + normalModuleFactory + ); + compilation.dependencyTemplates.set( + ModuleHotDeclineDependency, + new ModuleHotDeclineDependency.Template() + ); + // #endregion + + // #region import.meta.webpackHot.* API + compilation.dependencyFactories.set( + ImportMetaHotAcceptDependency, + normalModuleFactory + ); + compilation.dependencyTemplates.set( + ImportMetaHotAcceptDependency, + new ImportMetaHotAcceptDependency.Template() + ); + compilation.dependencyFactories.set( + ImportMetaHotDeclineDependency, + normalModuleFactory + ); + compilation.dependencyTemplates.set( + ImportMetaHotDeclineDependency, + new ImportMetaHotDeclineDependency.Template() + ); + // #endregion + + /** @type {HotIndex} */ + let hotIndex = 0; + /** @type {FullHashChunkModuleHashes} */ + const fullHashChunkModuleHashes = {}; + /** @type {ChunkModuleHashes} */ + const chunkModuleHashes = {}; + + compilation.hooks.record.tap(PLUGIN_NAME, (compilation, records) => { + if (records.hash === compilation.hash) return; + const chunkGraph = compilation.chunkGraph; + records.hash = compilation.hash; + records.hotIndex = hotIndex; + records.fullHashChunkModuleHashes = fullHashChunkModuleHashes; + records.chunkModuleHashes = chunkModuleHashes; + records.chunkHashes = {}; + records.chunkRuntime = {}; + for (const chunk of compilation.chunks) { + const chunkId = /** @type {ChunkId} */ (chunk.id); + records.chunkHashes[chunkId] = /** @type {string} */ (chunk.hash); + records.chunkRuntime[chunkId] = getRuntimeKey(chunk.runtime); + } + records.chunkModuleIds = {}; + for (const chunk of compilation.chunks) { + const chunkId = /** @type {ChunkId} */ (chunk.id); + + /** @type {ModuleId[]} */ + const moduleIds = []; + for (const m of chunkGraph.getOrderedChunkModulesIterable( + chunk, + compareModulesById(chunkGraph) + )) { + moduleIds.push( + /** @type {ModuleId} */ (chunkGraph.getModuleId(m)) + ); + if (m instanceof ConcatenatedModule && m.modules) { + for (const innerModule of m.modules) { + if ( + innerModule.buildMeta && + innerModule.buildMeta.needIdInConcatenation + ) { + const innerId = chunkGraph.getModuleId(innerModule); + if (innerId !== null) { + moduleIds.push(innerId); + } + } + } + } + } + records.chunkModuleIds[chunkId] = moduleIds; + } + }); + /** @type {TupleSet} */ + const updatedModules = new TupleSet(); + /** @type {TupleSet} */ + const fullHashModules = new TupleSet(); + /** @type {TupleSet} */ + const nonCodeGeneratedModules = new TupleSet(); + compilation.hooks.fullHash.tap(PLUGIN_NAME, (hash) => { + const chunkGraph = compilation.chunkGraph; + const records = /** @type {Records} */ (compilation.records); + for (const chunk of compilation.chunks) { + /** + * Returns module hash. + * @param {Module} module module + * @returns {string} module hash + */ + const getModuleHash = (module) => { + const codeGenerationResults = + /** @type {CodeGenerationResults} */ + (compilation.codeGenerationResults); + if (codeGenerationResults.has(module, chunk.runtime)) { + return codeGenerationResults.getHash(module, chunk.runtime); + } + nonCodeGeneratedModules.add(module, chunk.runtime); + return chunkGraph.getModuleHash(module, chunk.runtime); + }; + const fullHashModulesInThisChunk = + chunkGraph.getChunkFullHashModulesSet(chunk); + if (fullHashModulesInThisChunk !== undefined) { + for (const module of fullHashModulesInThisChunk) { + fullHashModules.add(module, chunk); + } + } + const modules = chunkGraph.getChunkModulesIterable(chunk); + if (modules !== undefined) { + if (records.chunkModuleHashes) { + if (fullHashModulesInThisChunk !== undefined) { + for (const module of modules) { + const key = `${chunk.id}|${module.identifier()}`; + const hash = getModuleHash(module); + if ( + fullHashModulesInThisChunk.has( + /** @type {RuntimeModule} */ + (module) + ) + ) { + if ( + /** @type {FullHashChunkModuleHashes} */ + (records.fullHashChunkModuleHashes)[key] !== hash + ) { + updatedModules.add(module, chunk); + } + fullHashChunkModuleHashes[key] = hash; + } else { + if (records.chunkModuleHashes[key] !== hash) { + updatedModules.add(module, chunk); + } + chunkModuleHashes[key] = hash; + } + } + } else { + for (const module of modules) { + const key = `${chunk.id}|${module.identifier()}`; + const hash = getModuleHash(module); + if (records.chunkModuleHashes[key] !== hash) { + updatedModules.add(module, chunk); + } + chunkModuleHashes[key] = hash; + } + } + } else if (fullHashModulesInThisChunk !== undefined) { + for (const module of modules) { + const key = `${chunk.id}|${module.identifier()}`; + const hash = getModuleHash(module); + if ( + fullHashModulesInThisChunk.has( + /** @type {RuntimeModule} */ (module) + ) + ) { + fullHashChunkModuleHashes[key] = hash; + } else { + chunkModuleHashes[key] = hash; + } + } + } else { + for (const module of modules) { + const key = `${chunk.id}|${module.identifier()}`; + const hash = getModuleHash(module); + chunkModuleHashes[key] = hash; + } + } + } + } + + hotIndex = records.hotIndex || 0; + if (updatedModules.size > 0) hotIndex++; + + hash.update(`${hotIndex}`); + }); + compilation.hooks.processAssets.tap( + { + name: PLUGIN_NAME, + stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL + }, + () => { + const chunkGraph = compilation.chunkGraph; + const records = /** @type {Records} */ (compilation.records); + if (records.hash === compilation.hash) return; + if ( + !records.chunkModuleHashes || + !records.chunkHashes || + !records.chunkModuleIds + ) { + return; + } + const codeGenerationResults = + /** @type {CodeGenerationResults} */ + (compilation.codeGenerationResults); + for (const [module, chunk] of fullHashModules) { + const key = `${chunk.id}|${module.identifier()}`; + const hash = nonCodeGeneratedModules.has(module, chunk.runtime) + ? chunkGraph.getModuleHash(module, chunk.runtime) + : codeGenerationResults.getHash(module, chunk.runtime); + if (records.chunkModuleHashes[key] !== hash) { + updatedModules.add(module, chunk); + } + chunkModuleHashes[key] = hash; + } + + /** @type {HotUpdateMainContentByRuntime} */ + const hotUpdateMainContentByRuntime = new Map(); + /** @type {RuntimeSpec} */ + let allOldRuntime; + const chunkRuntime = + /** @type {ChunkRuntime} */ + (records.chunkRuntime); + for (const key of Object.keys(chunkRuntime)) { + const runtime = keyToRuntime(chunkRuntime[key]); + allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime); + } + forEachRuntime(allOldRuntime, (runtime) => { + const { path: filename, info: assetInfo } = + compilation.getPathWithInfo( + compilation.outputOptions.hotUpdateMainFilename, + { + hash: records.hash, + runtime + } + ); + hotUpdateMainContentByRuntime.set( + /** @type {string} */ (runtime), + { + /** @type {ChunkIds} */ + updatedChunkIds: new Set(), + /** @type {ChunkIds} */ + removedChunkIds: new Set(), + /** @type {ModuleSet} */ + removedModules: new Set(), + filename, + assetInfo + } + ); + }); + if (hotUpdateMainContentByRuntime.size === 0) return; + + // Create a list of all active modules to verify which modules are removed completely + /** @type {Map} */ + const allModules = new Map(); + for (const module of compilation.modules) { + const id = + /** @type {ModuleId} */ + (chunkGraph.getModuleId(module)); + allModules.set(id, module); + } + + // List of completely removed modules + /** @type {Set} */ + const completelyRemovedModules = new Set(); + + for (const key of Object.keys(records.chunkHashes)) { + const oldRuntime = keyToRuntime( + /** @type {ChunkRuntime} */ + (records.chunkRuntime)[key] + ); + /** @type {Module[]} */ + const remainingModules = []; + // Check which modules are removed + for (const id of records.chunkModuleIds[key]) { + const module = allModules.get(id); + if (module === undefined) { + completelyRemovedModules.add(id); + } else { + remainingModules.push(module); + } + } + + /** @type {ChunkId | null} */ + let chunkId; + /** @type {undefined | Module[]} */ + let newModules; + /** @type {undefined | RuntimeModule[]} */ + let newRuntimeModules; + /** @type {undefined | RuntimeModule[]} */ + let newFullHashModules; + /** @type {undefined | RuntimeModule[]} */ + let newDependentHashModules; + /** @type {RuntimeSpec} */ + let newRuntime; + /** @type {RuntimeSpec} */ + let removedFromRuntime; + const currentChunk = find( + compilation.chunks, + (chunk) => `${chunk.id}` === key + ); + if (currentChunk) { + chunkId = currentChunk.id; + newRuntime = intersectRuntime( + currentChunk.runtime, + allOldRuntime + ); + if (newRuntime === undefined) continue; + newModules = chunkGraph + .getChunkModules(currentChunk) + .filter((module) => updatedModules.has(module, currentChunk)); + newRuntimeModules = [ + ...chunkGraph.getChunkRuntimeModulesIterable(currentChunk) + ].filter((module) => updatedModules.has(module, currentChunk)); + const fullHashModules = + chunkGraph.getChunkFullHashModulesIterable(currentChunk); + newFullHashModules = + fullHashModules && + [...fullHashModules].filter((module) => + updatedModules.has(module, currentChunk) + ); + const dependentHashModules = + chunkGraph.getChunkDependentHashModulesIterable(currentChunk); + newDependentHashModules = + dependentHashModules && + [...dependentHashModules].filter((module) => + updatedModules.has(module, currentChunk) + ); + removedFromRuntime = subtractRuntime(oldRuntime, newRuntime); + } else { + // chunk has completely removed + chunkId = `${Number(key)}` === key ? Number(key) : key; + removedFromRuntime = oldRuntime; + newRuntime = oldRuntime; + } + if (removedFromRuntime) { + // chunk was removed from some runtimes + forEachRuntime(removedFromRuntime, (runtime) => { + const item = + /** @type {HotUpdateMainContentByRuntimeItem} */ + ( + hotUpdateMainContentByRuntime.get( + /** @type {string} */ (runtime) + ) + ); + item.removedChunkIds.add(/** @type {ChunkId} */ (chunkId)); + }); + // dispose modules from the chunk in these runtimes + // where they are no longer in this runtime + for (const module of remainingModules) { + const moduleKey = `${key}|${module.identifier()}`; + const oldHash = records.chunkModuleHashes[moduleKey]; + const runtimes = chunkGraph.getModuleRuntimes(module); + if (oldRuntime === newRuntime && runtimes.has(newRuntime)) { + // Module is still in the same runtime combination + const hash = nonCodeGeneratedModules.has(module, newRuntime) + ? chunkGraph.getModuleHash(module, newRuntime) + : codeGenerationResults.getHash(module, newRuntime); + if (hash !== oldHash) { + if (module.type === WEBPACK_MODULE_TYPE_RUNTIME) { + newRuntimeModules = newRuntimeModules || []; + newRuntimeModules.push( + /** @type {RuntimeModule} */ (module) + ); + } else { + newModules = newModules || []; + newModules.push(module); + } + } + } else { + // module is no longer in this runtime combination + // We (incorrectly) assume that it's not in an overlapping runtime combination + // and dispose it from the main runtimes the chunk was removed from + forEachRuntime(removedFromRuntime, (runtime) => { + // If the module is still used in this runtime, do not dispose it + // This could create a bad runtime state where the module is still loaded, + // but no chunk which contains it. This means we don't receive further HMR updates + // to this module and that's bad. + // TODO force load one of the chunks which contains the module + for (const moduleRuntime of runtimes) { + if (typeof moduleRuntime === "string") { + if (moduleRuntime === runtime) return; + } else if ( + moduleRuntime !== undefined && + moduleRuntime.has(/** @type {string} */ (runtime)) + ) { + return; + } + } + const item = + /** @type {HotUpdateMainContentByRuntimeItem} */ ( + hotUpdateMainContentByRuntime.get( + /** @type {string} */ (runtime) + ) + ); + item.removedModules.add(module); + }); + } + } + } + if ( + (newModules && newModules.length > 0) || + (newRuntimeModules && newRuntimeModules.length > 0) + ) { + const hotUpdateChunk = new HotUpdateChunk(); + if (backCompat) { + ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph); + } + hotUpdateChunk.id = chunkId; + hotUpdateChunk.runtime = currentChunk + ? currentChunk.runtime + : newRuntime; + if (currentChunk) { + for (const group of currentChunk.groupsIterable) { + hotUpdateChunk.addGroup(group); + } + } + chunkGraph.attachModules(hotUpdateChunk, newModules || []); + chunkGraph.attachRuntimeModules( + hotUpdateChunk, + newRuntimeModules || [] + ); + if (newFullHashModules) { + chunkGraph.attachFullHashModules( + hotUpdateChunk, + newFullHashModules + ); + } + if (newDependentHashModules) { + chunkGraph.attachDependentHashModules( + hotUpdateChunk, + newDependentHashModules + ); + } + const renderManifest = compilation.getRenderManifest({ + chunk: hotUpdateChunk, + hash: /** @type {string} */ (records.hash), + fullHash: /** @type {string} */ (records.hash), + outputOptions: compilation.outputOptions, + moduleTemplates: compilation.moduleTemplates, + dependencyTemplates: compilation.dependencyTemplates, + codeGenerationResults: /** @type {CodeGenerationResults} */ ( + compilation.codeGenerationResults + ), + runtimeTemplate: compilation.runtimeTemplate, + moduleGraph: compilation.moduleGraph, + chunkGraph + }); + for (const entry of renderManifest) { + /** @type {string} */ + let filename; + /** @type {AssetInfo} */ + let assetInfo; + if ("filename" in entry) { + filename = entry.filename; + assetInfo = entry.info; + } else { + ({ path: filename, info: assetInfo } = + compilation.getPathWithInfo( + entry.filenameTemplate, + entry.pathOptions + )); + } + const source = entry.render(); + compilation.additionalChunkAssets.push(filename); + compilation.emitAsset(filename, source, { + hotModuleReplacement: true, + ...assetInfo + }); + if (currentChunk) { + currentChunk.files.add(filename); + compilation.hooks.chunkAsset.call(currentChunk, filename); + } + } + forEachRuntime(newRuntime, (runtime) => { + const item = + /** @type {HotUpdateMainContentByRuntimeItem} */ ( + hotUpdateMainContentByRuntime.get( + /** @type {string} */ (runtime) + ) + ); + item.updatedChunkIds.add(/** @type {ChunkId} */ (chunkId)); + }); + } + } + const completelyRemovedModulesArray = [...completelyRemovedModules]; + /** @type {Map>} */ + const hotUpdateMainContentByFilename = new Map(); + for (const { + removedChunkIds, + removedModules, + updatedChunkIds, + filename, + assetInfo + } of hotUpdateMainContentByRuntime.values()) { + const old = hotUpdateMainContentByFilename.get(filename); + if ( + old && + (!isSubset(old.removedChunkIds, removedChunkIds) || + !isSubset(old.removedModules, removedModules) || + !isSubset(old.updatedChunkIds, updatedChunkIds)) + ) { + compilation.warnings.push( + new WebpackError(`HotModuleReplacementPlugin +The configured output.hotUpdateMainFilename doesn't lead to unique filenames per runtime and HMR update differs between runtimes. +This might lead to incorrect runtime behavior of the applied update. +To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename option, or use the default config.`) + ); + for (const chunkId of removedChunkIds) { + old.removedChunkIds.add(chunkId); + } + for (const chunkId of removedModules) { + old.removedModules.add(chunkId); + } + for (const chunkId of updatedChunkIds) { + old.updatedChunkIds.add(chunkId); + } + continue; + } + hotUpdateMainContentByFilename.set(filename, { + removedChunkIds, + removedModules, + updatedChunkIds, + assetInfo + }); + } + for (const [ + filename, + { removedChunkIds, removedModules, updatedChunkIds, assetInfo } + ] of hotUpdateMainContentByFilename) { + /** @type {{ c: ChunkId[], r: ChunkId[], m: ModuleId[], css?: { r: ChunkId[] } }} */ + const hotUpdateMainJson = { + c: [...updatedChunkIds], + r: [...removedChunkIds], + m: + removedModules.size === 0 + ? completelyRemovedModulesArray + : [ + ...completelyRemovedModulesArray, + ...Array.from( + removedModules, + (m) => + /** @type {ModuleId} */ (chunkGraph.getModuleId(m)) + ) + ] + }; + + // Build CSS removed chunks list (chunks in updatedChunkIds that no longer have CSS) + /** @type {ChunkId[]} */ + const cssRemovedChunkIds = []; + if (compilation.options.experiments.css) { + for (const chunkId of updatedChunkIds) { + for (const /** @type {Chunk} */ chunk of compilation.chunks) { + if (chunk.id === chunkId) { + if (!chunkHasCss(chunk, chunkGraph)) { + cssRemovedChunkIds.push(chunkId); + } + break; + } + } + } + } + + if (cssRemovedChunkIds.length > 0) { + hotUpdateMainJson.css = { r: cssRemovedChunkIds }; + } + + const source = new RawSource( + (filename.endsWith(".json") ? "" : "export default ") + + JSON.stringify(hotUpdateMainJson) + ); + compilation.emitAsset(filename, source, { + hotModuleReplacement: true, + ...assetInfo + }); + } + } + ); + + compilation.hooks.additionalTreeRuntimeRequirements.tap( + PLUGIN_NAME, + (chunk, runtimeRequirements) => { + runtimeRequirements.add(RuntimeGlobals.hmrDownloadManifest); + runtimeRequirements.add(RuntimeGlobals.hmrDownloadUpdateHandlers); + runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution); + runtimeRequirements.add(RuntimeGlobals.moduleCache); + compilation.addRuntimeModule( + chunk, + new HotModuleReplacementRuntimeModule() + ); + } + ); + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, (parser) => { + applyModuleHot(parser); + applyImportMetaHot(parser); + }); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, (parser) => { + applyModuleHot(parser); + }); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, (parser) => { + applyImportMetaHot(parser); + }); + normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module) => { + module.hot = true; + return module; + }); + + NormalModule.getCompilationHooks(compilation).loader.tap( + PLUGIN_NAME, + (context) => { + context.hot = true; + } + ); + } + ); + } +} + +module.exports = HotModuleReplacementPlugin; Index: frontend/node_modules/webpack/lib/HotUpdateChunk.js =================================================================== --- frontend/node_modules/webpack/lib/HotUpdateChunk.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/HotUpdateChunk.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,16 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Chunk = require("./Chunk"); + +class HotUpdateChunk extends Chunk { + constructor() { + super(); + } +} + +module.exports = HotUpdateChunk; Index: frontend/node_modules/webpack/lib/IgnorePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/IgnorePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/IgnorePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,108 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const RawModule = require("./RawModule"); +const EntryDependency = require("./dependencies/EntryDependency"); + +/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */ +/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */ + +/** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */ + +const PLUGIN_NAME = "IgnorePlugin"; + +class IgnorePlugin { + /** + * Creates an instance of IgnorePlugin. + * @param {IgnorePluginOptions} options IgnorePlugin options + */ + constructor(options) { + this.options = options; + this.checkIgnore = this.checkIgnore.bind(this); + } + + /** + * Note that if "contextRegExp" is given, both the "resourceRegExp" and "contextRegExp" have to match. + * @param {ResolveData | BeforeContextResolveData} resolveData resolve data + * @returns {false | undefined} returns false when the request should be ignored, otherwise undefined + */ + checkIgnore(resolveData) { + if ( + "checkResource" in this.options && + this.options.checkResource && + this.options.checkResource(resolveData.request, resolveData.context) + ) { + return false; + } + + if ( + "resourceRegExp" in this.options && + this.options.resourceRegExp && + this.options.resourceRegExp.test(resolveData.request) + ) { + if ("contextRegExp" in this.options && this.options.contextRegExp) { + // if "contextRegExp" is given, + // both the "resourceRegExp" and "contextRegExp" have to match. + if (this.options.contextRegExp.test(resolveData.context)) { + return false; + } + } else { + return false; + } + } + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + /** @type {EXPECTED_ANY} */ + (require("../schemas/plugins/IgnorePlugin.json")), + this.options, + { + name: "Ignore Plugin", + baseDataPath: "options" + }, + (options) => require("../schemas/plugins/IgnorePlugin.check")(options) + ); + }); + + compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => { + nmf.hooks.beforeResolve.tap(PLUGIN_NAME, (resolveData) => { + const result = this.checkIgnore(resolveData); + + if ( + result === false && + resolveData.dependencies.length > 0 && + resolveData.dependencies[0] instanceof EntryDependency + ) { + const module = new RawModule( + "", + "ignored-entry-module", + "(ignored-entry-module)" + ); + module.factoryMeta = { sideEffectFree: true }; + + resolveData.ignoredModule = module; + } + + return result; + }); + }); + compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => { + cmf.hooks.beforeResolve.tap(PLUGIN_NAME, this.checkIgnore); + }); + } +} + +module.exports = IgnorePlugin; Index: frontend/node_modules/webpack/lib/IgnoreWarningsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/IgnoreWarningsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/IgnoreWarningsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Compilation")} Compilation */ + +/** @typedef {(warning: Error, compilation: Compilation) => boolean} IgnoreFn */ + +const PLUGIN_NAME = "IgnoreWarningsPlugin"; + +class IgnoreWarningsPlugin { + /** + * Creates an instance of IgnoreWarningsPlugin. + * @param {IgnoreFn[]} ignoreWarnings conditions to ignore warnings + */ + constructor(ignoreWarnings) { + /** @type {IgnoreFn[]} */ + this._ignoreWarnings = ignoreWarnings; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + compilation.hooks.processWarnings.tap(PLUGIN_NAME, (warnings) => + warnings.filter( + (warning) => + !this._ignoreWarnings.some((ignore) => ignore(warning, compilation)) + ) + ); + }); + } +} + +module.exports = IgnoreWarningsPlugin; Index: frontend/node_modules/webpack/lib/InitFragment.js =================================================================== --- frontend/node_modules/webpack/lib/InitFragment.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/InitFragment.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,214 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Florent Cailhol @ooflorent +*/ + +"use strict"; + +const { ConcatSource } = require("webpack-sources"); +const makeSerializable = require("./util/makeSerializable"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./Generator").GenerateContext} GenerateContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ + +/** @typedef {string} InitFragmentKey */ + +/** + * Defines the maybe mergeable init fragment type used by this module. + * @template GenerateContext + * @typedef {object} MaybeMergeableInitFragment + * @property {InitFragmentKey=} key + * @property {number} stage + * @property {number} position + * @property {(context: GenerateContext) => string | Source | undefined} getContent + * @property {(context: GenerateContext) => string | Source | undefined} getEndContent + * @property {(fragments: MaybeMergeableInitFragment) => MaybeMergeableInitFragment=} merge + * @property {(fragments: MaybeMergeableInitFragment[]) => MaybeMergeableInitFragment[]=} mergeAll + */ + +/** + * Extract fragment index. + * @template T + * @param {T} fragment the init fragment + * @param {number} index index + * @returns {[T, number]} tuple with both + */ +const extractFragmentIndex = (fragment, index) => [fragment, index]; + +/** + * Sorts fragment with index. + * @template T + * @param {[MaybeMergeableInitFragment, number]} a first pair + * @param {[MaybeMergeableInitFragment, number]} b second pair + * @returns {number} sort value + */ +const sortFragmentWithIndex = ([a, i], [b, j]) => { + const stageCmp = a.stage - b.stage; + if (stageCmp !== 0) return stageCmp; + const positionCmp = a.position - b.position; + if (positionCmp !== 0) return positionCmp; + return i - j; +}; + +/** + * Represents InitFragment. + * @template GenerateContext + * @implements {MaybeMergeableInitFragment} + */ +class InitFragment { + /** + * Creates an instance of InitFragment. + * @param {string | Source | undefined} content the source code that will be included as initialization code + * @param {number} stage category of initialization code (contribute to order) + * @param {number} position position in the category (contribute to order) + * @param {InitFragmentKey=} key unique key to avoid emitting the same initialization code twice + * @param {string | Source=} endContent the source code that will be included at the end of the module + */ + constructor(content, stage, position, key, endContent) { + this.content = content; + this.stage = stage; + this.position = position; + this.key = key; + this.endContent = endContent; + } + + /** + * Returns the source code that will be included as initialization code. + * @param {GenerateContext} context context + * @returns {string | Source | undefined} the source code that will be included as initialization code + */ + getContent(context) { + return this.content; + } + + /** + * Returns the source code that will be included at the end of the module. + * @param {GenerateContext} context context + * @returns {string | Source | undefined} the source code that will be included at the end of the module + */ + getEndContent(context) { + return this.endContent; + } + + /** + * Adds the provided source to the init fragment. + * @template Context + * @param {Source} source sources + * @param {MaybeMergeableInitFragment[]} initFragments init fragments + * @param {Context} context context + * @returns {Source} source + */ + static addToSource(source, initFragments, context) { + if (initFragments.length > 0) { + // Sort fragments by position. If 2 fragments have the same position, + // use their index. + const sortedFragments = initFragments + .map(extractFragmentIndex) + .sort(sortFragmentWithIndex); + + // Deduplicate fragments. If a fragment has no key, it is always included. + /** @type {Map | MaybeMergeableInitFragment[]>} */ + const keyedFragments = new Map(); + for (const [fragment] of sortedFragments) { + if (typeof fragment.mergeAll === "function") { + if (!fragment.key) { + throw new Error( + `InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}` + ); + } + const oldValue = keyedFragments.get(fragment.key); + if (oldValue === undefined) { + keyedFragments.set(fragment.key, fragment); + } else if (Array.isArray(oldValue)) { + oldValue.push(fragment); + } else { + keyedFragments.set(fragment.key, [oldValue, fragment]); + } + continue; + } else if (typeof fragment.merge === "function") { + const key = /** @type {InitFragmentKey} */ (fragment.key); + const oldValue = + /** @type {MaybeMergeableInitFragment} */ + (keyedFragments.get(key)); + if (oldValue !== undefined) { + keyedFragments.set(key, fragment.merge(oldValue)); + continue; + } + } + keyedFragments.set(fragment.key || Symbol("fragment key"), fragment); + } + + const concatSource = new ConcatSource(); + /** @type {(string | Source)[]} */ + const endContents = []; + for (let fragment of keyedFragments.values()) { + if (Array.isArray(fragment)) { + fragment = + /** @type {[MaybeMergeableInitFragment & { mergeAll: (fragments: MaybeMergeableInitFragment[]) => MaybeMergeableInitFragment[] }, ...MaybeMergeableInitFragment[]]} */ + (fragment)[0].mergeAll(fragment); + } + const content = + /** @type {MaybeMergeableInitFragment} */ + (fragment).getContent(context); + if (content) { + concatSource.add(content); + } + const endContent = + /** @type {MaybeMergeableInitFragment} */ + (fragment).getEndContent(context); + if (endContent) { + endContents.push(endContent); + } + } + + concatSource.add(source); + for (const content of endContents.reverse()) { + concatSource.add(content); + } + return concatSource; + } + return source; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + + write(this.content); + write(this.stage); + write(this.position); + write(this.key); + write(this.endContent); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + + this.content = read(); + this.stage = read(); + this.position = read(); + this.key = read(); + this.endContent = read(); + } +} + +makeSerializable(InitFragment, "webpack/lib/InitFragment"); + +InitFragment.STAGE_CONSTANTS = 10; +InitFragment.STAGE_ASYNC_BOUNDARY = 20; +InitFragment.STAGE_HARMONY_EXPORTS = 30; +InitFragment.STAGE_HARMONY_IMPORTS = 40; +InitFragment.STAGE_PROVIDES = 50; +InitFragment.STAGE_ASYNC_DEPENDENCIES = 60; +InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = 70; + +module.exports = InitFragment; Index: frontend/node_modules/webpack/lib/JavascriptMetaInfoPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/JavascriptMetaInfoPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/JavascriptMetaInfoPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,79 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sergey Melyukov @smelukov +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const InnerGraph = require("./optimize/InnerGraph"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ + +const PLUGIN_NAME = "JavascriptMetaInfoPlugin"; + +class JavascriptMetaInfoPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + * @returns {void} + */ + const handler = (parser) => { + parser.hooks.call.for("eval").tap(PLUGIN_NAME, () => { + const buildInfo = + /** @type {BuildInfo} */ + (parser.state.module.buildInfo); + buildInfo.moduleConcatenationBailout = "eval()"; + const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state); + if (currentSymbol) { + InnerGraph.addUsage(parser.state, null, currentSymbol); + } else { + InnerGraph.bailout(parser.state); + } + }); + parser.hooks.finish.tap(PLUGIN_NAME, () => { + const buildInfo = + /** @type {BuildInfo} */ + (parser.state.module.buildInfo); + let topLevelDeclarations = buildInfo.topLevelDeclarations; + if (topLevelDeclarations === undefined) { + topLevelDeclarations = buildInfo.topLevelDeclarations = new Set(); + } + for (const name of parser.scope.definitions.asSet()) { + if (parser.isVariableDefined(name)) { + topLevelDeclarations.add(name); + } + } + }); + }; + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } +} + +module.exports = JavascriptMetaInfoPlugin; Index: frontend/node_modules/webpack/lib/LibraryTemplatePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/LibraryTemplatePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/LibraryTemplatePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,49 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const EnableLibraryPlugin = require("./library/EnableLibraryPlugin"); + +/** @typedef {import("../declarations/WebpackOptions").AuxiliaryComment} AuxiliaryComment */ +/** @typedef {import("../declarations/WebpackOptions").LibraryExport} LibraryExport */ +/** @typedef {import("../declarations/WebpackOptions").LibraryName} LibraryName */ +/** @typedef {import("../declarations/WebpackOptions").LibraryType} LibraryType */ +/** @typedef {import("../declarations/WebpackOptions").UmdNamedDefine} UmdNamedDefine */ +/** @typedef {import("./Compiler")} Compiler */ + +// TODO webpack 6 remove +class LibraryTemplatePlugin { + /** + * Creates an instance of LibraryTemplatePlugin. + * @param {LibraryName} name name of library + * @param {LibraryType} target type of library + * @param {UmdNamedDefine} umdNamedDefine setting this to true will name the UMD module + * @param {AuxiliaryComment} auxiliaryComment comment in the UMD wrapper + * @param {LibraryExport} exportProperty which export should be exposed as library + */ + constructor(name, target, umdNamedDefine, auxiliaryComment, exportProperty) { + this.library = { + type: target || "var", + name, + umdNamedDefine, + auxiliaryComment, + export: exportProperty + }; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const { output } = compiler.options; + output.library = this.library; + new EnableLibraryPlugin(this.library.type).apply(compiler); + } +} + +module.exports = LibraryTemplatePlugin; Index: frontend/node_modules/webpack/lib/LoaderOptionsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/LoaderOptionsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/LoaderOptionsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,85 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); +const NormalModule = require("./NormalModule"); + +/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./ModuleFilenameHelpers").MatchObject} MatchObject */ + +/** + * Defines the loader context type used by this module. + * @template T + * @typedef {import("../declarations/LoaderContext").LoaderContext} LoaderContext + */ + +const PLUGIN_NAME = "LoaderOptionsPlugin"; + +class LoaderOptionsPlugin { + /** + * Creates an instance of LoaderOptionsPlugin. + * @param {LoaderOptionsPluginOptions & MatchObject} options options object + */ + constructor(options = {}) { + // If no options are set then generate empty options object + if (typeof options !== "object") options = {}; + if (!options.test) { + options.test = () => true; + } + /** @type {LoaderOptionsPluginOptions & MatchObject} */ + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => require("../schemas/plugins/LoaderOptionsPlugin.json"), + this.options, + { + name: "Loader Options Plugin", + baseDataPath: "options" + }, + (options) => + require("../schemas/plugins/LoaderOptionsPlugin.check")(options) + ); + }); + + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + NormalModule.getCompilationHooks(compilation).loader.tap( + PLUGIN_NAME, + (context, module) => { + const resource = module.resource; + if (!resource) return; + const i = resource.indexOf("?"); + if ( + ModuleFilenameHelpers.matchObject( + this.options, + i < 0 ? resource : resource.slice(0, i) + ) + ) { + for (const key of Object.keys(this.options)) { + if (key === "include" || key === "exclude" || key === "test") { + continue; + } + + /** @type {LoaderContext & Record} */ + (context)[key] = this.options[key]; + } + } + } + ); + }); + } +} + +module.exports = LoaderOptionsPlugin; Index: frontend/node_modules/webpack/lib/LoaderTargetPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/LoaderTargetPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/LoaderTargetPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,40 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const NormalModule = require("./NormalModule"); + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "LoaderTargetPlugin"; + +class LoaderTargetPlugin { + /** + * Creates an instance of LoaderTargetPlugin. + * @param {string} target the target + */ + constructor(target) { + this.target = target; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + NormalModule.getCompilationHooks(compilation).loader.tap( + PLUGIN_NAME, + (loaderContext) => { + loaderContext.target = this.target; + } + ); + }); + } +} + +module.exports = LoaderTargetPlugin; Index: frontend/node_modules/webpack/lib/MainTemplate.js =================================================================== --- frontend/node_modules/webpack/lib/MainTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/MainTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,386 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const { SyncWaterfallHook } = require("tapable"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const memoize = require("./util/memoize"); + +/** @typedef {import("tapable").Tap} Tap */ +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */ +/** @typedef {import("./ModuleTemplate")} ModuleTemplate */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("./Compilation").InterpolatedPathAndAssetInfo} InterpolatedPathAndAssetInfo */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./DependencyTemplates")} DependencyTemplates */ +/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderBootstrapContext} RenderBootstrapContext */ +/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */ +/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */ +/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */ +/** @typedef {import("./TemplatedPathPlugin").PathData} PathData */ +/** + * Defines the if set type used by this module. + * @template T + * @typedef {import("tapable").IfSet} IfSet + */ + +const getJavascriptModulesPlugin = memoize(() => + require("./javascript/JavascriptModulesPlugin") +); +const getJsonpTemplatePlugin = memoize(() => + require("./web/JsonpTemplatePlugin") +); +const getLoadScriptRuntimeModule = memoize(() => + require("./runtime/LoadScriptRuntimeModule") +); + +// TODO webpack 6 remove this class +class MainTemplate { + /** + * Creates an instance of MainTemplate. + * @param {OutputOptions} outputOptions output options for the MainTemplate + * @param {Compilation} compilation the compilation + */ + constructor(outputOptions, compilation) { + /** @type {OutputOptions} */ + this._outputOptions = outputOptions || {}; + this.hooks = Object.freeze({ + renderManifest: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(renderManifestEntries: RenderManifestEntry[], renderManifestOptions: RenderManifestOptions) => RenderManifestEntry[]} fn fn + */ + (options, fn) => { + compilation.hooks.renderManifest.tap( + options, + (entries, options) => { + if (!options.chunk.hasRuntime()) return entries; + return fn(entries, options); + } + ); + }, + "MainTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_RENDER_MANIFEST" + ) + }, + modules: { + tap: () => { + throw new Error( + "MainTemplate.hooks.modules has been removed (there is no replacement, please create an issue to request that)" + ); + } + }, + moduleObj: { + tap: () => { + throw new Error( + "MainTemplate.hooks.moduleObj has been removed (there is no replacement, please create an issue to request that)" + ); + } + }, + require: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(value: string, renderBootstrapContext: RenderBootstrapContext) => string} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .renderRequire.tap(options, fn); + }, + "MainTemplate.hooks.require is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderRequire instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE" + ) + }, + beforeStartup: { + tap: () => { + throw new Error( + "MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startupOnlyBefore instead)" + ); + } + }, + startup: { + tap: () => { + throw new Error( + "MainTemplate.hooks.startup has been removed (use RuntimeGlobals.startup instead)" + ); + } + }, + afterStartup: { + tap: () => { + throw new Error( + "MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startupOnlyAfter instead)" + ); + } + }, + render: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, chunk: Chunk, hash: string | undefined, moduleTemplate: ModuleTemplate, dependencyTemplates: DependencyTemplates) => Source} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .render.tap(options, (source, renderContext) => { + if ( + renderContext.chunkGraph.getNumberOfEntryModules( + renderContext.chunk + ) === 0 || + !renderContext.chunk.hasRuntime() + ) { + return source; + } + return fn( + source, + renderContext.chunk, + compilation.hash, + compilation.moduleTemplates.javascript, + compilation.dependencyTemplates + ); + }); + }, + "MainTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_RENDER" + ) + }, + renderWithEntry: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, chunk: Chunk, hash: string | undefined) => Source} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .render.tap(options, (source, renderContext) => { + if ( + renderContext.chunkGraph.getNumberOfEntryModules( + renderContext.chunk + ) === 0 || + !renderContext.chunk.hasRuntime() + ) { + return source; + } + return fn(source, renderContext.chunk, compilation.hash); + }); + }, + "MainTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_RENDER_WITH_ENTRY" + ) + }, + assetPath: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(value: string, path: PathData, assetInfo: AssetInfo | undefined) => string} fn fn + */ + (options, fn) => { + compilation.hooks.assetPath.tap(options, fn); + }, + "MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH" + ), + call: util.deprecate( + /** + * Handles the call callback for this hook. + * @param {TemplatePath} filename used to get asset path with hash + * @param {PathData} options context data + * @returns {string} interpolated path + */ + (filename, options) => compilation.getAssetPath(filename, options), + "MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH" + ) + }, + hash: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(hash: Hash) => void} fn fn + */ + (options, fn) => { + compilation.hooks.fullHash.tap(options, fn); + }, + "MainTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_HASH" + ) + }, + hashForChunk: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(hash: Hash, chunk: Chunk) => void} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .chunkHash.tap(options, (chunk, hash) => { + if (!chunk.hasRuntime()) return; + return fn(hash, chunk); + }); + }, + "MainTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK" + ) + }, + globalHashPaths: { + tap: util.deprecate( + () => {}, + "MainTemplate.hooks.globalHashPaths has been removed (it's no longer needed)", + "DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK" + ) + }, + globalHash: { + tap: util.deprecate( + () => {}, + "MainTemplate.hooks.globalHash has been removed (it's no longer needed)", + "DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK" + ) + }, + hotBootstrap: { + tap: () => { + throw new Error( + "MainTemplate.hooks.hotBootstrap has been removed (use your own RuntimeModule instead)" + ); + } + }, + + // for compatibility: + /** @type {SyncWaterfallHook<[string, Chunk, string, ModuleTemplate, DependencyTemplates]>} */ + bootstrap: new SyncWaterfallHook([ + "source", + "chunk", + "hash", + "moduleTemplate", + "dependencyTemplates" + ]), + /** @type {SyncWaterfallHook<[string, Chunk, string]>} */ + localVars: new SyncWaterfallHook(["source", "chunk", "hash"]), + /** @type {SyncWaterfallHook<[string, Chunk, string]>} */ + requireExtensions: new SyncWaterfallHook(["source", "chunk", "hash"]), + /** @type {SyncWaterfallHook<[string, Chunk, string, string]>} */ + requireEnsure: new SyncWaterfallHook([ + "source", + "chunk", + "hash", + "chunkIdExpression" + ]), + get jsonpScript() { + const hooks = + getLoadScriptRuntimeModule().getCompilationHooks(compilation); + return hooks.createScript; + }, + get linkPrefetch() { + const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation); + return hooks.linkPrefetch; + }, + get linkPreload() { + const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation); + return hooks.linkPreload; + } + }); + + this.renderCurrentHashCode = util.deprecate( + /** + * Handles the require ensure callback for this hook. + * @deprecated + * @param {string} hash the hash + * @param {number=} length length of the hash + * @returns {string} generated code + */ + (hash, length) => { + if (length) { + return `${RuntimeGlobals.getFullHash} ? ${ + RuntimeGlobals.getFullHash + }().slice(0, ${length}) : ${hash.slice(0, length)}`; + } + return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}() : ${hash}`; + }, + "MainTemplate.renderCurrentHashCode is deprecated (use RuntimeGlobals.getFullHash runtime function instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_RENDER_CURRENT_HASH_CODE" + ); + + this.getPublicPath = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {PathData} options context data + * @returns {string} interpolated path + */ (options) => + compilation.getAssetPath(compilation.outputOptions.publicPath, options), + "MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH" + ); + + this.getAssetPath = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {TemplatePath} path used to get asset path with hash + * @param {PathData} options context data + * @returns {string} interpolated path + */ + (path, options) => compilation.getAssetPath(path, options), + "MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH" + ); + + this.getAssetPathWithInfo = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {TemplatePath} path used to get asset path with hash + * @param {PathData} options context data + * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info + */ + (path, options) => compilation.getAssetPathWithInfo(path, options), + "MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO" + ); + } +} + +Object.defineProperty(MainTemplate.prototype, "requireFn", { + get: util.deprecate( + () => RuntimeGlobals.require, + `MainTemplate.requireFn is deprecated (use "${RuntimeGlobals.require}")`, + "DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN" + ) +}); + +Object.defineProperty(MainTemplate.prototype, "outputOptions", { + get: util.deprecate( + /** + * Returns output options. + * @this {MainTemplate} + * @returns {OutputOptions} output options + */ + function outputOptions() { + return this._outputOptions; + }, + "MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)", + "DEP_WEBPACK_MAIN_TEMPLATE_OUTPUT_OPTIONS" + ) +}); + +module.exports = MainTemplate; Index: frontend/node_modules/webpack/lib/ManifestPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ManifestPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ManifestPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,251 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Haijie Xie @hai-x +*/ + +"use strict"; + +const { RawSource } = require("webpack-sources"); +const Compilation = require("./Compilation"); +const HotUpdateChunk = require("./HotUpdateChunk"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Chunk").ChunkName} ChunkName */ +/** @typedef {import("./Chunk").ChunkId} ChunkId */ +/** @typedef {import("./Compilation").Asset} Asset */ +/** @typedef {import("./Compilation").AssetInfo} AssetInfo */ + +/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestPluginOptions} ManifestPluginOptions */ +/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestObject} ManifestObject */ +/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestEntrypoint} ManifestEntrypoint */ +/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestItem} ManifestItem */ + +/** @typedef {(item: ManifestItem) => boolean} Filter */ +/** @typedef {(manifest: ManifestObject) => ManifestObject} Generate */ +/** @typedef {(manifest: ManifestObject) => string} Serialize */ + +const PLUGIN_NAME = "ManifestPlugin"; + +/** + * Returns extname. + * @param {string} filename filename + * @returns {string} extname + */ +const extname = (filename) => { + const replaced = filename.replace(/\?.*/, ""); + const split = replaced.split("."); + const last = split.pop(); + if (!last) return ""; + return last && /^(?:gz|br|map)$/i.test(last) + ? `${split.pop()}.${last}` + : last; +}; + +const DEFAULT_PREFIX = "[publicpath]"; +const DEFAULT_FILENAME = "manifest.json"; + +class ManifestPlugin { + /** + * Creates an instance of ManifestPlugin. + * @param {ManifestPluginOptions} options options + */ + constructor(options = {}) { + /** @type {ManifestPluginOptions} */ + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => require("../schemas/plugins/ManifestPlugin.json"), + this.options, + { + name: "ManifestPlugin", + baseDataPath: "options" + }, + (options) => require("../schemas/plugins/ManifestPlugin.check")(options) + ); + }); + + const entrypoints = + this.options.entrypoints !== undefined ? this.options.entrypoints : true; + const serialize = + this.options.serialize || + ((manifest) => JSON.stringify(manifest, null, 2)); + + compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => { + compilation.hooks.processAssets.tap( + { + name: PLUGIN_NAME, + stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE + }, + () => { + const hashDigestLength = compilation.outputOptions.hashDigestLength; + const publicPath = compilation.getPath( + compilation.outputOptions.publicPath + ); + + /** + * Creates a hash reg exp. + * @param {string | string[]} value value + * @returns {RegExp} regexp to remove hash + */ + const createHashRegExp = (value) => + new RegExp( + `(?:\\.${Array.isArray(value) ? `(${value.join("|")})` : value})(?=\\.)`, + "gi" + ); + + /** + * Removes the provided name from the manifest plugin. + * @param {string} name name + * @param {AssetInfo | null} info asset info + * @returns {string} hash removed name + */ + const removeHash = (name, info) => { + // Handles hashes that match configured `hashDigestLength` + // i.e. index.XXXX.html -> index.html (html-webpack-plugin) + if (hashDigestLength <= 0) return name; + const reg = createHashRegExp(`[a-f0-9]{${hashDigestLength},32}`); + return name.replace(reg, ""); + }; + + /** + * Returns chunk name or chunk id. + * @param {Chunk} chunk chunk + * @returns {ChunkName | ChunkId} chunk name or chunk id + */ + const getName = (chunk) => { + if (chunk.name) return chunk.name; + + return chunk.id; + }; + + /** @type {ManifestObject} */ + let manifest = {}; + + if (entrypoints) { + /** @type {ManifestObject["entrypoints"]} */ + const entrypoints = {}; + + for (const [name, entrypoint] of compilation.entrypoints) { + /** @type {string[]} */ + const imports = []; + + for (const chunk of entrypoint.chunks) { + for (const file of chunk.files) { + const name = getName(chunk); + + imports.push(name ? `${name}.${extname(file)}` : file); + } + } + + /** @type {ManifestEntrypoint} */ + const item = { imports }; + const parents = entrypoint + .getParents() + .map((item) => /** @type {string} */ (item.name)); + + if (parents.length > 0) { + item.parents = parents; + } + + entrypoints[name] = item; + } + + manifest.entrypoints = entrypoints; + } + + /** @type {ManifestObject["assets"]} */ + const assets = {}; + + /** @type {Set} */ + const added = new Set(); + + /** + * Processes the provided file. + * @param {string} file file + * @param {string=} usedName usedName + * @returns {void} + */ + const handleFile = (file, usedName) => { + if (added.has(file)) return; + added.add(file); + + const asset = compilation.getAsset(file); + if (!asset) return; + const sourceFilename = asset.info.sourceFilename; + const name = + usedName || + sourceFilename || + // Fallback for unofficial plugins, just remove hash from filename + removeHash(file, asset.info); + + const prefix = (this.options.prefix || DEFAULT_PREFIX).replace( + /\[publicpath\]/gi, + () => (publicPath === "auto" ? "/" : publicPath) + ); + /** @type {ManifestItem} */ + const item = { file: prefix + file }; + + if (sourceFilename) { + item.src = sourceFilename; + } + + if (this.options.filter) { + const needKeep = this.options.filter(item); + + if (!needKeep) { + return; + } + } + + assets[name] = item; + }; + + for (const chunk of compilation.chunks) { + if (chunk instanceof HotUpdateChunk) continue; + + for (const auxiliaryFile of chunk.auxiliaryFiles) { + handleFile(auxiliaryFile); + } + + const name = getName(chunk); + + for (const file of chunk.files) { + handleFile(file, name ? `${name}.${extname(file)}` : file); + } + } + + for (const asset of compilation.getAssets()) { + if (asset.info.hotModuleReplacement) { + continue; + } + + handleFile(asset.name); + } + + manifest.assets = assets; + + if (this.options.generate) { + manifest = this.options.generate(manifest); + } + + compilation.emitAsset( + this.options.filename || DEFAULT_FILENAME, + new RawSource(serialize(manifest)), + { manifest: true } + ); + } + ); + }); + } +} + +module.exports = ManifestPlugin; Index: frontend/node_modules/webpack/lib/Module.js =================================================================== --- frontend/node_modules/webpack/lib/Module.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Module.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1463 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const ChunkGraph = require("./ChunkGraph"); +const DependenciesBlock = require("./DependenciesBlock"); +const ModuleGraph = require("./ModuleGraph"); +const { + JAVASCRIPT_TYPE, + UNKNOWN_TYPE +} = require("./ModuleSourceTypeConstants"); +const { JAVASCRIPT_TYPES } = require("./ModuleSourceTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const { first } = require("./util/SetHelpers"); +const { compareChunksById } = require("./util/comparators"); +const makeSerializable = require("./util/makeSerializable"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */ +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ +/** @typedef {import("./ChunkGroup")} ChunkGroup */ +/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */ +/** @typedef {import("./Compilation").UnsafeCacheData} UnsafeCacheData */ +/** @typedef {import("./ConcatenationScope")} ConcatenationScope */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("./DependencyTemplate").CssData} CssData */ +/** @typedef {import("./DependencyTemplates")} DependencyTemplates */ +/** @typedef {import("./ModuleSourceTypeConstants").AllTypes} AllTypes */ +/** @typedef {import("./FileSystemInfo")} FileSystemInfo */ +/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */ +/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */ +/** @typedef {import("./ModuleTypeConstants").ModuleTypes} ModuleTypes */ +/** @typedef {import("./ModuleGraph").OptimizationBailouts} OptimizationBailouts */ +/** @typedef {import("./ModuleProfile")} ModuleProfile */ +/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** + * Defines the init fragment type used by this module. + * @template T + * @typedef {import("./InitFragment")} InitFragment + */ +/** @typedef {import("./errors/WebpackError")} WebpackError */ +/** @typedef {import("./json/JsonData")} JsonData */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ +/** + * @template T + * @typedef {import("./util/SortableSet")} SortableSet + */ +/** @typedef {"namespace" | "default-only" | "default-with-named" | "dynamic"} ExportsType */ + +/** + * Defines the shared type used by this module. + * @template T + * @typedef {import("./util/LazySet")} LazySet + */ + +/** + * Defines the source context type used by this module. + * @typedef {object} SourceContext + * @property {DependencyTemplates} dependencyTemplates the dependency templates + * @property {RuntimeTemplate} runtimeTemplate the runtime template + * @property {ModuleGraph} moduleGraph the module graph + * @property {ChunkGraph} chunkGraph the chunk graph + * @property {RuntimeSpec} runtime the runtimes code should be generated for + * @property {string=} type the type of source that should be generated + */ + +/** @typedef {AllTypes} KnownSourceType */ +/** @typedef {KnownSourceType | string} SourceType */ +/** @typedef {ReadonlySet} SourceTypes */ + +/** @typedef {ReadonlySet} BasicSourceTypes */ + +// TODO webpack 6: compilation will be required in CodeGenerationContext +/** + * Defines the code generation context type used by this module. + * @typedef {object} CodeGenerationContext + * @property {DependencyTemplates} dependencyTemplates the dependency templates + * @property {RuntimeTemplate} runtimeTemplate the runtime template + * @property {ModuleGraph} moduleGraph the module graph + * @property {ChunkGraph} chunkGraph the chunk graph + * @property {RuntimeSpec} runtime the runtimes code should be generated for + * @property {RuntimeSpec[]} runtimes all runtimes code should be generated for + * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules + * @property {CodeGenerationResults | undefined} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that) + * @property {Compilation=} compilation the compilation + * @property {SourceTypes=} sourceTypes source types + */ + +/** + * Defines the concatenation bailout reason context type used by this module. + * @typedef {object} ConcatenationBailoutReasonContext + * @property {ModuleGraph} moduleGraph the module graph + * @property {ChunkGraph} chunkGraph the chunk graph + */ + +/** @typedef {Set} RuntimeRequirements */ +/** @typedef {ReadonlySet} ReadOnlyRuntimeRequirements */ + +/** + * Defines the all code generation schemas type used by this module. + * @typedef {object} AllCodeGenerationSchemas + * @property {Set} topLevelDeclarations top level declarations for javascript modules + * @property {InitFragment[]} chunkInitFragments chunk init fragments for javascript modules + * @property {{ javascript?: string, ["asset-url"]?: string }} url url for asset modules + * @property {string} filename a filename for asset modules + * @property {AssetInfo} assetInfo an asset info for asset modules + * @property {string} fullContentHash a full content hash for asset modules + * @property {[{ shareScope: string, initStage: number, init: string }]} share-init share-init for modules federation + */ + +/** + * Defines the code gen value type used by this module. + * @template {string} K + * @typedef {K extends (keyof AllCodeGenerationSchemas) ? AllCodeGenerationSchemas[K] : EXPECTED_ANY} CodeGenValue + */ + +/** + * Defines the code gen map overloads type used by this module. + * @typedef {object} CodeGenMapOverloads + * @property {(key: K) => CodeGenValue | undefined} get + * @property {(key: K, value: CodeGenValue) => CodeGenerationResultData} set + * @property {(key: K) => boolean} has + * @property {(key: K) => boolean} delete + */ + +/** + * Defines the code generation result data type used by this module. + * @typedef {Omit, "get" | "set" | "has" | "delete"> & CodeGenMapOverloads} CodeGenerationResultData + */ + +/** @typedef {Map} Sources */ + +/** + * Defines the code generation result type used by this module. + * @typedef {object} CodeGenerationResult + * @property {Sources} sources the resulting sources for all source types + * @property {CodeGenerationResultData=} data the resulting data for all source types + * @property {ReadOnlyRuntimeRequirements | null} runtimeRequirements the runtime requirements + * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided) + */ + +/** + * Defines the lib ident options type used by this module. + * @typedef {object} LibIdentOptions + * @property {string} context absolute context path to which lib ident is relative to + * @property {AssociatedObjectForCache=} associatedObjectForCache object for caching + */ + +/** + * Defines the known build meta type used by this module. + * @typedef {object} KnownBuildMeta + * @property {("default" | "namespace" | "flagged" | "dynamic")=} exportsType + * @property {(false | "redirect" | "redirect-warn")=} defaultObject + * @property {boolean=} strictHarmonyModule + * @property {boolean=} treatAsCommonJs + * @property {boolean=} async + * @property {boolean=} sideEffectFree + * @property {boolean=} isCssModule + * @property {boolean=} needIdInConcatenation + * @property {Record=} jsIncompatibleExports + * @property {Map>=} exportsFinalNameByRuntime + * @property {Map=} exportsSourceByRuntime + */ + +/** + * Defines the known build info type used by this module. + * @typedef {object} KnownBuildInfo + * @property {boolean=} cacheable + * @property {boolean=} parsed + * @property {boolean=} strict + * @property {string=} moduleArgument using in AMD + * @property {string=} exportsArgument using in AMD + * @property {string=} moduleConcatenationBailout using in CommonJs + * @property {boolean=} needCreateRequire using in APIPlugin + * @property {string=} resourceIntegrity using in HttpUriPlugin + * @property {FileSystemDependencies=} fileDependencies using in NormalModule + * @property {FileSystemDependencies=} contextDependencies using in NormalModule + * @property {FileSystemDependencies=} missingDependencies using in NormalModule + * @property {FileSystemDependencies=} buildDependencies using in NormalModule + * @property {ValueCacheVersions=} valueDependencies using in NormalModule + * @property {Record=} assets using in NormalModule + * @property {Map=} assetsInfo using in NormalModule + * @property {string=} hash using in NormalModule + * @property {(Snapshot | null)=} snapshot using in ContextModule + * @property {string=} fullContentHash for assets modules + * @property {string=} filename for assets modules + * @property {boolean=} dataUrl for assets modules + * @property {AssetInfo=} assetInfo for assets modules + * @property {boolean=} javascriptModule for external modules + * @property {boolean=} active for lazy compilation modules + * @property {CssData=} cssData for css modules + * @property {string=} charset for css modules (charset at-rule) + * @property {JsonData=} jsonData for json modules + * @property {Set=} topLevelDeclarations top level declaration names + */ + +/** @typedef {string | Set} ValueCacheVersion */ +/** @typedef {Map} ValueCacheVersions */ + +/** + * Defines the need build context type used by this module. + * @typedef {object} NeedBuildContext + * @property {Compilation} compilation + * @property {FileSystemInfo} fileSystemInfo + * @property {ValueCacheVersions} valueCacheVersions + */ + +/** @typedef {(err?: WebpackError | null, needBuild?: boolean) => void} NeedBuildCallback */ + +/** @typedef {(err?: WebpackError) => void} BuildCallback */ + +/** @typedef {KnownBuildMeta & Record} BuildMeta */ +/** @typedef {KnownBuildInfo & Record} BuildInfo */ + +/** + * Defines the factory meta type used by this module. + * @typedef {object} FactoryMeta + * @property {boolean=} sideEffectFree + */ + +const EMPTY_RESOLVE_OPTIONS = {}; + +let debugId = 1000; + +/** @type {SourceTypes} */ +const DEFAULT_TYPES_UNKNOWN = new Set([UNKNOWN_TYPE]); + +const deprecatedNeedRebuild = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {Module} module the module + * @param {NeedBuildContext} context context info + * @returns {boolean} true, when rebuild is needed + */ + (module, context) => + module.needRebuild( + context.fileSystemInfo.getDeprecatedFileTimestamps(), + context.fileSystemInfo.getDeprecatedContextTimestamps() + ), + "Module.needRebuild is deprecated in favor of Module.needBuild", + "DEP_WEBPACK_MODULE_NEED_REBUILD" +); + +/** @typedef {string} LibIdent */ +/** @typedef {string} NameForCondition */ + +/** @typedef {(requestShortener: RequestShortener) => string} OptimizationBailoutFunction */ + +class Module extends DependenciesBlock { + /** + * Creates an instance of Module. + * @param {ModuleTypes | ""} type the module type, when deserializing the type is not known and is an empty string + * @param {(string | null)=} context an optional context + * @param {(string | null)=} layer an optional layer in which the module is + */ + constructor(type, context = null, layer = null) { + super(); + + /** @type {ModuleTypes} */ + this.type = type; + /** @type {string | null} */ + this.context = context; + /** @type {string | null} */ + this.layer = layer; + /** @type {boolean} */ + this.needId = true; + + // Unique Id + /** @type {number} */ + this.debugId = debugId++; + + // Info from Factory + /** @type {ResolveOptions | undefined} */ + this.resolveOptions = EMPTY_RESOLVE_OPTIONS; + /** @type {FactoryMeta | undefined} */ + this.factoryMeta = undefined; + // TODO refactor this -> options object filled from Factory + // TODO webpack 6: use an enum + /** @type {boolean} */ + this.useSourceMap = false; + /** @type {boolean} */ + this.useSimpleSourceMap = false; + + // Is in hot context, i.e. HotModuleReplacementPlugin.js enabled + // TODO do we need hot here? + /** @type {boolean} */ + this.hot = false; + // Info from Build + /** @type {Error[] | undefined} */ + this._warnings = undefined; + /** @type {Error[] | undefined} */ + this._errors = undefined; + /** @type {BuildMeta | undefined} */ + this.buildMeta = undefined; + /** @type {BuildInfo | undefined} */ + this.buildInfo = undefined; + /** @type {Dependency[] | undefined} */ + this.presentationalDependencies = undefined; + /** @type {Dependency[] | undefined} */ + this.codeGenerationDependencies = undefined; + } + + // TODO remove in webpack 6 + // BACKWARD-COMPAT START + /** + * Returns the module id assigned by the chunk graph. + * @deprecated + * @returns {ModuleId | null} module id + */ + get id() { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.id", + "DEP_WEBPACK_MODULE_ID" + ).getModuleId(this); + } + + /** + * Updates the module id using the provided value. + * @deprecated + * @param {ModuleId} value value + */ + set id(value) { + if (value === "") { + this.needId = false; + return; + } + ChunkGraph.getChunkGraphForModule( + this, + "Module.id", + "DEP_WEBPACK_MODULE_ID" + ).setModuleId(this, value); + } + + /** + * Returns the hash of the module. + * @deprecated + * @returns {string} the hash of the module + */ + get hash() { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.hash", + "DEP_WEBPACK_MODULE_HASH" + ).getModuleHash(this, undefined); + } + + /** + * Returns the rendered hash of the module. + * @deprecated + * @returns {string} the shortened hash of the module + */ + get renderedHash() { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.renderedHash", + "DEP_WEBPACK_MODULE_RENDERED_HASH" + ).getRenderedModuleHash(this, undefined); + } + + /** + * @deprecated + * @returns {ModuleProfile | undefined} module profile + */ + get profile() { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.profile", + "DEP_WEBPACK_MODULE_PROFILE" + ).getProfile(this); + } + + /** + * @deprecated + * @param {ModuleProfile | undefined} value module profile + */ + set profile(value) { + ModuleGraph.getModuleGraphForModule( + this, + "Module.profile", + "DEP_WEBPACK_MODULE_PROFILE" + ).setProfile(this, value); + } + + /** + * Returns the pre-order index. + * @deprecated + * @returns {number | null} the pre order index + */ + get index() { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.index", + "DEP_WEBPACK_MODULE_INDEX" + ).getPreOrderIndex(this); + } + + /** + * Updates the pre-order index using the provided value. + * @deprecated + * @param {number} value the pre order index + */ + set index(value) { + ModuleGraph.getModuleGraphForModule( + this, + "Module.index", + "DEP_WEBPACK_MODULE_INDEX" + ).setPreOrderIndex(this, value); + } + + /** + * Returns the post-order index. + * @deprecated + * @returns {number | null} the post order index + */ + get index2() { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.index2", + "DEP_WEBPACK_MODULE_INDEX2" + ).getPostOrderIndex(this); + } + + /** + * Updates the post-order index using the provided value. + * @deprecated + * @param {number} value the post order index + */ + set index2(value) { + ModuleGraph.getModuleGraphForModule( + this, + "Module.index2", + "DEP_WEBPACK_MODULE_INDEX2" + ).setPostOrderIndex(this, value); + } + + /** + * Returns the depth. + * @deprecated + * @returns {number | null} the depth + */ + get depth() { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.depth", + "DEP_WEBPACK_MODULE_DEPTH" + ).getDepth(this); + } + + /** + * Updates the depth using the provided value. + * @deprecated + * @param {number} value the depth + */ + set depth(value) { + ModuleGraph.getModuleGraphForModule( + this, + "Module.depth", + "DEP_WEBPACK_MODULE_DEPTH" + ).setDepth(this, value); + } + + /** + * Returns the issuer. + * @deprecated + * @returns {Module | null | undefined} issuer + */ + get issuer() { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.issuer", + "DEP_WEBPACK_MODULE_ISSUER" + ).getIssuer(this); + } + + /** + * Updates the issuer using the provided value. + * @deprecated + * @param {Module | null} value issuer + */ + set issuer(value) { + ModuleGraph.getModuleGraphForModule( + this, + "Module.issuer", + "DEP_WEBPACK_MODULE_ISSUER" + ).setIssuer(this, value); + } + + /** + * @deprecated + * @returns {boolean | SortableSet | null} used exports + */ + get usedExports() { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.usedExports", + "DEP_WEBPACK_MODULE_USED_EXPORTS" + ).getUsedExports(this, undefined); + } + + /** + * Gets optimization bailout. + * @deprecated + * @returns {OptimizationBailouts} list + */ + get optimizationBailout() { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.optimizationBailout", + "DEP_WEBPACK_MODULE_OPTIMIZATION_BAILOUT" + ).getOptimizationBailout(this); + } + + /** + * @deprecated + * @returns {boolean} true when optional, otherwise false + */ + get optional() { + return this.isOptional( + ModuleGraph.getModuleGraphForModule( + this, + "Module.optional", + "DEP_WEBPACK_MODULE_OPTIONAL" + ) + ); + } + + /** + * Adds the provided chunk to the module. + * @deprecated + * @param {Chunk} chunk the chunk + * @returns {boolean} true, when the module was added + */ + addChunk(chunk) { + const chunkGraph = ChunkGraph.getChunkGraphForModule( + this, + "Module.addChunk", + "DEP_WEBPACK_MODULE_ADD_CHUNK" + ); + if (chunkGraph.isModuleInChunk(this, chunk)) return false; + chunkGraph.connectChunkAndModule(chunk, this); + return true; + } + + /** + * Removes the provided chunk from the module. + * @deprecated + * @param {Chunk} chunk the chunk + * @returns {void} + */ + removeChunk(chunk) { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.removeChunk", + "DEP_WEBPACK_MODULE_REMOVE_CHUNK" + ).disconnectChunkAndModule(chunk, this); + } + + /** + * Checks whether this module is in the provided chunk. + * @deprecated + * @param {Chunk} chunk the chunk + * @returns {boolean} true, when the module is in the chunk + */ + isInChunk(chunk) { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.isInChunk", + "DEP_WEBPACK_MODULE_IS_IN_CHUNK" + ).isModuleInChunk(this, chunk); + } + + /** + * @deprecated + * @returns {boolean} true when is entry module, otherwise false + */ + isEntryModule() { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.isEntryModule", + "DEP_WEBPACK_MODULE_IS_ENTRY_MODULE" + ).isEntryModule(this); + } + + /** + * @deprecated + * @returns {Chunk[]} chunks + */ + getChunks() { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.getChunks", + "DEP_WEBPACK_MODULE_GET_CHUNKS" + ).getModuleChunks(this); + } + + /** + * @deprecated + * @returns {number} number of chunks + */ + getNumberOfChunks() { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.getNumberOfChunks", + "DEP_WEBPACK_MODULE_GET_NUMBER_OF_CHUNKS" + ).getNumberOfModuleChunks(this); + } + + /** + * @deprecated + * @returns {Iterable} chunks + */ + get chunksIterable() { + return ChunkGraph.getChunkGraphForModule( + this, + "Module.chunksIterable", + "DEP_WEBPACK_MODULE_CHUNKS_ITERABLE" + ).getOrderedModuleChunksIterable(this, compareChunksById); + } + + /** + * Checks whether this module provides the specified export. + * @deprecated + * @param {string} exportName a name of an export + * @returns {boolean | null} true, if the export is provided why the module. + * null, if it's unknown. + * false, if it's not provided. + */ + isProvided(exportName) { + return ModuleGraph.getModuleGraphForModule( + this, + "Module.usedExports", + "DEP_WEBPACK_MODULE_USED_EXPORTS" + ).isExportProvided(this, exportName); + } + // BACKWARD-COMPAT END + + /** + * Gets exports argument. + * @returns {string} name of the exports argument + */ + get exportsArgument() { + return (this.buildInfo && this.buildInfo.exportsArgument) || "exports"; + } + + /** + * Gets module argument. + * @returns {string} name of the module argument + */ + get moduleArgument() { + return (this.buildInfo && this.buildInfo.moduleArgument) || "module"; + } + + /** + * Returns export type. + * @param {ModuleGraph} moduleGraph the module graph + * @param {boolean | undefined} strict the importing module is strict + * @returns {ExportsType} export type + * "namespace": Exports is already a namespace object. namespace = exports. + * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }. + * "default-only": Provide a namespace object with only default export. namespace = { default: exports } + * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports } + */ + getExportsType(moduleGraph, strict) { + switch (this.buildMeta && this.buildMeta.exportsType) { + case "flagged": + return strict ? "default-with-named" : "namespace"; + case "namespace": + return "namespace"; + case "default": + switch (/** @type {BuildMeta} */ (this.buildMeta).defaultObject) { + case "redirect": + return "default-with-named"; + case "redirect-warn": + return strict ? "default-only" : "default-with-named"; + default: + return "default-only"; + } + case "dynamic": { + if (strict) return "default-with-named"; + // Try to figure out value of __esModule by following reexports + const handleDefault = () => { + switch (/** @type {BuildMeta} */ (this.buildMeta).defaultObject) { + case "redirect": + case "redirect-warn": + return "default-with-named"; + default: + return "default-only"; + } + }; + const exportInfo = moduleGraph.getReadOnlyExportInfo( + this, + "__esModule" + ); + if (exportInfo.provided === false) { + return handleDefault(); + } + const target = exportInfo.getTarget(moduleGraph); + if ( + !target || + !target.export || + target.export.length !== 1 || + target.export[0] !== "__esModule" + ) { + return "dynamic"; + } + switch ( + target.module.buildMeta && + target.module.buildMeta.exportsType + ) { + case "flagged": + case "namespace": + return "namespace"; + case "default": + return handleDefault(); + default: + return "dynamic"; + } + } + default: + return strict ? "default-with-named" : "dynamic"; + } + } + + /** + * Adds presentational dependency. + * @param {Dependency} presentationalDependency dependency being tied to module. + * This is a Dependency without edge in the module graph. It's only for presentation. + * @returns {void} + */ + addPresentationalDependency(presentationalDependency) { + if (this.presentationalDependencies === undefined) { + this.presentationalDependencies = []; + } + this.presentationalDependencies.push(presentationalDependency); + } + + /** + * Adds code generation dependency. + * @param {Dependency} codeGenerationDependency dependency being tied to module. + * This is a Dependency where the code generation result of the referenced module is needed during code generation. + * The Dependency should also be added to normal dependencies via addDependency. + * @returns {void} + */ + addCodeGenerationDependency(codeGenerationDependency) { + if (this.codeGenerationDependencies === undefined) { + this.codeGenerationDependencies = []; + } + this.codeGenerationDependencies.push(codeGenerationDependency); + } + + /** + * Clear dependencies and blocks. + * @returns {void} + */ + clearDependenciesAndBlocks() { + if (this.presentationalDependencies !== undefined) { + this.presentationalDependencies.length = 0; + } + if (this.codeGenerationDependencies !== undefined) { + this.codeGenerationDependencies.length = 0; + } + super.clearDependenciesAndBlocks(); + } + + /** + * Adds the provided warning to the module. + * @param {Error} warning the warning + * @returns {void} + */ + addWarning(warning) { + if (this._warnings === undefined) { + this._warnings = []; + } + this._warnings.push(warning); + } + + /** + * Returns list of warnings if any. + * @returns {Error[] | undefined} list of warnings if any + */ + getWarnings() { + return this._warnings; + } + + /** + * Gets number of warnings. + * @returns {number} number of warnings + */ + getNumberOfWarnings() { + return this._warnings !== undefined ? this._warnings.length : 0; + } + + /** + * Adds the provided error to the module. + * @param {Error} error the error + * @returns {void} + */ + addError(error) { + if (this._errors === undefined) { + this._errors = []; + } + this._errors.push(error); + } + + /** + * Returns list of errors if any. + * @returns {Error[] | undefined} list of errors if any + */ + getErrors() { + return this._errors; + } + + /** + * Gets number of errors. + * @returns {number} number of errors + */ + getNumberOfErrors() { + return this._errors !== undefined ? this._errors.length : 0; + } + + /** + * removes all warnings and errors + * @returns {void} + */ + clearWarningsAndErrors() { + if (this._warnings !== undefined) { + this._warnings.length = 0; + } + if (this._errors !== undefined) { + this._errors.length = 0; + } + } + + /** + * Checks whether this module is optional. + * @param {ModuleGraph} moduleGraph the module graph + * @returns {boolean} true, if the module is optional + */ + isOptional(moduleGraph) { + let hasConnections = false; + for (const r of moduleGraph.getIncomingConnections(this)) { + if ( + !r.dependency || + !r.dependency.optional || + !r.isTargetActive(undefined) + ) { + return false; + } + hasConnections = true; + } + return hasConnections; + } + + /** + * Checks whether this module is accessible in chunk. + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {Chunk} chunk a chunk + * @param {Chunk=} ignoreChunk chunk to be ignored + * @returns {boolean} true, if the module is accessible from "chunk" when ignoring "ignoreChunk" + */ + isAccessibleInChunk(chunkGraph, chunk, ignoreChunk) { + // Check if module is accessible in ALL chunk groups + for (const chunkGroup of chunk.groupsIterable) { + if (!this.isAccessibleInChunkGroup(chunkGraph, chunkGroup)) return false; + } + return true; + } + + /** + * Checks whether this module is accessible in chunk group. + * @param {ChunkGraph} chunkGraph the chunk graph + * @param {ChunkGroup} chunkGroup a chunk group + * @param {Chunk=} ignoreChunk chunk to be ignored + * @returns {boolean} true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk" + */ + isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk) { + const queue = new Set([chunkGroup]); + + // Check if module is accessible from all items of the queue + queueFor: for (const cg of queue) { + // 1. If module is in one of the chunks of the group we can continue checking the next items + // because it's accessible. + for (const chunk of cg.chunks) { + if (chunk !== ignoreChunk && chunkGraph.isModuleInChunk(this, chunk)) { + continue queueFor; + } + } + // 2. If the chunk group is initial, we can break here because it's not accessible. + if (chunkGroup.isInitial()) return false; + // 3. Enqueue all parents because it must be accessible from ALL parents + for (const parent of chunkGroup.parentsIterable) queue.add(parent); + } + // When we processed through the whole list and we didn't bailout, the module is accessible + return true; + } + + /** + * Checks whether this module contains the chunk. + * @param {Chunk} chunk a chunk + * @param {ModuleGraph} moduleGraph the module graph + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {boolean} true, if the module has any reason why "chunk" should be included + */ + hasReasonForChunk(chunk, moduleGraph, chunkGraph) { + // check for each reason if we need the chunk + for (const [ + fromModule, + connections + ] of moduleGraph.getIncomingConnectionsByOriginModule(this)) { + if (!connections.some((c) => c.isTargetActive(chunk.runtime))) continue; + for (const originChunk of chunkGraph.getModuleChunksIterable( + /** @type {Module} */ (fromModule) + )) { + // return true if module this is not reachable from originChunk when ignoring chunk + if (!this.isAccessibleInChunk(chunkGraph, originChunk, chunk)) { + return true; + } + } + } + return false; + } + + /** + * Checks whether this module contains the module graph. + * @param {ModuleGraph} moduleGraph the module graph + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true if at least one other module depends on this module + */ + hasReasons(moduleGraph, runtime) { + for (const c of moduleGraph.getIncomingConnections(this)) { + if (c.isTargetActive(runtime)) return true; + } + return false; + } + + /** + * Returns a string representation. + * @returns {string} for debugging + */ + toString() { + return `Module[${this.debugId}: ${this.identifier()}]`; + } + + /** + * Checks whether the module needs to be rebuilt for the current build state. + * @param {NeedBuildContext} context context info + * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild + * @returns {void} + */ + needBuild(context, callback) { + callback( + null, + !this.buildMeta || + this.needRebuild === Module.prototype.needRebuild || + deprecatedNeedRebuild(this, context) + ); + } + + /** + * Checks whether it needs rebuild. + * @deprecated Use needBuild instead + * @param {Map} fileTimestamps timestamps of files + * @param {Map} contextTimestamps timestamps of directories + * @returns {boolean} true, if the module needs a rebuild + */ + needRebuild(fileTimestamps, contextTimestamps) { + return true; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash( + hash, + context = { + chunkGraph: ChunkGraph.getChunkGraphForModule( + this, + "Module.updateHash", + "DEP_WEBPACK_MODULE_UPDATE_HASH" + ), + runtime: undefined + } + ) { + const { chunkGraph, runtime } = context; + hash.update(chunkGraph.getModuleGraphHash(this, runtime)); + if (this.presentationalDependencies !== undefined) { + for (const dep of this.presentationalDependencies) { + dep.updateHash(hash, context); + } + } + super.updateHash(hash, context); + } + + /** + * Invalidates the cached state associated with this value. + * @returns {void} + */ + invalidateBuild() { + // should be overridden to support this feature + } + + /* istanbul ignore next */ + /** + * Returns the unique identifier used to reference this module. + * @abstract + * @returns {string} a unique identifier of the module + */ + identifier() { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /* istanbul ignore next */ + /** + * Returns a human-readable identifier for this module. + * @abstract + * @param {RequestShortener} requestShortener the request shortener + * @returns {string} a user readable identifier of the module + */ + readableIdentifier(requestShortener) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /* istanbul ignore next */ + /** + * Builds the module using the provided compilation context. + * @abstract + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {BuildCallback} callback callback function + * @returns {void} + */ + build(options, compilation, resolver, fs, callback) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /** + * Returns the source types this module can generate. + * @abstract + * @returns {SourceTypes} types available (do not mutate) + */ + getSourceTypes() { + // Better override this method to return the correct types + if (this.source === Module.prototype.source) { + return DEFAULT_TYPES_UNKNOWN; + } + return JAVASCRIPT_TYPES; + } + + /** + * Basic source types are high-level categories like javascript, css, webassembly, etc. + * We only have built-in knowledge about the javascript basic type here; other basic types may be + * added or changed over time by generators and do not need to be handled or detected here. + * + * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init" + * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS. + * @returns {BasicSourceTypes} types available (do not mutate) + */ + getSourceBasicTypes() { + return this.getSourceTypes(); + } + + /** + * Returns generated source. + * @abstract + * @deprecated Use codeGeneration() instead + * @param {DependencyTemplates} dependencyTemplates the dependency templates + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @param {SourceType=} type the type of source that should be generated + * @returns {Source} generated source + */ + source(dependencyTemplates, runtimeTemplate, type = JAVASCRIPT_TYPE) { + if (this.codeGeneration === Module.prototype.codeGeneration) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + const chunkGraph = ChunkGraph.getChunkGraphForModule( + this, + "Module.source() is deprecated. Use Compilation.codeGenerationResults.getSource(module, runtime, type) instead", + "DEP_WEBPACK_MODULE_SOURCE" + ); + /** @type {CodeGenerationContext} */ + const codeGenContext = { + dependencyTemplates, + runtimeTemplate, + moduleGraph: chunkGraph.moduleGraph, + chunkGraph, + runtime: undefined, + runtimes: [], + codeGenerationResults: undefined + }; + const sources = this.codeGeneration(codeGenContext).sources; + + return /** @type {Source} */ ( + type + ? sources.get(type) + : sources.get(/** @type {SourceType} */ (first(this.getSourceTypes()))) + ); + } + + /* istanbul ignore next */ + /** + * Returns the estimated size for the requested source type. + * @abstract + * @param {string=} type the source type for which the size should be estimated + * @returns {number} the estimated size of the module (must be non-zero) + */ + size(type) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /** + * Gets the library identifier. + * @param {LibIdentOptions} options options + * @returns {LibIdent | null} an identifier for library inclusion + */ + libIdent(options) { + return null; + } + + /** + * Returns the path used when matching this module against rule conditions. + * @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path) + */ + nameForCondition() { + return null; + } + + /** + * Returns the reason this module cannot be concatenated, when one exists. + * @param {ConcatenationBailoutReasonContext} context context + * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated + */ + getConcatenationBailoutReason(context) { + return `Module Concatenation is not implemented for ${this.constructor.name}`; + } + + /** + * Gets side effects connection state. + * @param {ModuleGraph} moduleGraph the module graph + * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only + */ + getSideEffectsConnectionState(moduleGraph) { + return true; + } + + /** + * Generates code and runtime requirements for this module. + * @param {CodeGenerationContext} context context for code generation + * @returns {CodeGenerationResult} result + */ + codeGeneration(context) { + // Best override this method + /** @type {Sources} */ + const sources = new Map(); + for (const type of this.getSourceTypes()) { + if (type !== UNKNOWN_TYPE) { + sources.set( + type, + this.source( + context.dependencyTemplates, + context.runtimeTemplate, + type + ) + ); + } + } + return { + sources, + runtimeRequirements: new Set([ + RuntimeGlobals.module, + RuntimeGlobals.exports, + RuntimeGlobals.require + ]) + }; + } + + /** + * Returns true if the module can be placed in the chunk. + * @param {Chunk} chunk the chunk which condition should be checked + * @param {Compilation} compilation the compilation + * @returns {boolean} true if the module can be placed in the chunk + */ + chunkCondition(chunk, compilation) { + return true; + } + + hasChunkCondition() { + return this.chunkCondition !== Module.prototype.chunkCondition; + } + + /** + * Assuming this module is in the cache. Update the (cached) module with + * the fresh module from the factory. Usually updates internal references + * and properties. + * @param {Module} module fresh module + * @returns {void} + */ + updateCacheModule(module) { + this.type = module.type; + this.layer = module.layer; + this.context = module.context; + this.factoryMeta = module.factoryMeta; + this.resolveOptions = module.resolveOptions; + } + + /** + * Module should be unsafe cached. Get data that's needed for that. + * This data will be passed to restoreFromUnsafeCache later. + * @returns {UnsafeCacheData} cached data + */ + getUnsafeCacheData() { + return { + factoryMeta: this.factoryMeta, + resolveOptions: this.resolveOptions + }; + } + + /** + * restore unsafe cache data + * @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData + * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching + */ + _restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) { + this.factoryMeta = unsafeCacheData.factoryMeta; + this.resolveOptions = unsafeCacheData.resolveOptions; + } + + /** + * Assuming this module is in the cache. Remove internal references to allow freeing some memory. + */ + cleanupForCache() { + this.factoryMeta = undefined; + this.resolveOptions = undefined; + } + + /** + * Gets the original source. + * @returns {Source | null} the original source for the module before webpack transformation + */ + originalSource() { + return null; + } + + /** + * Adds the provided file dependencies to the module. + * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to + * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to + * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to + * @param {FileSystemDependencies} buildDependencies set where build dependencies are added to + */ + addCacheDependencies( + fileDependencies, + contextDependencies, + missingDependencies, + buildDependencies + ) {} + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + write(this.type); + write(this.layer); + write(this.context); + write(this.resolveOptions); + write(this.factoryMeta); + write(this.useSourceMap); + write(this.useSimpleSourceMap); + write(this.hot); + write( + this._warnings !== undefined && this._warnings.length === 0 + ? undefined + : this._warnings + ); + write( + this._errors !== undefined && this._errors.length === 0 + ? undefined + : this._errors + ); + write(this.buildMeta); + write(this.buildInfo); + write(this.presentationalDependencies); + write(this.codeGenerationDependencies); + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + this.type = read(); + this.layer = read(); + this.context = read(); + this.resolveOptions = read(); + this.factoryMeta = read(); + this.useSourceMap = read(); + this.useSimpleSourceMap = read(); + this.hot = read(); + this._warnings = read(); + this._errors = read(); + this.buildMeta = read(); + this.buildInfo = read(); + this.presentationalDependencies = read(); + this.codeGenerationDependencies = read(); + super.deserialize(context); + } + + // TODO remove in webpack 6 + /** + * Gets source basic types. + * @deprecated In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method. + * @param {Module} module the module + * @returns {ReturnType} the source types of the module + */ + static getSourceBasicTypes(module) { + if (!(module instanceof Module)) { + // https://github.com/webpack/webpack/issues/20597 + // fallback to javascript + return JAVASCRIPT_TYPES; + } + return module.getSourceBasicTypes(); + } +} + +makeSerializable(Module, "webpack/lib/Module"); + +// TODO remove in webpack 6 +Object.defineProperty(Module.prototype, "hasEqualsChunks", { + /** + * Gets has equals chunks. + * @deprecated + * @returns {EXPECTED_ANY} throw an error + */ + get() { + throw new Error( + "Module.hasEqualsChunks was renamed (use hasEqualChunks instead)" + ); + } +}); + +// TODO remove in webpack 6 +Object.defineProperty(Module.prototype, "isUsed", { + /** + * Returns throw an error. + * @deprecated + * @returns {EXPECTED_ANY} throw an error + */ + get() { + throw new Error( + "Module.isUsed was renamed (use getUsedName, isExportUsed or isModuleUsed instead)" + ); + } +}); + +// TODO remove in webpack 6 +Object.defineProperty(Module.prototype, "errors", { + /** + * Returns errors. + * @deprecated + * @returns {Error[]} errors + */ + get: util.deprecate( + /** + * Returns errors. + * @this {Module} + * @returns {Error[]} errors + */ + function errors() { + if (this._errors === undefined) { + this._errors = []; + } + return this._errors; + }, + "Module.errors was removed (use getErrors instead)", + "DEP_WEBPACK_MODULE_ERRORS" + ) +}); + +// TODO remove in webpack 6 +Object.defineProperty(Module.prototype, "warnings", { + /** + * Returns warnings. + * @deprecated + * @returns {Error[]} warnings + */ + get: util.deprecate( + /** + * Returns warnings. + * @this {Module} + * @returns {Error[]} warnings + */ + function warnings() { + if (this._warnings === undefined) { + this._warnings = []; + } + return this._warnings; + }, + "Module.warnings was removed (use getWarnings instead)", + "DEP_WEBPACK_MODULE_WARNINGS" + ) +}); + +// TODO remove in webpack 6 +Object.defineProperty(Module.prototype, "used", { + /** + * Returns throw an error. + * @deprecated + * @returns {EXPECTED_ANY} throw an error + */ + get() { + throw new Error( + "Module.used was refactored (use ModuleGraph.getUsedExports instead)" + ); + }, + /** + * Updates used using the provided value. + * @param {EXPECTED_ANY} value value + */ + set(value) { + throw new Error( + "Module.used was refactored (use ModuleGraph.setUsedExports instead)" + ); + } +}); + +module.exports = Module; Index: frontend/node_modules/webpack/lib/ModuleFactory.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,62 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Module")} Module */ + +/** + * Defines the module factory result type used by this module. + * @typedef {object} ModuleFactoryResult + * @property {Module=} module the created module or unset if no module was created + * @property {Set=} fileDependencies + * @property {Set=} contextDependencies + * @property {Set=} missingDependencies + * @property {boolean=} cacheable allow to use the unsafe cache + */ + +/** @typedef {string | null} IssuerLayer */ + +/** + * Defines the module factory create data context info type used by this module. + * @typedef {object} ModuleFactoryCreateDataContextInfo + * @property {string} issuer + * @property {IssuerLayer} issuerLayer + * @property {string=} compiler + */ + +/** + * Defines the module factory create data type used by this module. + * @typedef {object} ModuleFactoryCreateData + * @property {ModuleFactoryCreateDataContextInfo} contextInfo + * @property {ResolveOptions=} resolveOptions + * @property {string} context + * @property {Dependency[]} dependencies + */ + +/** + * Represents the module factory runtime component. + * @typedef {(err?: Error | null, result?: ModuleFactoryResult) => void} ModuleFactoryCallback + */ + +class ModuleFactory { + /* istanbul ignore next */ + /** + * Processes the provided data. + * @abstract + * @param {ModuleFactoryCreateData} data data object + * @param {ModuleFactoryCallback} callback callback + * @returns {void} + */ + create(data, callback) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } +} + +module.exports = ModuleFactory; Index: frontend/node_modules/webpack/lib/ModuleFilenameHelpers.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleFilenameHelpers.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleFilenameHelpers.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,391 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const NormalModule = require("./NormalModule"); +const { DEFAULTS } = require("./config/defaults"); +const createHash = require("./util/createHash"); +const memoize = require("./util/memoize"); + +/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./RequestShortener")} RequestShortener */ + +/** @typedef {(str: string) => boolean} MatcherFn */ +/** @typedef {string | RegExp | MatcherFn | (string | RegExp | MatcherFn)[]} Matcher */ +/** @typedef {{ test?: Matcher, include?: Matcher, exclude?: Matcher }} MatchObject */ + +const ModuleFilenameHelpers = module.exports; + +// TODO webpack 6: consider removing these +ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]"; +ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE = + /\[all-?loaders\]\[resource\]/gi; +ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]"; +ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi; +ModuleFilenameHelpers.RESOURCE = "[resource]"; +ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi; +ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]"; +// cSpell:words olute +ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH = + /\[abs(olute)?-?resource-?path\]/gi; +ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]"; +ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi; +ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]"; +ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi; +ModuleFilenameHelpers.LOADERS = "[loaders]"; +ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi; +ModuleFilenameHelpers.QUERY = "[query]"; +ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi; +ModuleFilenameHelpers.ID = "[id]"; +ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi; +ModuleFilenameHelpers.HASH = "[hash]"; +ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi; +ModuleFilenameHelpers.NAMESPACE = "[namespace]"; +ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi; + +/** @typedef {() => string} ReturnStringCallback */ + +/** + * Returns a function that returns the part of the string after the token + * @param {ReturnStringCallback} strFn the function to get the string + * @param {string} token the token to search for + * @returns {ReturnStringCallback} a function that returns the part of the string after the token + */ +const getAfter = (strFn, token) => () => { + const str = strFn(); + const idx = str.indexOf(token); + return idx < 0 ? "" : str.slice(idx); +}; + +/** + * Returns a function that returns the part of the string before the token + * @param {ReturnStringCallback} strFn the function to get the string + * @param {string} token the token to search for + * @returns {ReturnStringCallback} a function that returns the part of the string before the token + */ +const getBefore = (strFn, token) => () => { + const str = strFn(); + const idx = str.lastIndexOf(token); + return idx < 0 ? "" : str.slice(0, idx); +}; + +/** + * Returns a function that returns a hash of the string + * @param {ReturnStringCallback} strFn the function to get the string + * @param {HashFunction=} hashFunction the hash function to use + * @returns {ReturnStringCallback} a function that returns the hash of the string + */ +const getHash = + (strFn, hashFunction = DEFAULTS.HASH_FUNCTION) => + () => { + const hash = createHash(hashFunction); + hash.update(strFn()); + const digest = hash.digest("hex"); + return digest.slice(0, 4); + }; + +/** + * Returns the lazy access object. + * @template T + * Returns a lazy object. The object is lazy in the sense that the properties are + * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key. + * @param {Record T>} obj the object to convert to a lazy access object + * @returns {Record} the lazy access object + */ +const lazyObject = (obj) => { + const newObj = /** @type {Record} */ ({}); + for (const key of Object.keys(obj)) { + const fn = obj[key]; + Object.defineProperty(newObj, key, { + get: () => fn(), + set: (v) => { + Object.defineProperty(newObj, key, { + value: v, + enumerable: true, + writable: true + }); + }, + enumerable: true, + configurable: true + }); + } + return newObj; +}; + +const SQUARE_BRACKET_TAG_REGEXP = /\[\\*([\w-]+)\\*\]/g; +/** + * Defines the module filename template context type used by this module. + * @typedef {object} ModuleFilenameTemplateContext + * @property {string} identifier the identifier of the module + * @property {string} shortIdentifier the shortened identifier of the module + * @property {string} resource the resource of the module request + * @property {string} resourcePath the resource path of the module request + * @property {string} absoluteResourcePath the absolute resource path of the module request + * @property {string} loaders the loaders of the module request + * @property {string} allLoaders the all loaders of the module request + * @property {string} query the query of the module identifier + * @property {string} moduleId the module id of the module + * @property {string} hash the hash of the module identifier + * @property {string} namespace the module namespace + */ +/** @typedef {((context: ModuleFilenameTemplateContext) => string)} ModuleFilenameTemplateFunction */ +/** @typedef {string | ModuleFilenameTemplateFunction} ModuleFilenameTemplate */ + +/** + * Returns the filename. + * @param {Module | string} module the module + * @param {{ namespace?: string, moduleFilenameTemplate?: ModuleFilenameTemplate }} options options + * @param {{ requestShortener: RequestShortener, chunkGraph: ChunkGraph, hashFunction?: HashFunction }} contextInfo context info + * @returns {string} the filename + */ +ModuleFilenameHelpers.createFilename = ( + // eslint-disable-next-line default-param-last + module = "", + options, + { requestShortener, chunkGraph, hashFunction = DEFAULTS.HASH_FUNCTION } +) => { + const opts = { + namespace: "", + moduleFilenameTemplate: "", + ...(typeof options === "object" + ? options + : { + moduleFilenameTemplate: options + }) + }; + + /** @type {ReturnStringCallback} */ + let absoluteResourcePath; + /** @type {ReturnStringCallback} */ + let hash; + /** @type {ReturnStringCallback} */ + let identifier; + /** @type {ReturnStringCallback} */ + let moduleId; + /** @type {ReturnStringCallback} */ + let shortIdentifier; + if (typeof module === "string") { + shortIdentifier = + /** @type {ReturnStringCallback} */ + (memoize(() => requestShortener.shorten(module))); + identifier = shortIdentifier; + moduleId = () => ""; + absoluteResourcePath = () => + /** @type {string} */ (module.split("!").pop()); + hash = getHash(identifier, hashFunction); + } else { + shortIdentifier = memoize(() => + module.readableIdentifier(requestShortener) + ); + identifier = + /** @type {ReturnStringCallback} */ + (memoize(() => requestShortener.shorten(module.identifier()))); + moduleId = + /** @type {ReturnStringCallback} */ + (() => chunkGraph.getModuleId(module)); + absoluteResourcePath = () => + module instanceof NormalModule + ? module.resource + : /** @type {string} */ (module.identifier().split("!").pop()); + hash = getHash(identifier, hashFunction); + } + const resource = + /** @type {ReturnStringCallback} */ + (memoize(() => shortIdentifier().split("!").pop())); + + const loaders = getBefore(shortIdentifier, "!"); + const allLoaders = getBefore(identifier, "!"); + const query = getAfter(resource, "?"); + const resourcePath = () => { + const q = query().length; + return q === 0 ? resource() : resource().slice(0, -q); + }; + if (typeof opts.moduleFilenameTemplate === "function") { + return opts.moduleFilenameTemplate( + /** @type {ModuleFilenameTemplateContext} */ + ( + lazyObject({ + identifier, + shortIdentifier, + resource, + resourcePath: memoize(resourcePath), + absoluteResourcePath: memoize(absoluteResourcePath), + loaders: memoize(loaders), + allLoaders: memoize(allLoaders), + query: memoize(query), + moduleId: memoize(moduleId), + hash: memoize(hash), + namespace: () => opts.namespace + }) + ) + ); + } + + // TODO webpack 6: consider removing alternatives without dashes + /** @type {Map string>} */ + const replacements = new Map([ + ["identifier", identifier], + ["short-identifier", shortIdentifier], + ["resource", resource], + ["resource-path", resourcePath], + // cSpell:words resourcepath + ["resourcepath", resourcePath], + ["absolute-resource-path", absoluteResourcePath], + ["abs-resource-path", absoluteResourcePath], + // cSpell:words absoluteresource + ["absoluteresource-path", absoluteResourcePath], + // cSpell:words absresource + ["absresource-path", absoluteResourcePath], + // cSpell:words resourcepath + ["absolute-resourcepath", absoluteResourcePath], + // cSpell:words resourcepath + ["abs-resourcepath", absoluteResourcePath], + // cSpell:words absoluteresourcepath + ["absoluteresourcepath", absoluteResourcePath], + // cSpell:words absresourcepath + ["absresourcepath", absoluteResourcePath], + ["all-loaders", allLoaders], + // cSpell:words allloaders + ["allloaders", allLoaders], + ["loaders", loaders], + ["query", query], + ["id", moduleId], + ["hash", hash], + ["namespace", () => opts.namespace] + ]); + + // TODO webpack 6: consider removing weird double placeholders + return /** @type {string} */ (opts.moduleFilenameTemplate) + .replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]") + .replace( + ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE, + "[short-identifier]" + ) + .replace(SQUARE_BRACKET_TAG_REGEXP, (match, content) => { + if (content.length + 2 === match.length) { + const replacement = replacements.get(content.toLowerCase()); + if (replacement !== undefined) { + return replacement(); + } + } else if (match.startsWith("[\\") && match.endsWith("\\]")) { + return `[${match.slice(2, -2)}]`; + } + return match; + }); +}; + +/** + * Replaces duplicate items in an array with new values generated by a callback function. + * The callback function is called with the duplicate item, the index of the duplicate item, and the number of times the item has been replaced. + * The callback function should return the new value for the duplicate item. + * @template T + * @param {T[]} array the array with duplicates to be replaced + * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items + * @param {(firstElement: T, nextElement: T) => -1 | 0 | 1=} comparator optional comparator function to sort the duplicate items + * @returns {T[]} the array with duplicates replaced + * @example + * ```js + * const array = ["a", "b", "c", "a", "b", "a"]; + * const result = ModuleFilenameHelpers.replaceDuplicates(array, (item, index, count) => `${item}-${count}`); + * // result: ["a-1", "b-1", "c", "a-2", "b-2", "a-3"] + * ``` + */ +ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => { + const countMap = Object.create(null); + const posMap = Object.create(null); + + for (const [idx, item] of array.entries()) { + countMap[item] = countMap[item] || []; + countMap[item].push(idx); + posMap[item] = 0; + } + if (comparator) { + for (const item of Object.keys(countMap)) { + countMap[item].sort(comparator); + } + } + return array.map((item, i) => { + if (countMap[item].length > 1) { + if (comparator && countMap[item][0] === i) return item; + return fn(item, i, posMap[item]++); + } + return item; + }); +}; + +/** + * Tests if a string matches a RegExp or an array of RegExp. + * @param {string} str string to test + * @param {Matcher} test value which will be used to match against the string + * @returns {boolean} true, when the RegExp matches + * @example + * ```js + * ModuleFilenameHelpers.matchPart("foo.js", "foo"); // true + * ModuleFilenameHelpers.matchPart("foo.js", "foo.js"); // true + * ModuleFilenameHelpers.matchPart("foo.js", "foo."); // false + * ModuleFilenameHelpers.matchPart("foo.js", "foo*"); // false + * ModuleFilenameHelpers.matchPart("foo.js", "foo.*"); // true + * ModuleFilenameHelpers.matchPart("foo.js", /^foo/); // true + * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true + * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true + * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, /^bar/]); // true + * ModuleFilenameHelpers.matchPart("foo.js", [/^baz/, /^bar/]); // false + * ``` + */ +const matchPart = (str, test) => { + if (!test) return true; + if (test instanceof RegExp) { + return test.test(str); + } else if (typeof test === "string") { + return str.startsWith(test); + } else if (typeof test === "function") { + return test(str); + } + + return test.some((test) => matchPart(str, test)); +}; + +ModuleFilenameHelpers.matchPart = matchPart; + +/** + * Tests if a string matches a match object. The match object can have the following properties: + * - `test`: a RegExp or an array of RegExp + * - `include`: a RegExp or an array of RegExp + * - `exclude`: a RegExp or an array of RegExp + * + * The `test` property is tested first, then `include` and then `exclude`. + * @param {MatchObject} obj a match object to test against the string + * @param {string} str string to test against the matching object + * @returns {boolean} true, when the object matches + * @example + * ```js + * ModuleFilenameHelpers.matchObject({ test: "foo.js" }, "foo.js"); // true + * ModuleFilenameHelpers.matchObject({ test: /^foo/ }, "foo.js"); // true + * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "foo.js"); // true + * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "baz.js"); // false + * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "foo.js"); // true + * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "bar.js"); // false + * ModuleFilenameHelpers.matchObject({ include: /^foo/ }, "foo.js"); // true + * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "foo.js"); // true + * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "baz.js"); // false + * ModuleFilenameHelpers.matchObject({ exclude: "foo.js" }, "foo.js"); // false + * ModuleFilenameHelpers.matchObject({ exclude: [/^foo/, "bar"] }, "foo.js"); // false + * ``` + */ +ModuleFilenameHelpers.matchObject = (obj, str) => { + if (obj.test && !ModuleFilenameHelpers.matchPart(str, obj.test)) { + return false; + } + if (obj.include && !ModuleFilenameHelpers.matchPart(str, obj.include)) { + return false; + } + if (obj.exclude && ModuleFilenameHelpers.matchPart(str, obj.exclude)) { + return false; + } + return true; +}; Index: frontend/node_modules/webpack/lib/ModuleGraph.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleGraph.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleGraph.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1093 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const ExportsInfo = require("./ExportsInfo"); +const ModuleGraphConnection = require("./ModuleGraphConnection"); +const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency"); +const { ImportPhaseUtils } = require("./dependencies/ImportPhase"); +const SortableSet = require("./util/SortableSet"); +const WeakTupleMap = require("./util/WeakTupleMap"); +const { sortWithSourceOrder } = require("./util/comparators"); + +/** @typedef {import("./Compilation").ModuleMemCaches} ModuleMemCaches */ +/** @typedef {import("./DependenciesBlock")} DependenciesBlock */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */ +/** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleProfile")} ModuleProfile */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ +/** @typedef {import("./dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */ +/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */ +/** @typedef {import("./util/comparators").DependencySourceOrder} DependencySourceOrder */ + +/** + * Defines the optimization bailout function callback. + * @callback OptimizationBailoutFunction + * @param {RequestShortener} requestShortener + * @returns {string} + */ + +/** @type {Iterable} */ +const EMPTY_SET = new Set(); + +/** + * Gets connections by key. + * @template {Module | null | undefined} T + * @param {SortableSet} set input + * @param {(connection: ModuleGraphConnection) => T} getKey function to extract key from connection + * @returns {ReadonlyMap>} mapped by key + */ +const getConnectionsByKey = (set, getKey) => { + /** @type {Map} */ + const map = new Map(); + /** @type {T | 0} */ + let lastKey = 0; + /** @type {ModuleGraphConnection[] | undefined} */ + let lastList; + for (const connection of set) { + const key = getKey(connection); + if (lastKey === key) { + /** @type {ModuleGraphConnection[]} */ + (lastList).push(connection); + } else { + lastKey = key; + const list = map.get(key); + if (list !== undefined) { + lastList = list; + list.push(connection); + } else { + const list = [connection]; + lastList = list; + map.set(key, list); + } + } + } + return map; +}; + +/** + * Gets connections by origin module. + * @param {SortableSet} set input + * @returns {ReadonlyMap>} mapped by origin module + */ +const getConnectionsByOriginModule = (set) => + getConnectionsByKey(set, (connection) => connection.originModule); + +/** + * Gets connections by module. + * @param {SortableSet} set input + * @returns {ReadonlyMap>} mapped by module + */ +const getConnectionsByModule = (set) => + getConnectionsByKey(set, (connection) => connection.module); + +/** @typedef {SortableSet} IncomingConnections */ +/** @typedef {SortableSet} OutgoingConnections */ +/** @typedef {Module | null | undefined} Issuer */ +/** @typedef {(string | OptimizationBailoutFunction)[]} OptimizationBailouts */ + +class ModuleGraphModule { + constructor() { + /** @type {IncomingConnections} */ + this.incomingConnections = new SortableSet(); + /** @type {OutgoingConnections | undefined} */ + this.outgoingConnections = undefined; + /** @type {Issuer} */ + this.issuer = undefined; + /** @type {OptimizationBailouts} */ + this.optimizationBailout = []; + /** @type {ExportsInfo} */ + this.exports = new ExportsInfo(); + /** @type {number | null} */ + this.preOrderIndex = null; + /** @type {number | null} */ + this.postOrderIndex = null; + /** @type {number | null} */ + this.depth = null; + /** @type {ModuleProfile | undefined} */ + this.profile = undefined; + /** @type {boolean} */ + this.async = false; + /** @type {ModuleGraphConnection[] | undefined} */ + this._unassignedConnections = undefined; + } +} + +/** @typedef {(moduleGraphConnection: ModuleGraphConnection) => boolean} FilterConnection */ + +/** @typedef {EXPECTED_OBJECT} MetaKey */ + +/** @typedef {import("./dependencies/CommonJsExportRequireDependency").idsSymbol} CommonJsExportRequireDependencyIDsSymbol */ +/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency").idsSymbol} HarmonyImportSpecifierDependencyIDsSymbol */ +/** @typedef {import("./dependencies/HarmonyExportImportedSpecifierDependency").idsSymbol} HarmonyExportImportedSpecifierDependencyIDsSymbol */ + +/** + * Defines the known meta type used by this module. + * @typedef {object} KnownMeta + * @property {Map=} importVarMap + * @property {Map=} deferredImportVarMap + */ + +/** @typedef {KnownMeta & Record & Record} Meta */ + +class ModuleGraph { + constructor() { + /** + * @type {WeakMap} + * @private + */ + this._dependencyMap = new WeakMap(); + /** + * @type {Map} + * @private + */ + this._moduleMap = new Map(); + /** + * @type {WeakMap} + * @private + */ + this._metaMap = new WeakMap(); + /** + * @type {WeakTupleMap | undefined} + * @private + */ + this._cache = undefined; + /** + * @type {ModuleMemCaches | undefined} + * @private + */ + this._moduleMemCaches = undefined; + + /** + * @type {string | undefined} + * @private + */ + this._cacheStage = undefined; + + /** + * @type {WeakMap} + * @private + */ + this._dependencySourceOrderMap = new WeakMap(); + + /** + * @type {Set} + * @private + */ + this._modulesNeedingSort = new Set(); + } + + /** + * Get module graph module. + * @param {Module} module the module + * @returns {ModuleGraphModule} the internal module + */ + _getModuleGraphModule(module) { + let mgm = this._moduleMap.get(module); + if (mgm === undefined) { + mgm = new ModuleGraphModule(); + this._moduleMap.set(module, mgm); + } + return mgm; + } + + /** + * Updates parents using the provided dependency. + * @param {Dependency} dependency the dependency + * @param {DependenciesBlock} block parent block + * @param {Module} module parent module + * @param {number=} indexInBlock position in block + * @returns {void} + */ + setParents(dependency, block, module, indexInBlock = -1) { + dependency._parentDependenciesBlockIndex = indexInBlock; + dependency._parentDependenciesBlock = block; + dependency._parentModule = module; + } + + /** + * Sets parent dependencies block index. + * @param {Dependency} dependency the dependency + * @param {number} index the index + * @returns {void} + */ + setParentDependenciesBlockIndex(dependency, index) { + dependency._parentDependenciesBlockIndex = index; + } + + /** + * Gets parent module. + * @param {Dependency} dependency the dependency + * @returns {Module | undefined} parent module + */ + getParentModule(dependency) { + return dependency._parentModule; + } + + /** + * Returns parent block. + * @param {Dependency} dependency the dependency + * @returns {DependenciesBlock | undefined} parent block + */ + getParentBlock(dependency) { + return dependency._parentDependenciesBlock; + } + + /** + * Gets parent block index. + * @param {Dependency} dependency the dependency + * @returns {number} index + */ + getParentBlockIndex(dependency) { + return dependency._parentDependenciesBlockIndex; + } + + /** + * Sets resolved module. + * @param {Module | null} originModule the referencing module + * @param {Dependency} dependency the referencing dependency + * @param {Module} module the referenced module + * @returns {void} + */ + setResolvedModule(originModule, dependency, module) { + const connection = new ModuleGraphConnection( + originModule, + dependency, + module, + undefined, + dependency.weak, + dependency.getCondition(this) + ); + const connections = this._getModuleGraphModule(module).incomingConnections; + connections.add(connection); + if (originModule) { + const mgm = this._getModuleGraphModule(originModule); + if (mgm._unassignedConnections === undefined) { + mgm._unassignedConnections = []; + } + mgm._unassignedConnections.push(connection); + if (mgm.outgoingConnections === undefined) { + mgm.outgoingConnections = new SortableSet(); + } + mgm.outgoingConnections.add(connection); + } else { + this._dependencyMap.set(dependency, connection); + } + } + + /** + * Updates module using the provided dependency. + * @param {Dependency} dependency the referencing dependency + * @param {Module} module the referenced module + * @returns {void} + */ + updateModule(dependency, module) { + const connection = + /** @type {ModuleGraphConnection} */ + (this.getConnection(dependency)); + if (connection.module === module) return; + const newConnection = connection.clone(); + newConnection.module = module; + this._dependencyMap.set(dependency, newConnection); + connection.setActive(false); + const originMgm = this._getModuleGraphModule( + /** @type {Module} */ (connection.originModule) + ); + /** @type {OutgoingConnections} */ + (originMgm.outgoingConnections).add(newConnection); + const targetMgm = this._getModuleGraphModule(module); + targetMgm.incomingConnections.add(newConnection); + } + + /** + * Updates parent using the provided dependency. + * @param {Dependency} dependency the need update dependency + * @param {ModuleGraphConnection=} connection the target connection + * @param {Module=} parentModule the parent module + * @returns {void} + */ + updateParent(dependency, connection, parentModule) { + if (this._dependencySourceOrderMap.has(dependency)) { + return; + } + if (!connection || !parentModule) { + return; + } + const originDependency = connection.dependency; + + // src/index.js + // import { c } from "lib/c" -> c = 0 + // import { a, b } from "lib" -> a and b have the same source order -> a = b = 1 + // import { d } from "lib/d" -> d = 2 + const currentSourceOrder = + /** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ + (dependency).sourceOrder; + + // lib/index.js (reexport) + // import { a } from "lib/a" -> a = 0 + // import { b } from "lib/b" -> b = 1 + const originSourceOrder = + /** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ + (originDependency).sourceOrder; + if ( + typeof currentSourceOrder === "number" && + typeof originSourceOrder === "number" + ) { + // src/index.js + // import { c } from "lib/c" -> c = 0 + // import { a } from "lib/a" -> a = 1.0 = 1(main) + 0.0(sub) + // import { b } from "lib/b" -> b = 1.1 = 1(main) + 0.1(sub) + // import { d } from "lib/d" -> d = 2 + this._dependencySourceOrderMap.set(dependency, { + main: currentSourceOrder, + sub: originSourceOrder + }); + + // Save for later batch sorting + this._modulesNeedingSort.add(parentModule); + } + } + + /** + * Finish update parent. + * @returns {void} + */ + finishUpdateParent() { + if (this._modulesNeedingSort.size === 0) { + return; + } + for (const mod of this._modulesNeedingSort) { + // If dependencies like HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency have a SourceOrder, + // we sort based on it; otherwise, we preserve the original order. + sortWithSourceOrder( + mod.dependencies, + this._dependencySourceOrderMap, + (dep, index) => this.setParentDependenciesBlockIndex(dep, index) + ); + } + this._modulesNeedingSort.clear(); + } + + /** + * Removes connection. + * @param {Dependency} dependency the referencing dependency + * @returns {void} + */ + removeConnection(dependency) { + const connection = + /** @type {ModuleGraphConnection} */ + (this.getConnection(dependency)); + const targetMgm = this._getModuleGraphModule(connection.module); + targetMgm.incomingConnections.delete(connection); + const originMgm = this._getModuleGraphModule( + /** @type {Module} */ (connection.originModule) + ); + /** @type {OutgoingConnections} */ + (originMgm.outgoingConnections).delete(connection); + this._dependencyMap.set(dependency, null); + } + + /** + * Adds the provided dependency to the module graph. + * @param {Dependency} dependency the referencing dependency + * @param {string} explanation an explanation + * @returns {void} + */ + addExplanation(dependency, explanation) { + const connection = + /** @type {ModuleGraphConnection} */ + (this.getConnection(dependency)); + connection.addExplanation(explanation); + } + + /** + * Clones module attributes. + * @param {Module} sourceModule the source module + * @param {Module} targetModule the target module + * @returns {void} + */ + cloneModuleAttributes(sourceModule, targetModule) { + const oldMgm = this._getModuleGraphModule(sourceModule); + const newMgm = this._getModuleGraphModule(targetModule); + newMgm.postOrderIndex = oldMgm.postOrderIndex; + newMgm.preOrderIndex = oldMgm.preOrderIndex; + newMgm.depth = oldMgm.depth; + newMgm.exports = oldMgm.exports; + newMgm.async = oldMgm.async; + } + + /** + * Removes module attributes. + * @param {Module} module the module + * @returns {void} + */ + removeModuleAttributes(module) { + const mgm = this._getModuleGraphModule(module); + mgm.postOrderIndex = null; + mgm.preOrderIndex = null; + mgm.depth = null; + mgm.async = false; + } + + /** + * Removes all module attributes. + * @returns {void} + */ + removeAllModuleAttributes() { + for (const mgm of this._moduleMap.values()) { + mgm.postOrderIndex = null; + mgm.preOrderIndex = null; + mgm.depth = null; + mgm.async = false; + } + } + + /** + * Move module connections. + * @param {Module} oldModule the old referencing module + * @param {Module} newModule the new referencing module + * @param {FilterConnection} filterConnection filter predicate for replacement + * @returns {void} + */ + moveModuleConnections(oldModule, newModule, filterConnection) { + if (oldModule === newModule) return; + const oldMgm = this._getModuleGraphModule(oldModule); + const newMgm = this._getModuleGraphModule(newModule); + // Outgoing connections + const oldConnections = oldMgm.outgoingConnections; + if (oldConnections !== undefined) { + if (newMgm.outgoingConnections === undefined) { + newMgm.outgoingConnections = new SortableSet(); + } + const newConnections = newMgm.outgoingConnections; + for (const connection of oldConnections) { + if (filterConnection(connection)) { + connection.originModule = newModule; + newConnections.add(connection); + oldConnections.delete(connection); + } + } + } + // Incoming connections + const oldConnections2 = oldMgm.incomingConnections; + const newConnections2 = newMgm.incomingConnections; + for (const connection of oldConnections2) { + if (filterConnection(connection)) { + connection.module = newModule; + newConnections2.add(connection); + oldConnections2.delete(connection); + } + } + } + + /** + * Copies outgoing module connections. + * @param {Module} oldModule the old referencing module + * @param {Module} newModule the new referencing module + * @param {FilterConnection} filterConnection filter predicate for replacement + * @returns {void} + */ + copyOutgoingModuleConnections(oldModule, newModule, filterConnection) { + if (oldModule === newModule) return; + const oldMgm = this._getModuleGraphModule(oldModule); + const newMgm = this._getModuleGraphModule(newModule); + // Outgoing connections + const oldConnections = oldMgm.outgoingConnections; + if (oldConnections !== undefined) { + if (newMgm.outgoingConnections === undefined) { + newMgm.outgoingConnections = new SortableSet(); + } + const newConnections = newMgm.outgoingConnections; + for (const connection of oldConnections) { + if (filterConnection(connection)) { + const newConnection = connection.clone(); + newConnection.originModule = newModule; + newConnections.add(newConnection); + if (newConnection.module !== undefined) { + const otherMgm = this._getModuleGraphModule(newConnection.module); + otherMgm.incomingConnections.add(newConnection); + } + } + } + } + } + + /** + * Adds the provided module to the module graph. + * @param {Module} module the referenced module + * @param {string} explanation an explanation why it's referenced + * @returns {void} + */ + addExtraReason(module, explanation) { + const connections = this._getModuleGraphModule(module).incomingConnections; + connections.add(new ModuleGraphConnection(null, null, module, explanation)); + } + + /** + * Gets resolved module. + * @param {Dependency} dependency the dependency to look for a referenced module + * @returns {Module | null} the referenced module + */ + getResolvedModule(dependency) { + const connection = this.getConnection(dependency); + return connection !== undefined ? connection.resolvedModule : null; + } + + /** + * Returns the connection. + * @param {Dependency} dependency the dependency to look for a referenced module + * @returns {ModuleGraphConnection | undefined} the connection + */ + getConnection(dependency) { + const connection = this._dependencyMap.get(dependency); + if (connection === undefined) { + const module = this.getParentModule(dependency); + if (module !== undefined) { + const mgm = this._getModuleGraphModule(module); + if ( + mgm._unassignedConnections && + mgm._unassignedConnections.length !== 0 + ) { + /** @type {undefined | ModuleGraphConnection} */ + let foundConnection; + for (const connection of mgm._unassignedConnections) { + this._dependencyMap.set( + /** @type {Dependency} */ (connection.dependency), + connection + ); + if (connection.dependency === dependency) { + foundConnection = connection; + } + } + mgm._unassignedConnections.length = 0; + if (foundConnection !== undefined) { + return foundConnection; + } + } + } + this._dependencyMap.set(dependency, null); + return; + } + return connection === null ? undefined : connection; + } + + /** + * Returns the referenced module. + * @param {Dependency} dependency the dependency to look for a referenced module + * @returns {Module | null} the referenced module + */ + getModule(dependency) { + const connection = this.getConnection(dependency); + return connection !== undefined ? connection.module : null; + } + + /** + * Returns the referencing module. + * @param {Dependency} dependency the dependency to look for a referencing module + * @returns {Module | null} the referencing module + */ + getOrigin(dependency) { + const connection = this.getConnection(dependency); + return connection !== undefined ? connection.originModule : null; + } + + /** + * Gets resolved origin. + * @param {Dependency} dependency the dependency to look for a referencing module + * @returns {Module | null} the original referencing module + */ + getResolvedOrigin(dependency) { + const connection = this.getConnection(dependency); + return connection !== undefined ? connection.resolvedOriginModule : null; + } + + /** + * Gets incoming connections. + * @param {Module} module the module + * @returns {Iterable} reasons why a module is included + */ + getIncomingConnections(module) { + const connections = this._getModuleGraphModule(module).incomingConnections; + return connections; + } + + /** + * Gets outgoing connections. + * @param {Module} module the module + * @returns {Iterable} list of outgoing connections + */ + getOutgoingConnections(module) { + const connections = this._getModuleGraphModule(module).outgoingConnections; + return connections === undefined ? EMPTY_SET : connections; + } + + /** + * Gets incoming connections by origin module. + * @param {Module} module the module + * @returns {ReadonlyMap>} reasons why a module is included, in a map by source module + */ + getIncomingConnectionsByOriginModule(module) { + const connections = this._getModuleGraphModule(module).incomingConnections; + return connections.getFromUnorderedCache(getConnectionsByOriginModule); + } + + /** + * Gets outgoing connections by module. + * @param {Module} module the module + * @returns {ReadonlyMap> | undefined} connections to modules, in a map by module + */ + getOutgoingConnectionsByModule(module) { + const connections = this._getModuleGraphModule(module).outgoingConnections; + return connections === undefined + ? undefined + : connections.getFromUnorderedCache(getConnectionsByModule); + } + + /** + * Returns the module profile. + * @param {Module} module the module + * @returns {ModuleProfile | undefined} the module profile + */ + getProfile(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.profile; + } + + /** + * Updates profile using the provided module. + * @param {Module} module the module + * @param {ModuleProfile | undefined} profile the module profile + * @returns {void} + */ + setProfile(module, profile) { + const mgm = this._getModuleGraphModule(module); + mgm.profile = profile; + } + + /** + * Returns the issuer module. + * @param {Module} module the module + * @returns {Issuer} the issuer module + */ + getIssuer(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.issuer; + } + + /** + * Updates issuer using the provided module. + * @param {Module} module the module + * @param {Module | null} issuer the issuer module + * @returns {void} + */ + setIssuer(module, issuer) { + const mgm = this._getModuleGraphModule(module); + mgm.issuer = issuer; + } + + /** + * Sets issuer if unset. + * @param {Module} module the module + * @param {Module | null} issuer the issuer module + * @returns {void} + */ + setIssuerIfUnset(module, issuer) { + const mgm = this._getModuleGraphModule(module); + if (mgm.issuer === undefined) mgm.issuer = issuer; + } + + /** + * Gets optimization bailout. + * @param {Module} module the module + * @returns {OptimizationBailouts} optimization bailouts + */ + getOptimizationBailout(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.optimizationBailout; + } + + /** + * Gets provided exports. + * @param {Module} module the module + * @returns {null | true | ExportInfoName[]} the provided exports + */ + getProvidedExports(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.exports.getProvidedExports(); + } + + /** + * Checks whether this module graph is export provided. + * @param {Module} module the module + * @param {ExportInfoName | ExportInfoName[]} exportName a name of an export + * @returns {boolean | null} true, if the export is provided by the module. + * null, if it's unknown. + * false, if it's not provided. + */ + isExportProvided(module, exportName) { + const mgm = this._getModuleGraphModule(module); + const result = mgm.exports.isExportProvided(exportName); + return result === undefined ? null : result; + } + + /** + * Returns info about the exports. + * @param {Module} module the module + * @returns {ExportsInfo} info about the exports + */ + getExportsInfo(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.exports; + } + + /** + * Returns info about the export. + * @param {Module} module the module + * @param {string} exportName the export + * @returns {ExportInfo} info about the export + */ + getExportInfo(module, exportName) { + const mgm = this._getModuleGraphModule(module); + return mgm.exports.getExportInfo(exportName); + } + + /** + * Gets read only export info. + * @param {Module} module the module + * @param {string} exportName the export + * @returns {ExportInfo} info about the export (do not modify) + */ + getReadOnlyExportInfo(module, exportName) { + const mgm = this._getModuleGraphModule(module); + return mgm.exports.getReadOnlyExportInfo(exportName); + } + + /** + * Returns the used exports. + * @param {Module} module the module + * @param {RuntimeSpec} runtime the runtime + * @returns {false | true | SortableSet | null} the used exports + * false: module is not used at all. + * true: the module namespace/object export is used. + * SortableSet: these export names are used. + * empty SortableSet: module is used but no export. + * null: unknown, worst case should be assumed. + */ + getUsedExports(module, runtime) { + const mgm = this._getModuleGraphModule(module); + return mgm.exports.getUsedExports(runtime); + } + + /** + * Gets pre order index. + * @param {Module} module the module + * @returns {number | null} the index of the module + */ + getPreOrderIndex(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.preOrderIndex; + } + + /** + * Gets post order index. + * @param {Module} module the module + * @returns {number | null} the index of the module + */ + getPostOrderIndex(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.postOrderIndex; + } + + /** + * Sets pre order index. + * @param {Module} module the module + * @param {number} index the index of the module + * @returns {void} + */ + setPreOrderIndex(module, index) { + const mgm = this._getModuleGraphModule(module); + mgm.preOrderIndex = index; + } + + /** + * Sets pre order index if unset. + * @param {Module} module the module + * @param {number} index the index of the module + * @returns {boolean} true, if the index was set + */ + setPreOrderIndexIfUnset(module, index) { + const mgm = this._getModuleGraphModule(module); + if (mgm.preOrderIndex === null) { + mgm.preOrderIndex = index; + return true; + } + return false; + } + + /** + * Sets post order index. + * @param {Module} module the module + * @param {number} index the index of the module + * @returns {void} + */ + setPostOrderIndex(module, index) { + const mgm = this._getModuleGraphModule(module); + mgm.postOrderIndex = index; + } + + /** + * Sets post order index if unset. + * @param {Module} module the module + * @param {number} index the index of the module + * @returns {boolean} true, if the index was set + */ + setPostOrderIndexIfUnset(module, index) { + const mgm = this._getModuleGraphModule(module); + if (mgm.postOrderIndex === null) { + mgm.postOrderIndex = index; + return true; + } + return false; + } + + /** + * Returns the depth of the module. + * @param {Module} module the module + * @returns {number | null} the depth of the module + */ + getDepth(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.depth; + } + + /** + * Updates depth using the provided module. + * @param {Module} module the module + * @param {number} depth the depth of the module + * @returns {void} + */ + setDepth(module, depth) { + const mgm = this._getModuleGraphModule(module); + mgm.depth = depth; + } + + /** + * Sets depth if lower. + * @param {Module} module the module + * @param {number} depth the depth of the module + * @returns {boolean} true, if the depth was set + */ + setDepthIfLower(module, depth) { + const mgm = this._getModuleGraphModule(module); + if (mgm.depth === null || mgm.depth > depth) { + mgm.depth = depth; + return true; + } + return false; + } + + /** + * Checks whether this module graph is async. + * @param {Module} module the module + * @returns {boolean} true, if the module is async + */ + isAsync(module) { + const mgm = this._getModuleGraphModule(module); + return mgm.async; + } + + /** + * Checks whether this module graph is deferred. + * @param {Module} module the module + * @returns {boolean} true, if the module is used as a deferred module at least once + */ + isDeferred(module) { + if (this.isAsync(module)) return false; + const connections = this.getIncomingConnections(module); + for (const connection of connections) { + if ( + !connection.dependency || + !(connection.dependency instanceof HarmonyImportDependency) + ) { + continue; + } + if (ImportPhaseUtils.isDefer(connection.dependency.phase)) return true; + } + return false; + } + + /** + * Updates async using the provided module. + * @param {Module} module the module + * @returns {void} + */ + setAsync(module) { + const mgm = this._getModuleGraphModule(module); + mgm.async = true; + } + + /** + * Returns metadata. + * @param {MetaKey} thing any thing + * @returns {Meta} metadata + */ + getMeta(thing) { + let meta = this._metaMap.get(thing); + if (meta === undefined) { + meta = /** @type {Meta} */ (Object.create(null)); + this._metaMap.set(thing, meta); + } + return meta; + } + + /** + * Gets meta if existing. + * @param {MetaKey} thing any thing + * @returns {Meta | undefined} metadata + */ + getMetaIfExisting(thing) { + return this._metaMap.get(thing); + } + + /** + * Processes the provided cache stage. + * @param {string=} cacheStage a persistent stage name for caching + */ + freeze(cacheStage) { + this._cache = new WeakTupleMap(); + this._cacheStage = cacheStage; + } + + unfreeze() { + this._cache = undefined; + this._cacheStage = undefined; + } + + /** + * Returns computed value or cached. + * @template {EXPECTED_ANY[]} T + * @template R + * @param {(moduleGraph: ModuleGraph, ...args: T) => R} fn computer + * @param {T} args arguments + * @returns {R} computed value or cached + */ + cached(fn, ...args) { + if (this._cache === undefined) return fn(this, ...args); + return this._cache.provide(fn, ...args, () => fn(this, ...args)); + } + + /** + * Sets module mem caches. + * @param {ModuleMemCaches} moduleMemCaches mem caches for modules for better caching + */ + setModuleMemCaches(moduleMemCaches) { + this._moduleMemCaches = moduleMemCaches; + } + + /** + * Dependency cache provide. + * @template {Dependency} D + * @template {EXPECTED_ANY[]} ARGS + * @template R + * @param {D} dependency dependency + * @param {[...ARGS, (moduleGraph: ModuleGraph, dependency: D, ...args: ARGS) => R]} args arguments, last argument is a function called with moduleGraph, dependency, ...args + * @returns {R} computed value or cached + */ + dependencyCacheProvide(dependency, ...args) { + const fn = + /** @type {(moduleGraph: ModuleGraph, dependency: D, ...args: EXPECTED_ANY[]) => R} */ + (args.pop()); + if (this._moduleMemCaches && this._cacheStage) { + const memCache = this._moduleMemCaches.get( + /** @type {Module} */ + (this.getParentModule(dependency)) + ); + if (memCache !== undefined) { + return memCache.provide(dependency, this._cacheStage, ...args, () => + fn(this, dependency, ...args) + ); + } + } + if (this._cache === undefined) return fn(this, dependency, ...args); + return this._cache.provide(dependency, ...args, () => + fn(this, dependency, ...args) + ); + } + + // TODO remove in webpack 6 + /** + * Gets module graph for module. + * @deprecated + * @param {Module} module the module + * @param {string} deprecateMessage message for the deprecation message + * @param {string} deprecationCode code for the deprecation + * @returns {ModuleGraph} the module graph + */ + static getModuleGraphForModule(module, deprecateMessage, deprecationCode) { + const fn = deprecateMap.get(deprecateMessage); + if (fn) return fn(module); + const newFn = util.deprecate( + /** + * Handles the callback logic for this hook. + * @param {Module} module the module + * @returns {ModuleGraph} the module graph + */ + (module) => { + const moduleGraph = moduleGraphForModuleMap.get(module); + if (!moduleGraph) { + throw new Error( + `${ + deprecateMessage + }There was no ModuleGraph assigned to the Module for backward-compat (Use the new API)` + ); + } + return moduleGraph; + }, + `${deprecateMessage}: Use new ModuleGraph API`, + deprecationCode + ); + deprecateMap.set(deprecateMessage, newFn); + return newFn(module); + } + + // TODO remove in webpack 6 + /** + * Sets module graph for module. + * @deprecated + * @param {Module} module the module + * @param {ModuleGraph} moduleGraph the module graph + * @returns {void} + */ + static setModuleGraphForModule(module, moduleGraph) { + moduleGraphForModuleMap.set(module, moduleGraph); + } + + // TODO remove in webpack 6 + /** + * Clear module graph for module. + * @deprecated + * @param {Module} module the module + * @returns {void} + */ + static clearModuleGraphForModule(module) { + moduleGraphForModuleMap.delete(module); + } +} + +// TODO remove in webpack 6 +/** @type {WeakMap} */ +const moduleGraphForModuleMap = new WeakMap(); + +// TODO remove in webpack 6 +/** @type {Map ModuleGraph>} */ +const deprecateMap = new Map(); + +module.exports = ModuleGraph; +module.exports.ModuleGraphConnection = ModuleGraphConnection; Index: frontend/node_modules/webpack/lib/ModuleGraphConnection.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleGraphConnection.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleGraphConnection.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,208 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").GetConditionFn} GetConditionFn */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** + * Module itself is not connected, but transitive modules are connected transitively. + */ +const TRANSITIVE_ONLY = Symbol("transitive only"); + +/** + * While determining the active state, this flag is used to signal a circular connection. + */ +const CIRCULAR_CONNECTION = Symbol("circular connection"); + +/** @typedef {boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION} ConnectionState */ + +/** + * Adds connection states. + * @param {ConnectionState} a first + * @param {ConnectionState} b second + * @returns {ConnectionState} merged + */ +const addConnectionStates = (a, b) => { + if (a === true || b === true) return true; + if (a === false) return b; + if (b === false) return a; + if (a === TRANSITIVE_ONLY) return b; + if (b === TRANSITIVE_ONLY) return a; + return a; +}; + +/** + * Intersect connection states. + * @param {ConnectionState} a first + * @param {ConnectionState} b second + * @returns {ConnectionState} intersected + */ +const intersectConnectionStates = (a, b) => { + if (a === false || b === false) return false; + if (a === true) return b; + if (b === true) return a; + if (a === CIRCULAR_CONNECTION) return b; + if (b === CIRCULAR_CONNECTION) return a; + return a; +}; + +class ModuleGraphConnection { + /** + * Creates an instance of ModuleGraphConnection. + * @param {Module | null} originModule the referencing module + * @param {Dependency | null} dependency the referencing dependency + * @param {Module} module the referenced module + * @param {string=} explanation some extra detail + * @param {boolean=} weak the reference is weak + * @param {false | null | GetConditionFn=} condition condition for the connection + */ + constructor( + originModule, + dependency, + module, + explanation, + weak = false, + condition = undefined + ) { + /** @type {Module | null} */ + this.originModule = originModule; + /** @type {Module | null} */ + this.resolvedOriginModule = originModule; + /** @type {Dependency | null} */ + this.dependency = dependency; + /** @type {Module} */ + this.resolvedModule = module; + /** @type {Module} */ + this.module = module; + /** @type {boolean | undefined} */ + this.weak = weak; + /** @type {boolean} */ + this.conditional = Boolean(condition); + /** @type {boolean} */ + this._active = condition !== false; + /** @type {false | null | GetConditionFn | undefined} */ + this.condition = condition || undefined; + /** @type {Set | undefined} */ + this.explanations = undefined; + if (explanation) { + this.explanations = new Set(); + this.explanations.add(explanation); + } + } + + clone() { + const clone = new ModuleGraphConnection( + this.resolvedOriginModule, + this.dependency, + this.resolvedModule, + undefined, + this.weak, + this.condition + ); + clone.originModule = this.originModule; + clone.module = this.module; + clone.conditional = this.conditional; + clone._active = this._active; + if (this.explanations) clone.explanations = new Set(this.explanations); + return clone; + } + + /** + * Adds the provided condition to the module graph connection. + * @param {GetConditionFn} condition condition for the connection + * @returns {void} + */ + addCondition(condition) { + if (this.conditional) { + const old = + /** @type {GetConditionFn} */ + (this.condition); + /** @type {GetConditionFn} */ + (this.condition) = (c, r) => + intersectConnectionStates(old(c, r), condition(c, r)); + } else if (this._active) { + this.conditional = true; + this.condition = condition; + } + } + + /** + * Adds the provided explanation to the module graph connection. + * @param {string} explanation the explanation to add + * @returns {void} + */ + addExplanation(explanation) { + if (this.explanations === undefined) { + this.explanations = new Set(); + } + this.explanations.add(explanation); + } + + get explanation() { + if (this.explanations === undefined) return ""; + return [...this.explanations].join(" "); + } + + /** + * Checks whether this module graph connection is active. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, if the connection is active + */ + isActive(runtime) { + if (!this.conditional) return this._active; + + return ( + /** @type {GetConditionFn} */ (this.condition)(this, runtime) !== false + ); + } + + /** + * Checks whether this module graph connection is target active. + * @param {RuntimeSpec} runtime the runtime + * @returns {boolean} true, if the connection is active + */ + isTargetActive(runtime) { + if (!this.conditional) return this._active; + return ( + /** @type {GetConditionFn} */ (this.condition)(this, runtime) === true + ); + } + + /** + * Returns true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active. + * @param {RuntimeSpec} runtime the runtime + * @returns {ConnectionState} true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active + */ + getActiveState(runtime) { + if (!this.conditional) return this._active; + return /** @type {GetConditionFn} */ (this.condition)(this, runtime); + } + + /** + * Updates active using the provided value. + * @param {boolean} value active or not + * @returns {void} + */ + setActive(value) { + this.conditional = false; + this._active = value; + } +} + +/** @typedef {typeof TRANSITIVE_ONLY} TRANSITIVE_ONLY */ +/** @typedef {typeof CIRCULAR_CONNECTION} CIRCULAR_CONNECTION */ + +module.exports = ModuleGraphConnection; +module.exports.CIRCULAR_CONNECTION = /** @type {typeof CIRCULAR_CONNECTION} */ ( + CIRCULAR_CONNECTION +); +module.exports.TRANSITIVE_ONLY = /** @type {typeof TRANSITIVE_ONLY} */ ( + TRANSITIVE_ONLY +); +module.exports.addConnectionStates = addConnectionStates; Index: frontend/node_modules/webpack/lib/ModuleInfoHeaderPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleInfoHeaderPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleInfoHeaderPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,323 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { CachedSource, ConcatSource, RawSource } = require("webpack-sources"); +const { UsageState } = require("./ExportsInfo"); +const Template = require("./Template"); +const CssModulesPlugin = require("./css/CssModulesPlugin"); +const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./ExportsInfo")} ExportsInfo */ +/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").BuildMeta} BuildMeta */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./RequestShortener")} RequestShortener */ + +/** + * Join iterable with comma. + * @template T + * @param {Iterable} iterable iterable + * @returns {string} joined with comma + */ +const joinIterableWithComma = (iterable) => { + // This is more performant than Array.from().join(", ") + // as it doesn't create an array + let str = ""; + let first = true; + for (const item of iterable) { + if (first) { + first = false; + } else { + str += ", "; + } + str += item; + } + return str; +}; + +/** + * Print exports info to source. + * @param {ConcatSource} source output + * @param {string} indent spacing + * @param {ExportsInfo} exportsInfo data + * @param {ModuleGraph} moduleGraph moduleGraph + * @param {RequestShortener} requestShortener requestShortener + * @param {Set} alreadyPrinted deduplication set + * @returns {void} + */ +const printExportsInfoToSource = ( + source, + indent, + exportsInfo, + moduleGraph, + requestShortener, + alreadyPrinted = new Set() +) => { + const otherExportsInfo = exportsInfo.otherExportsInfo; + + let alreadyPrintedExports = 0; + + // determine exports to print + /** @type {ExportInfo[]} */ + const printedExports = []; + for (const exportInfo of exportsInfo.orderedExports) { + if (!alreadyPrinted.has(exportInfo)) { + alreadyPrinted.add(exportInfo); + printedExports.push(exportInfo); + } else { + alreadyPrintedExports++; + } + } + let showOtherExports = false; + if (!alreadyPrinted.has(otherExportsInfo)) { + alreadyPrinted.add(otherExportsInfo); + showOtherExports = true; + } else { + alreadyPrintedExports++; + } + + // print the exports + for (const exportInfo of printedExports) { + const target = exportInfo.getTarget(moduleGraph); + source.add( + `${Template.toComment( + `${indent}export ${JSON.stringify(exportInfo.name).slice( + 1, + -1 + )} [${exportInfo.getProvidedInfo()}] [${exportInfo.getUsedInfo()}] [${exportInfo.getRenameInfo()}]${ + target + ? ` -> ${target.module.readableIdentifier(requestShortener)}${ + target.export + ? ` .${target.export + .map((e) => JSON.stringify(e).slice(1, -1)) + .join(".")}` + : "" + }` + : "" + }` + )}\n` + ); + if (exportInfo.exportsInfo) { + printExportsInfoToSource( + source, + `${indent} `, + exportInfo.exportsInfo, + moduleGraph, + requestShortener, + alreadyPrinted + ); + } + } + + if (alreadyPrintedExports) { + source.add( + `${Template.toComment( + `${indent}... (${alreadyPrintedExports} already listed exports)` + )}\n` + ); + } + + if (showOtherExports) { + const target = otherExportsInfo.getTarget(moduleGraph); + if ( + target || + otherExportsInfo.provided !== false || + otherExportsInfo.getUsed(undefined) !== UsageState.Unused + ) { + const title = + printedExports.length > 0 || alreadyPrintedExports > 0 + ? "other exports" + : "exports"; + source.add( + `${Template.toComment( + `${indent}${title} [${otherExportsInfo.getProvidedInfo()}] [${otherExportsInfo.getUsedInfo()}]${ + target + ? ` -> ${target.module.readableIdentifier(requestShortener)}` + : "" + }` + )}\n` + ); + } + } +}; + +/** @typedef {{ header: RawSource | undefined, full: WeakMap }} CacheEntry */ +/** @type {WeakMap>} */ +const caches = new WeakMap(); + +const PLUGIN_NAME = "ModuleInfoHeaderPlugin"; + +class ModuleInfoHeaderPlugin { + /** + * Creates an instance of ModuleInfoHeaderPlugin. + * @param {boolean=} verbose add more information like exports, runtime requirements and bailouts + */ + constructor(verbose = true) { + /** @type {boolean} */ + this._verbose = verbose; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler + * @returns {void} + */ + apply(compiler) { + const { _verbose: verbose } = this; + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const javascriptHooks = + JavascriptModulesPlugin.getCompilationHooks(compilation); + javascriptHooks.renderModulePackage.tap( + PLUGIN_NAME, + ( + moduleSource, + module, + { chunk, chunkGraph, moduleGraph, runtimeTemplate } + ) => { + const { requestShortener } = runtimeTemplate; + /** @type {undefined | CacheEntry} */ + let cacheEntry; + let cache = caches.get(requestShortener); + if (cache === undefined) { + caches.set(requestShortener, (cache = new WeakMap())); + cache.set( + module, + (cacheEntry = { header: undefined, full: new WeakMap() }) + ); + } else { + cacheEntry = cache.get(module); + if (cacheEntry === undefined) { + cache.set( + module, + (cacheEntry = { header: undefined, full: new WeakMap() }) + ); + } else if (!verbose) { + const cachedSource = cacheEntry.full.get(moduleSource); + if (cachedSource !== undefined) return cachedSource; + } + } + const source = new ConcatSource(); + let header = cacheEntry.header; + if (header === undefined) { + header = this.generateHeader(module, requestShortener); + cacheEntry.header = header; + } + source.add(header); + if (verbose) { + const exportsType = /** @type {BuildMeta} */ (module.buildMeta) + .exportsType; + source.add( + `${Template.toComment( + exportsType + ? `${exportsType} exports` + : "unknown exports (runtime-defined)" + )}\n` + ); + if (exportsType) { + const exportsInfo = moduleGraph.getExportsInfo(module); + printExportsInfoToSource( + source, + "", + exportsInfo, + moduleGraph, + requestShortener + ); + } + source.add( + `${Template.toComment( + `runtime requirements: ${joinIterableWithComma( + chunkGraph.getModuleRuntimeRequirements(module, chunk.runtime) + )}` + )}\n` + ); + const optimizationBailout = + moduleGraph.getOptimizationBailout(module); + if (optimizationBailout) { + for (const text of optimizationBailout) { + const code = + typeof text === "function" ? text(requestShortener) : text; + source.add(`${Template.toComment(`${code}`)}\n`); + } + } + source.add(moduleSource); + return source; + } + source.add(moduleSource); + const cachedSource = new CachedSource(source); + cacheEntry.full.set(moduleSource, cachedSource); + return cachedSource; + } + ); + javascriptHooks.chunkHash.tap(PLUGIN_NAME, (_chunk, hash) => { + hash.update(PLUGIN_NAME); + hash.update("1"); + }); + const cssHooks = CssModulesPlugin.getCompilationHooks(compilation); + cssHooks.renderModulePackage.tap( + PLUGIN_NAME, + (moduleSource, module, { runtimeTemplate }) => { + const { requestShortener } = runtimeTemplate; + /** @type {undefined | CacheEntry} */ + let cacheEntry; + let cache = caches.get(requestShortener); + if (cache === undefined) { + caches.set(requestShortener, (cache = new WeakMap())); + cache.set( + module, + (cacheEntry = { header: undefined, full: new WeakMap() }) + ); + } else { + cacheEntry = cache.get(module); + if (cacheEntry === undefined) { + cache.set( + module, + (cacheEntry = { header: undefined, full: new WeakMap() }) + ); + } else if (!verbose) { + const cachedSource = cacheEntry.full.get(moduleSource); + if (cachedSource !== undefined) return cachedSource; + } + } + const source = new ConcatSource(); + let header = cacheEntry.header; + if (header === undefined) { + header = this.generateHeader(module, requestShortener); + cacheEntry.header = header; + } + source.add(header); + source.add(moduleSource); + const cachedSource = new CachedSource(source); + cacheEntry.full.set(moduleSource, cachedSource); + return cachedSource; + } + ); + cssHooks.chunkHash.tap(PLUGIN_NAME, (_chunk, hash) => { + hash.update(PLUGIN_NAME); + hash.update("1"); + }); + }); + } + + /** + * Returns the header. + * @param {Module} module the module + * @param {RequestShortener} requestShortener request shortener + * @returns {RawSource} the header + */ + generateHeader(module, requestShortener) { + const req = module.readableIdentifier(requestShortener); + const reqStr = req.replace(/\*\//g, "*_/"); + const reqStrStar = "*".repeat(reqStr.length); + const headerStr = `/*!****${reqStrStar}****!*\\\n !*** ${reqStr} ***!\n \\****${reqStrStar}****/\n`; + return new RawSource(headerStr); + } +} + +module.exports = ModuleInfoHeaderPlugin; Index: frontend/node_modules/webpack/lib/ModuleNotFoundError.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleNotFoundError.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleNotFoundError.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,10 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +// TODO remove in webpack 6 +// Some old plugins use `require("webpack/lib/ModuleNotFoundError")`, in webpack@6 developer should migrate to `compiler.webpack.ModuleNotFoundError` +module.exports = require("./errors/ModuleNotFoundError"); Index: frontend/node_modules/webpack/lib/ModuleProfile.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleProfile.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleProfile.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,108 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +class ModuleProfile { + constructor() { + this.startTime = Date.now(); + + this.factoryStartTime = 0; + this.factoryEndTime = 0; + this.factory = 0; + this.factoryParallelismFactor = 0; + + this.restoringStartTime = 0; + this.restoringEndTime = 0; + this.restoring = 0; + this.restoringParallelismFactor = 0; + + this.integrationStartTime = 0; + this.integrationEndTime = 0; + this.integration = 0; + this.integrationParallelismFactor = 0; + + this.buildingStartTime = 0; + this.buildingEndTime = 0; + this.building = 0; + this.buildingParallelismFactor = 0; + + this.storingStartTime = 0; + this.storingEndTime = 0; + this.storing = 0; + this.storingParallelismFactor = 0; + + /** @type {{ start: number, end: number }[] | undefined} */ + this.additionalFactoryTimes = undefined; + this.additionalFactories = 0; + this.additionalFactoriesParallelismFactor = 0; + + /** @deprecated */ + this.additionalIntegration = 0; + } + + markFactoryStart() { + this.factoryStartTime = Date.now(); + } + + markFactoryEnd() { + this.factoryEndTime = Date.now(); + this.factory = this.factoryEndTime - this.factoryStartTime; + } + + markRestoringStart() { + this.restoringStartTime = Date.now(); + } + + markRestoringEnd() { + this.restoringEndTime = Date.now(); + this.restoring = this.restoringEndTime - this.restoringStartTime; + } + + markIntegrationStart() { + this.integrationStartTime = Date.now(); + } + + markIntegrationEnd() { + this.integrationEndTime = Date.now(); + this.integration = this.integrationEndTime - this.integrationStartTime; + } + + markBuildingStart() { + this.buildingStartTime = Date.now(); + } + + markBuildingEnd() { + this.buildingEndTime = Date.now(); + this.building = this.buildingEndTime - this.buildingStartTime; + } + + markStoringStart() { + this.storingStartTime = Date.now(); + } + + markStoringEnd() { + this.storingEndTime = Date.now(); + this.storing = this.storingEndTime - this.storingStartTime; + } + + // This depends on timing so we ignore it for coverage + /* istanbul ignore next */ + /** + * Merge this profile into another one + * @param {ModuleProfile} realProfile the profile to merge into + * @returns {void} + */ + mergeInto(realProfile) { + realProfile.additionalFactories = this.factory; + (realProfile.additionalFactoryTimes = + realProfile.additionalFactoryTimes || []).push({ + start: this.factoryStartTime, + end: this.factoryEndTime + }); + } +} + +module.exports = ModuleProfile; Index: frontend/node_modules/webpack/lib/ModuleSourceTypeConstants.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleSourceTypeConstants.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleSourceTypeConstants.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,212 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Alexander Akait @alexander-akait +*/ + +"use strict"; + +/** + * @type {Readonly<"javascript">} + */ +const JAVASCRIPT_TYPE = "javascript"; + +/** + * @type {Readonly<"runtime">} + */ +const RUNTIME_TYPE = "runtime"; + +/** + * @type {Readonly<"webassembly">} + */ +const WEBASSEMBLY_TYPE = "webassembly"; + +/** + * @type {Readonly<"asset">} + */ +const ASSET_TYPE = "asset"; + +/** + * @type {Readonly<"asset-url">} + */ +const ASSET_URL_TYPE = "asset-url"; + +/** + * @type {Readonly<"css">} + */ +const CSS_TYPE = "css"; + +/** + * @type {Readonly<"css-import">} + */ +const CSS_IMPORT_TYPE = "css-import"; + +/** + * @type {Readonly<"css-text">} + */ +const CSS_TEXT_TYPE = "css-text"; + +/** + * @type {Readonly<"html">} + */ +const HTML_TYPE = "html"; + +/** + * @type {Readonly<"share-init">} + */ +const SHARED_INIT_TYPE = "share-init"; + +/** + * @type {Readonly<"remote">} + */ +const REMOTE_GENERATOR_TYPE = "remote"; + +/** + * @type {Readonly<"consume-shared">} + */ +const CONSUME_SHARED_GENERATOR_TYPE = "consume-shared"; + +/** + * @type {Readonly<"unknown">} + */ +const UNKNOWN_TYPE = "unknown"; + +/** + * Defines the all types type used by this module. + * @typedef {JAVASCRIPT_TYPE | RUNTIME_TYPE | WEBASSEMBLY_TYPE | ASSET_TYPE | ASSET_URL_TYPE | CSS_TYPE | CSS_IMPORT_TYPE | CSS_TEXT_TYPE | HTML_TYPE | SHARED_INIT_TYPE | REMOTE_GENERATOR_TYPE | CONSUME_SHARED_GENERATOR_TYPE | UNKNOWN_TYPE} AllTypes + */ + +/** + * @type {ReadonlySet} + */ +const NO_TYPES = new Set(); + +/** + * @type {ReadonlySet<"asset">} + */ +const ASSET_TYPES = new Set([ASSET_TYPE]); + +/** + * @type {ReadonlySet<"asset" | "javascript" | "asset">} + */ +const ASSET_AND_JAVASCRIPT_TYPES = new Set([ASSET_TYPE, JAVASCRIPT_TYPE]); + +/** + * @type {ReadonlySet<"asset-url" | "asset">} + */ +const ASSET_AND_ASSET_URL_TYPES = new Set([ASSET_TYPE, ASSET_URL_TYPE]); + +/** + * @type {ReadonlySet<"javascript" | "asset-url" | "asset">} + */ +const ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES = new Set([ + ASSET_TYPE, + JAVASCRIPT_TYPE, + ASSET_URL_TYPE +]); + +/** + * @type {ReadonlySet<"javascript">} + */ +const JAVASCRIPT_TYPES = new Set([JAVASCRIPT_TYPE]); + +/** + * @type {ReadonlySet<"javascript" | "asset-url">} + */ +const JAVASCRIPT_AND_ASSET_URL_TYPES = new Set([ + JAVASCRIPT_TYPE, + ASSET_URL_TYPE +]); + +/** + * @type {ReadonlySet<"javascript" | "css">} + */ +const JAVASCRIPT_AND_CSS_TYPES = new Set([JAVASCRIPT_TYPE, CSS_TYPE]); + +/** + * @type {ReadonlySet<"css">} + */ +const CSS_TYPES = new Set([CSS_TYPE]); + +/** + * @type {ReadonlySet<"asset-url">} + */ +const ASSET_URL_TYPES = new Set([ASSET_URL_TYPE]); + +/** + * @type {ReadonlySet<"css-text">} + */ +const CSS_TEXT_TYPES = new Set([CSS_TEXT_TYPE]); + +/** + * @type {ReadonlySet<"javascript" | "css-text">} + */ +const JAVASCRIPT_AND_CSS_TEXT_TYPES = new Set([JAVASCRIPT_TYPE, CSS_TEXT_TYPE]); +/** + * @type {ReadonlySet<"css-import">} + */ +const CSS_IMPORT_TYPES = new Set([CSS_IMPORT_TYPE]); + +/** + * @type {ReadonlySet<"html">} + */ +const HTML_TYPES = new Set([HTML_TYPE]); + +/** + * @type {ReadonlySet<"webassembly">} + */ +const WEBASSEMBLY_TYPES = new Set([WEBASSEMBLY_TYPE]); + +/** + * @type {ReadonlySet<"runtime">} + */ +const RUNTIME_TYPES = new Set([RUNTIME_TYPE]); + +/** + * @type {ReadonlySet<"remote" | "share-init">} + */ +const REMOTE_AND_SHARE_INIT_TYPES = new Set([ + REMOTE_GENERATOR_TYPE, + SHARED_INIT_TYPE +]); + +/** + * @type {ReadonlySet<"consume-shared">} + */ +const CONSUME_SHARED_TYPES = new Set([CONSUME_SHARED_GENERATOR_TYPE]); + +/** + * @type {ReadonlySet<"share-init">} + */ +const SHARED_INIT_TYPES = new Set([SHARED_INIT_TYPE]); + +module.exports.ASSET_AND_ASSET_URL_TYPES = ASSET_AND_ASSET_URL_TYPES; +module.exports.ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES = + ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES; +module.exports.ASSET_AND_JAVASCRIPT_TYPES = ASSET_AND_JAVASCRIPT_TYPES; +module.exports.ASSET_TYPE = ASSET_TYPE; +module.exports.ASSET_TYPES = ASSET_TYPES; +module.exports.ASSET_URL_TYPE = ASSET_URL_TYPE; +module.exports.ASSET_URL_TYPES = ASSET_URL_TYPES; +module.exports.CONSUME_SHARED_TYPES = CONSUME_SHARED_TYPES; +module.exports.CSS_IMPORT_TYPE = CSS_IMPORT_TYPE; +module.exports.CSS_IMPORT_TYPES = CSS_IMPORT_TYPES; +module.exports.CSS_TEXT_TYPE = CSS_TEXT_TYPE; +module.exports.CSS_TEXT_TYPES = CSS_TEXT_TYPES; +module.exports.CSS_TYPE = CSS_TYPE; +module.exports.CSS_TYPES = CSS_TYPES; +module.exports.HTML_TYPE = HTML_TYPE; +module.exports.HTML_TYPES = HTML_TYPES; +module.exports.JAVASCRIPT_AND_ASSET_URL_TYPES = JAVASCRIPT_AND_ASSET_URL_TYPES; +module.exports.JAVASCRIPT_AND_CSS_TEXT_TYPES = JAVASCRIPT_AND_CSS_TEXT_TYPES; +module.exports.JAVASCRIPT_AND_CSS_TYPES = JAVASCRIPT_AND_CSS_TYPES; +module.exports.JAVASCRIPT_TYPE = JAVASCRIPT_TYPE; +module.exports.JAVASCRIPT_TYPES = JAVASCRIPT_TYPES; +module.exports.NO_TYPES = NO_TYPES; +module.exports.REMOTE_AND_SHARE_INIT_TYPES = REMOTE_AND_SHARE_INIT_TYPES; +module.exports.RUNTIME_TYPE = RUNTIME_TYPE; +module.exports.RUNTIME_TYPES = RUNTIME_TYPES; +module.exports.SHARED_INIT_TYPE = SHARED_INIT_TYPE; +module.exports.SHARED_INIT_TYPES = SHARED_INIT_TYPES; +module.exports.UNKNOWN_TYPE = UNKNOWN_TYPE; +module.exports.WEBASSEMBLY_TYPE = WEBASSEMBLY_TYPE; +module.exports.WEBASSEMBLY_TYPES = WEBASSEMBLY_TYPES; Index: frontend/node_modules/webpack/lib/ModuleTemplate.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,181 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const util = require("util"); +const memoize = require("./util/memoize"); + +/** @typedef {import("tapable").Tap} Tap */ +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./DependencyTemplates")} DependencyTemplates */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */ +/** @typedef {import("./javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */ +/** @typedef {import("./util/Hash")} Hash */ + +/** + * Defines the if set type used by this module. + * @template T + * @typedef {import("tapable").IfSet} IfSet + */ + +const getJavascriptModulesPlugin = memoize(() => + require("./javascript/JavascriptModulesPlugin") +); + +// TODO webpack 6: remove this class +class ModuleTemplate { + /** + * Creates an instance of ModuleTemplate. + * @param {RuntimeTemplate} runtimeTemplate the runtime template + * @param {Compilation} compilation the compilation + */ + constructor(runtimeTemplate, compilation) { + this._runtimeTemplate = runtimeTemplate; + this.type = "javascript"; + this.hooks = Object.freeze({ + content: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .renderModuleContent.tap( + options, + (source, module, renderContext) => + fn( + source, + module, + renderContext, + renderContext.dependencyTemplates + ) + ); + }, + "ModuleTemplate.hooks.content is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)", + "DEP_MODULE_TEMPLATE_CONTENT" + ) + }, + module: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .renderModuleContent.tap( + options, + (source, module, renderContext) => + fn( + source, + module, + renderContext, + renderContext.dependencyTemplates + ) + ); + }, + "ModuleTemplate.hooks.module is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)", + "DEP_MODULE_TEMPLATE_MODULE" + ) + }, + render: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .renderModuleContainer.tap( + options, + (source, module, renderContext) => + fn( + source, + module, + renderContext, + renderContext.dependencyTemplates + ) + ); + }, + "ModuleTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer instead)", + "DEP_MODULE_TEMPLATE_RENDER" + ) + }, + package: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn + */ + (options, fn) => { + getJavascriptModulesPlugin() + .getCompilationHooks(compilation) + .renderModulePackage.tap( + options, + (source, module, renderContext) => + fn( + source, + module, + renderContext, + renderContext.dependencyTemplates + ) + ); + }, + "ModuleTemplate.hooks.package is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModulePackage instead)", + "DEP_MODULE_TEMPLATE_PACKAGE" + ) + }, + hash: { + tap: util.deprecate( + /** + * Handles the callback logic for this hook. + * @template AdditionalOptions + * @param {string | Tap & IfSet} options options + * @param {(hash: Hash) => void} fn fn + */ + (options, fn) => { + compilation.hooks.fullHash.tap(options, fn); + }, + "ModuleTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)", + "DEP_MODULE_TEMPLATE_HASH" + ) + } + }); + } +} + +Object.defineProperty(ModuleTemplate.prototype, "runtimeTemplate", { + get: util.deprecate( + /** + * Returns output options. + * @this {ModuleTemplate} + * @returns {RuntimeTemplate} output options + */ + function runtimeTemplate() { + return this._runtimeTemplate; + }, + "ModuleTemplate.runtimeTemplate is deprecated (use Compilation.runtimeTemplate instead)", + "DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS" + ) +}); + +module.exports = ModuleTemplate; Index: frontend/node_modules/webpack/lib/ModuleTypeConstants.js =================================================================== --- frontend/node_modules/webpack/lib/ModuleTypeConstants.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ModuleTypeConstants.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,199 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sean Larkin @TheLarkInn +*/ + +"use strict"; + +/** + * @type {Readonly<"javascript/auto">} + */ +const JAVASCRIPT_MODULE_TYPE_AUTO = "javascript/auto"; + +/** + * @type {Readonly<"javascript/dynamic">} + */ +const JAVASCRIPT_MODULE_TYPE_DYNAMIC = "javascript/dynamic"; + +/** + * @type {Readonly<"javascript/esm">} + * This is the module type used for _strict_ ES Module syntax. This means that all legacy formats + * that webpack supports (CommonJS, AMD, SystemJS) are not supported. + */ +const JAVASCRIPT_MODULE_TYPE_ESM = "javascript/esm"; + +/** + * @type {Readonly<"json">} + * This is the module type used for JSON files. JSON files are always parsed as ES Module. + */ +const JSON_MODULE_TYPE = "json"; + +/** + * @type {Readonly<"webassembly/async">} + * This is the module type used for WebAssembly modules. In webpack 5 they are always treated as async modules. + */ +const WEBASSEMBLY_MODULE_TYPE_ASYNC = "webassembly/async"; + +/** + * @type {Readonly<"webassembly/sync">} + * This is the module type used for WebAssembly modules. In webpack 4 they are always treated as sync modules. + * There is a legacy option to support this usage in webpack 5 and up. + */ +const WEBASSEMBLY_MODULE_TYPE_SYNC = "webassembly/sync"; + +/** + * @type {Readonly<"css">} + * This is the module type used for CSS files. + */ +const CSS_MODULE_TYPE = "css"; + +/** + * @type {Readonly<"css/global">} + * This is the module type used for CSS modules files where you need to use `:local` in selector list to hash classes. + */ +const CSS_MODULE_TYPE_GLOBAL = "css/global"; + +/** + * @type {Readonly<"css/module">} + * This is the module type used for CSS modules files, by default all classes are hashed. + */ +const CSS_MODULE_TYPE_MODULE = "css/module"; + +/** + * @type {Readonly<"css/auto">} + * This is the module type used for CSS files, the module will be parsed as CSS modules if it's filename contains `.module.` or `.modules.`. + */ +const CSS_MODULE_TYPE_AUTO = "css/auto"; + +/** + * @type {Readonly<"html">} + * This is the module type used for HTML files when `experiments.html` is enabled. + * HTML modules are emitted as HTML assets and can be used as entry points. + */ +const HTML_MODULE_TYPE = "html"; + +/** + * @type {Readonly<"asset">} + * This is the module type used for automatically choosing between `asset/inline`, `asset/resource` based on asset size limit (8096). + */ +const ASSET_MODULE_TYPE = "asset"; + +/** + * @type {Readonly<"asset/inline">} + * This is the module type used for assets that are inlined as a data URI. This is the equivalent of `url-loader`. + */ +const ASSET_MODULE_TYPE_INLINE = "asset/inline"; + +/** + * @type {Readonly<"asset/resource">} + * This is the module type used for assets that are copied to the output directory. This is the equivalent of `file-loader`. + */ +const ASSET_MODULE_TYPE_RESOURCE = "asset/resource"; + +/** + * @type {Readonly<"asset/source">} + * This is the module type used for assets that are imported as source code. This is the equivalent of `raw-loader`. + */ +const ASSET_MODULE_TYPE_SOURCE = "asset/source"; + +/** + * @type {Readonly<"asset/bytes">} + * This is the module type used for assets that are imported as Uint8Array. + */ +const ASSET_MODULE_TYPE_BYTES = "asset/bytes"; + +/** + * @type {Readonly<"asset/raw-data-url">} + * This is the module type used for the ignored asset module. + */ +const ASSET_MODULE_TYPE_RAW_DATA_URL = "asset/raw-data-url"; + +/** + * @type {Readonly<"runtime">} + * This is the module type used for the webpack runtime abstractions. + */ +const WEBPACK_MODULE_TYPE_RUNTIME = "runtime"; + +/** + * @type {Readonly<"fallback-module">} + * This is the module type used for the ModuleFederation feature's FallbackModule class. + */ +const WEBPACK_MODULE_TYPE_FALLBACK = "fallback-module"; + +/** + * @type {Readonly<"remote-module">} + * This is the module type used for the ModuleFederation feature's RemoteModule class. + */ +const WEBPACK_MODULE_TYPE_REMOTE = "remote-module"; + +/** + * @type {Readonly<"provide-module">} + * This is the module type used for the ModuleFederation feature's ProvideModule class. + */ +const WEBPACK_MODULE_TYPE_PROVIDE = "provide-module"; + +/** + * @type {Readonly<"consume-shared-module">} + * This is the module type used for the ModuleFederation feature's ConsumeSharedModule class. + */ +const WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE = "consume-shared-module"; + +/** + * @type {Readonly<"lazy-compilation-proxy">} + * Module type used for `experiments.lazyCompilation` feature. See `LazyCompilationPlugin` for more information. + */ +const WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY = "lazy-compilation-proxy"; + +/** @typedef {"javascript/auto" | "javascript/dynamic" | "javascript/esm"} JavaScriptModuleTypes */ +/** @typedef {"json"} JSONModuleType */ +/** @typedef {"webassembly/async" | "webassembly/sync"} WebAssemblyModuleTypes */ +/** @typedef {"css" | "css/global" | "css/module" | "css/auto"} CssModuleTypes */ +/** @typedef {"html"} HTMLModuleType */ +/** @typedef {"asset" | "asset/inline" | "asset/resource" | "asset/source" | "asset/raw-data-url"} AssetModuleTypes */ +/** @typedef {"runtime" | "fallback-module" | "remote-module" | "provide-module" | "consume-shared-module" | "lazy-compilation-proxy"} WebpackModuleTypes */ +/** @typedef {string} UnknownModuleTypes */ +/** @typedef {JavaScriptModuleTypes | JSONModuleType | WebAssemblyModuleTypes | CssModuleTypes | HTMLModuleType | AssetModuleTypes | WebpackModuleTypes | UnknownModuleTypes} ModuleTypes */ + +module.exports.ASSET_MODULE_TYPE = ASSET_MODULE_TYPE; +module.exports.ASSET_MODULE_TYPE_BYTES = ASSET_MODULE_TYPE_BYTES; +module.exports.ASSET_MODULE_TYPE_INLINE = ASSET_MODULE_TYPE_INLINE; +module.exports.ASSET_MODULE_TYPE_RAW_DATA_URL = ASSET_MODULE_TYPE_RAW_DATA_URL; +module.exports.ASSET_MODULE_TYPE_RESOURCE = ASSET_MODULE_TYPE_RESOURCE; +module.exports.ASSET_MODULE_TYPE_SOURCE = ASSET_MODULE_TYPE_SOURCE; +/** @type {CssModuleTypes[]} */ +module.exports.CSS_MODULES = [ + CSS_MODULE_TYPE, + CSS_MODULE_TYPE_GLOBAL, + CSS_MODULE_TYPE_MODULE, + CSS_MODULE_TYPE_AUTO +]; +module.exports.CSS_MODULE_TYPE = CSS_MODULE_TYPE; +module.exports.CSS_MODULE_TYPE_AUTO = CSS_MODULE_TYPE_AUTO; +module.exports.CSS_MODULE_TYPE_GLOBAL = CSS_MODULE_TYPE_GLOBAL; +module.exports.CSS_MODULE_TYPE_MODULE = CSS_MODULE_TYPE_MODULE; +module.exports.HTML_MODULE_TYPE = HTML_MODULE_TYPE; +/** @type {JavaScriptModuleTypes[]} */ +module.exports.JAVASCRIPT_MODULES = [ + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +]; +module.exports.JAVASCRIPT_MODULE_TYPE_AUTO = JAVASCRIPT_MODULE_TYPE_AUTO; +module.exports.JAVASCRIPT_MODULE_TYPE_DYNAMIC = JAVASCRIPT_MODULE_TYPE_DYNAMIC; +module.exports.JAVASCRIPT_MODULE_TYPE_ESM = JAVASCRIPT_MODULE_TYPE_ESM; +module.exports.JSON_MODULE_TYPE = JSON_MODULE_TYPE; +/** @type {WebAssemblyModuleTypes[]} */ +module.exports.WEBASSEMBLY_MODULES = [ + WEBASSEMBLY_MODULE_TYPE_ASYNC, + WEBASSEMBLY_MODULE_TYPE_SYNC +]; +module.exports.WEBASSEMBLY_MODULE_TYPE_ASYNC = WEBASSEMBLY_MODULE_TYPE_ASYNC; +module.exports.WEBASSEMBLY_MODULE_TYPE_SYNC = WEBASSEMBLY_MODULE_TYPE_SYNC; +module.exports.WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE = + WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE; +module.exports.WEBPACK_MODULE_TYPE_FALLBACK = WEBPACK_MODULE_TYPE_FALLBACK; +module.exports.WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY = + WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY; +module.exports.WEBPACK_MODULE_TYPE_PROVIDE = WEBPACK_MODULE_TYPE_PROVIDE; +module.exports.WEBPACK_MODULE_TYPE_REMOTE = WEBPACK_MODULE_TYPE_REMOTE; +module.exports.WEBPACK_MODULE_TYPE_RUNTIME = WEBPACK_MODULE_TYPE_RUNTIME; Index: frontend/node_modules/webpack/lib/MultiCompiler.js =================================================================== --- frontend/node_modules/webpack/lib/MultiCompiler.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/MultiCompiler.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,706 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const asyncLib = require("neo-async"); +const { MultiHook, SyncHook } = require("tapable"); + +const MultiStats = require("./MultiStats"); +const MultiWatching = require("./MultiWatching"); +const ConcurrentCompilationError = require("./errors/ConcurrentCompilationError"); +const WebpackError = require("./errors/WebpackError"); +const ArrayQueue = require("./util/ArrayQueue"); + +/** + * Defines the shared type used by this module. + * @template T + * @typedef {import("tapable").AsyncSeriesHook} AsyncSeriesHook + */ +/** + * Defines the shared type used by this module. + * @template T + * @template R + * @typedef {import("tapable").SyncBailHook} SyncBailHook + */ +/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */ +/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** + * Defines the callback type used by this module. + * @template T + * @template [R=void] + * @typedef {import("./webpack").Callback} Callback + */ +/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */ +/** @typedef {import("./Stats")} Stats */ +/** @typedef {import("./logging/Logger").Logger} Logger */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */ +/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */ +/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */ + +/** + * Defines the run with dependencies handler callback. + * @callback RunWithDependenciesHandler + * @param {Compiler} compiler + * @param {Callback} callback + * @returns {void} + */ + +/** + * Defines the multi compiler options type used by this module. + * @typedef {object} MultiCompilerOptions + * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel + */ + +/** @typedef {ReadonlyArray & MultiCompilerOptions} MultiWebpackOptions */ + +const CLASS_NAME = "MultiCompiler"; + +module.exports = class MultiCompiler { + /** + * Creates an instance of MultiCompiler. + * @param {Compiler[] | Record} compilers child compilers + * @param {MultiCompilerOptions} options options + */ + constructor(compilers, options) { + if (!Array.isArray(compilers)) { + /** @type {Compiler[]} */ + compilers = Object.keys(compilers).map((name) => { + /** @type {Record} */ + (compilers)[name].name = name; + return /** @type {Record} */ (compilers)[name]; + }); + } + + this.hooks = Object.freeze({ + /** @type {SyncHook<[MultiStats]>} */ + done: new SyncHook(["stats"]), + /** @type {MultiHook>} */ + invalid: new MultiHook(compilers.map((c) => c.hooks.invalid)), + /** @type {MultiHook>} */ + run: new MultiHook(compilers.map((c) => c.hooks.run)), + /** @type {SyncHook<[]>} */ + watchClose: new SyncHook([]), + /** @type {MultiHook>} */ + watchRun: new MultiHook(compilers.map((c) => c.hooks.watchRun)), + /** @type {MultiHook>} */ + infrastructureLog: new MultiHook( + compilers.map((c) => c.hooks.infrastructureLog) + ) + }); + this.compilers = compilers; + /** @type {MultiCompilerOptions} */ + this._options = { + parallelism: options.parallelism || Infinity + }; + /** @type {WeakMap} */ + this.dependencies = new WeakMap(); + this.running = false; + + /** @type {(Stats | null)[]} */ + const compilerStats = this.compilers.map(() => null); + let doneCompilers = 0; + for (let index = 0; index < this.compilers.length; index++) { + const compiler = this.compilers[index]; + const compilerIndex = index; + let compilerDone = false; + // eslint-disable-next-line no-loop-func + compiler.hooks.done.tap(CLASS_NAME, (stats) => { + if (!compilerDone) { + compilerDone = true; + doneCompilers++; + } + compilerStats[compilerIndex] = stats; + if (doneCompilers === this.compilers.length) { + this.hooks.done.call( + new MultiStats(/** @type {Stats[]} */ (compilerStats)) + ); + } + }); + // eslint-disable-next-line no-loop-func + compiler.hooks.invalid.tap(CLASS_NAME, () => { + if (compilerDone) { + compilerDone = false; + doneCompilers--; + } + }); + } + this._validateCompilersOptions(); + } + + _validateCompilersOptions() { + if (this.compilers.length < 2) return; + /** + * Adds the provided compiler to the multi compiler. + * @param {Compiler} compiler compiler + * @param {WebpackError} warning warning + */ + const addWarning = (compiler, warning) => { + compiler.hooks.thisCompilation.tap(CLASS_NAME, (compilation) => { + compilation.warnings.push(warning); + }); + }; + /** @type {Set} */ + const cacheNames = new Set(); + for (const compiler of this.compilers) { + if (compiler.options.cache && "name" in compiler.options.cache) { + const name = /** @type {string} */ (compiler.options.cache.name); + if (cacheNames.has(name)) { + addWarning( + compiler, + new WebpackError( + `${ + compiler.name + ? `Compiler with name "${compiler.name}" doesn't use unique cache name. ` + : "" + }Please set unique "cache.name" option. Name "${name}" already used.` + ) + ); + } else { + cacheNames.add(name); + } + } + } + } + + get options() { + return Object.assign( + this.compilers.map((c) => c.options), + this._options + ); + } + + get outputPath() { + let commonPath = this.compilers[0].outputPath; + for (const compiler of this.compilers) { + while ( + compiler.outputPath.indexOf(commonPath) !== 0 && + /[/\\]/.test(commonPath) + ) { + commonPath = commonPath.replace(/[/\\][^/\\]*$/, ""); + } + } + + if (!commonPath && this.compilers[0].outputPath[0] === "/") return "/"; + return commonPath; + } + + get inputFileSystem() { + throw new Error("Cannot read inputFileSystem of a MultiCompiler"); + } + + /** + * Sets input file system. + * @param {InputFileSystem} value the new input file system + */ + set inputFileSystem(value) { + for (const compiler of this.compilers) { + compiler.inputFileSystem = value; + } + } + + get outputFileSystem() { + throw new Error("Cannot read outputFileSystem of a MultiCompiler"); + } + + /** + * Sets output file system. + * @param {OutputFileSystem} value the new output file system + */ + set outputFileSystem(value) { + for (const compiler of this.compilers) { + compiler.outputFileSystem = value; + } + } + + get watchFileSystem() { + throw new Error("Cannot read watchFileSystem of a MultiCompiler"); + } + + /** + * Sets watch file system. + * @param {WatchFileSystem} value the new watch file system + */ + set watchFileSystem(value) { + for (const compiler of this.compilers) { + compiler.watchFileSystem = value; + } + } + + /** + * Sets intermediate file system. + * @param {IntermediateFileSystem} value the new intermediate file system + */ + set intermediateFileSystem(value) { + for (const compiler of this.compilers) { + compiler.intermediateFileSystem = value; + } + } + + get intermediateFileSystem() { + throw new Error("Cannot read outputFileSystem of a MultiCompiler"); + } + + /** + * Gets infrastructure logger. + * @param {string | (() => string)} name name of the logger, or function called once to get the logger name + * @returns {Logger} a logger with that name + */ + getInfrastructureLogger(name) { + return this.compilers[0].getInfrastructureLogger(name); + } + + /** + * Updates dependencies using the provided compiler. + * @param {Compiler} compiler the child compiler + * @param {string[]} dependencies its dependencies + * @returns {void} + */ + setDependencies(compiler, dependencies) { + this.dependencies.set(compiler, dependencies); + } + + /** + * Validate dependencies. + * @param {Callback} callback signals when the validation is complete + * @returns {boolean} true if the dependencies are valid + */ + validateDependencies(callback) { + /** @type {Set<{ source: Compiler, target: Compiler }>} */ + const edges = new Set(); + /** @type {string[]} */ + const missing = []; + /** + * Returns target was found. + * @param {Compiler} compiler compiler + * @returns {boolean} target was found + */ + const targetFound = (compiler) => { + for (const edge of edges) { + if (edge.target === compiler) { + return true; + } + } + return false; + }; + /** + * Returns result. + * @param {{ source: Compiler, target: Compiler }} e1 edge 1 + * @param {{ source: Compiler, target: Compiler }} e2 edge 2 + * @returns {number} result + */ + const sortEdges = (e1, e2) => + /** @type {string} */ + (e1.source.name).localeCompare(/** @type {string} */ (e2.source.name)) || + /** @type {string} */ + (e1.target.name).localeCompare(/** @type {string} */ (e2.target.name)); + for (const source of this.compilers) { + const dependencies = this.dependencies.get(source); + if (dependencies) { + for (const dep of dependencies) { + const target = this.compilers.find((c) => c.name === dep); + if (!target) { + missing.push(dep); + } else { + edges.add({ + source, + target + }); + } + } + } + } + /** @type {string[]} */ + const errors = missing.map( + (m) => `Compiler dependency \`${m}\` not found.` + ); + const stack = this.compilers.filter((c) => !targetFound(c)); + while (stack.length > 0) { + const current = stack.pop(); + for (const edge of edges) { + if (edge.source === current) { + edges.delete(edge); + const target = edge.target; + if (!targetFound(target)) { + stack.push(target); + } + } + } + } + if (edges.size > 0) { + /** @type {string[]} */ + const lines = [...edges] + .sort(sortEdges) + .map((edge) => `${edge.source.name} -> ${edge.target.name}`); + lines.unshift("Circular dependency found in compiler dependencies."); + errors.unshift(lines.join("\n")); + } + if (errors.length > 0) { + const message = errors.join("\n"); + callback(new Error(message)); + return false; + } + return true; + } + + // TODO webpack 6 remove + /** + * Run with dependencies. + * @deprecated This method should have been private + * @param {Compiler[]} compilers the child compilers + * @param {RunWithDependenciesHandler} fn a handler to run for each compiler + * @param {Callback} callback the compiler's handler + * @returns {void} + */ + runWithDependencies(compilers, fn, callback) { + /** @type {Set} */ + const fulfilledNames = new Set(); + let remainingCompilers = compilers; + /** + * Checks whether this multi compiler is dependency fulfilled. + * @param {string} d dependency + * @returns {boolean} when dependency was fulfilled + */ + const isDependencyFulfilled = (d) => fulfilledNames.has(d); + /** + * Gets ready compilers. + * @returns {Compiler[]} compilers + */ + const getReadyCompilers = () => { + /** @type {Compiler[]} */ + const readyCompilers = []; + const list = remainingCompilers; + remainingCompilers = []; + for (const c of list) { + const dependencies = this.dependencies.get(c); + const ready = + !dependencies || dependencies.every(isDependencyFulfilled); + if (ready) { + readyCompilers.push(c); + } else { + remainingCompilers.push(c); + } + } + return readyCompilers; + }; + /** + * Processes the provided stat. + * @param {Callback} callback callback + * @returns {void} + */ + const runCompilers = (callback) => { + if (remainingCompilers.length === 0) return callback(null); + asyncLib.map( + getReadyCompilers(), + (compiler, callback) => { + fn(compiler, (err) => { + if (err) return callback(err); + fulfilledNames.add(/** @type {string} */ (compiler.name)); + runCompilers(callback); + }); + }, + (err, results) => { + callback(/** @type {Error | null} */ (err), results); + } + ); + }; + runCompilers(callback); + } + + /** + * Returns result of setup. + * @template SetupResult + * @param {(compiler: Compiler, index: number, doneCallback: Callback, isBlocked: () => boolean, setChanged: () => void, setInvalid: () => void) => SetupResult} setup setup a single compiler + * @param {(compiler: Compiler, setupResult: SetupResult, callback: Callback) => void} run run/continue a single compiler + * @param {Callback} callback callback when all compilers are done, result includes Stats of all changed compilers + * @returns {SetupResult[]} result of setup + */ + _runGraph(setup, run, callback) { + /** @typedef {{ compiler: Compiler, setupResult: undefined | SetupResult, result: undefined | Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */ + + // State transitions for nodes: + // -> blocked (initial) + // blocked -> starting [running++] (when all parents done) + // queued -> starting [running++] (when processing the queue) + // starting -> running (when run has been called) + // running -> done [running--] (when compilation is done) + // done -> pending (when invalidated from file change) + // pending -> blocked [add to queue] (when invalidated from aggregated changes) + // done -> blocked [add to queue] (when invalidated, from parent invalidation) + // running -> running-outdated (when invalidated, either from change or parent invalidation) + // running-outdated -> blocked [running--] (when compilation is done) + + /** @type {Node[]} */ + const nodes = this.compilers.map((compiler) => ({ + compiler, + setupResult: undefined, + result: undefined, + state: "blocked", + children: [], + parents: [] + })); + /** @type {Map} */ + const compilerToNode = new Map(); + for (const node of nodes) { + compilerToNode.set(/** @type {string} */ (node.compiler.name), node); + } + for (const node of nodes) { + const dependencies = this.dependencies.get(node.compiler); + if (!dependencies) continue; + for (const dep of dependencies) { + const parent = /** @type {Node} */ (compilerToNode.get(dep)); + node.parents.push(parent); + parent.children.push(node); + } + } + /** @type {ArrayQueue} */ + const queue = new ArrayQueue(); + for (const node of nodes) { + if (node.parents.length === 0) { + node.state = "queued"; + queue.enqueue(node); + } + } + let errored = false; + let running = 0; + const parallelism = /** @type {number} */ (this._options.parallelism); + /** + * Processes the provided node. + * @param {Node} node node + * @param {(Error | null)=} err error + * @param {Stats=} stats result + * @returns {void} + */ + const nodeDone = (node, err, stats) => { + if (errored) return; + if (err) { + errored = true; + return asyncLib.each( + nodes, + (node, callback) => { + if (node.compiler.watching) { + node.compiler.watching.close(callback); + } else { + callback(); + } + }, + () => callback(err) + ); + } + node.result = stats; + running--; + if (node.state === "running") { + node.state = "done"; + for (const child of node.children) { + if (child.state === "blocked") queue.enqueue(child); + } + } else if (node.state === "running-outdated") { + node.state = "blocked"; + queue.enqueue(node); + } + processQueue(); + }; + /** + * Node invalid from parent. + * @param {Node} node node + * @returns {void} + */ + const nodeInvalidFromParent = (node) => { + if (node.state === "done") { + node.state = "blocked"; + } else if (node.state === "running") { + node.state = "running-outdated"; + } + for (const child of node.children) { + nodeInvalidFromParent(child); + } + }; + /** + * Processes the provided node. + * @param {Node} node node + * @returns {void} + */ + const nodeInvalid = (node) => { + if (node.state === "done") { + node.state = "pending"; + } else if (node.state === "running") { + node.state = "running-outdated"; + } + for (const child of node.children) { + nodeInvalidFromParent(child); + } + }; + /** + * Processes the provided node. + * @param {Node} node node + * @returns {void} + */ + const nodeChange = (node) => { + nodeInvalid(node); + if (node.state === "pending") { + node.state = "blocked"; + } + if (node.state === "blocked") { + queue.enqueue(node); + processQueue(); + } + }; + + /** @type {SetupResult[]} */ + const setupResults = []; + for (const [i, node] of nodes.entries()) { + setupResults.push( + (node.setupResult = setup( + node.compiler, + i, + nodeDone.bind(null, node), + () => node.state !== "starting" && node.state !== "running", + () => nodeChange(node), + () => nodeInvalid(node) + )) + ); + } + let processing = true; + const processQueue = () => { + if (processing) return; + processing = true; + process.nextTick(processQueueWorker); + }; + const processQueueWorker = () => { + // eslint-disable-next-line no-unmodified-loop-condition + while (running < parallelism && queue.length > 0 && !errored) { + const node = /** @type {Node} */ (queue.dequeue()); + if ( + node.state === "queued" || + (node.state === "blocked" && + node.parents.every((p) => p.state === "done")) + ) { + running++; + node.state = "starting"; + run( + node.compiler, + /** @type {SetupResult} */ (node.setupResult), + nodeDone.bind(null, node) + ); + node.state = "running"; + } + } + processing = false; + if ( + !errored && + running === 0 && + nodes.every((node) => node.state === "done") + ) { + /** @type {Stats[]} */ + const stats = []; + for (const node of nodes) { + const result = node.result; + if (result) { + node.result = undefined; + stats.push(result); + } + } + if (stats.length > 0) { + callback(null, new MultiStats(stats)); + } + } + }; + processQueueWorker(); + return setupResults; + } + + /** + * Returns a compiler watcher. + * @param {WatchOptions | WatchOptions[]} watchOptions the watcher's options + * @param {Callback} handler signals when the call finishes + * @returns {MultiWatching | undefined} a compiler watcher + */ + watch(watchOptions, handler) { + if (this.running) { + handler(new ConcurrentCompilationError()); + return; + } + this.running = true; + + if (this.validateDependencies(handler)) { + const watchings = this._runGraph( + (compiler, idx, callback, isBlocked, setChanged, setInvalid) => { + const watching = compiler.watch( + Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions, + callback + ); + if (watching) { + watching._onInvalid = setInvalid; + watching._onChange = setChanged; + watching._isBlocked = isBlocked; + } + return watching; + }, + (compiler, watching, _callback) => { + if (compiler.watching !== watching) return; + if (!watching.running) watching.invalidate(); + }, + handler + ); + return new MultiWatching(watchings, this); + } + + return new MultiWatching([], this); + } + + /** + * Processes the provided multi stat. + * @param {Callback} callback signals when the call finishes + * @returns {void} + */ + run(callback) { + if (this.running) { + callback(new ConcurrentCompilationError()); + return; + } + this.running = true; + + if (this.validateDependencies(callback)) { + this._runGraph( + () => {}, + (compiler, setupResult, callback) => compiler.run(callback), + (err, stats) => { + this.running = false; + + if (callback !== undefined) { + return callback(err, stats); + } + } + ); + } + } + + purgeInputFileSystem() { + for (const compiler of this.compilers) { + if (compiler.inputFileSystem && compiler.inputFileSystem.purge) { + compiler.inputFileSystem.purge(); + } + } + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the compiler closes + * @returns {void} + */ + close(callback) { + asyncLib.each( + this.compilers, + (compiler, callback) => { + compiler.close(callback); + }, + (error) => { + callback(/** @type {Error | null} */ (error)); + } + ); + } +}; Index: frontend/node_modules/webpack/lib/MultiStats.js =================================================================== --- frontend/node_modules/webpack/lib/MultiStats.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/MultiStats.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,221 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const identifierUtils = require("./util/identifier"); + +/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */ +/** @typedef {import("../declarations/WebpackOptions").StatsValue} StatsValue */ +/** @typedef {import("./Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */ +/** @typedef {import("./Compilation").NormalizedStatsOptions} NormalizedStatsOptions */ +/** @typedef {import("./Stats")} Stats */ +/** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */ +/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */ +/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */ + +/** + * Returns indent. + * @param {string} str string + * @param {string} prefix pref + * @returns {string} indent + */ +const indent = (str, prefix) => { + const rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`); + return prefix + rem; +}; + +/** @typedef {StatsOptions} MultiStatsOptions */ +/** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */ + +class MultiStats { + /** + * Creates an instance of MultiStats. + * @param {Stats[]} stats the child stats + */ + constructor(stats) { + this.stats = stats; + } + + get hash() { + return this.stats.map((stat) => stat.hash).join(""); + } + + /** + * Checks whether this multi stats has errors. + * @returns {boolean} true if a child compilation encountered an error + */ + hasErrors() { + return this.stats.some((stat) => stat.hasErrors()); + } + + /** + * Checks whether this multi stats has warnings. + * @returns {boolean} true if a child compilation had a warning + */ + hasWarnings() { + return this.stats.some((stat) => stat.hasWarnings()); + } + + /** + * Create child options. + * @param {undefined | StatsValue} options stats options + * @param {CreateStatsOptionsContext} context context + * @returns {ChildOptions} context context + */ + _createChildOptions(options, context) { + const getCreateStatsOptions = () => { + if (!options) { + options = {}; + } + + const { children: childrenOptions = undefined, ...baseOptions } = + typeof options === "string" + ? { preset: options } + : /** @type {StatsOptions} */ (options); + + return { childrenOptions, baseOptions }; + }; + + const children = this.stats.map((stat, idx) => { + if (typeof options === "boolean") { + return stat.compilation.createStatsOptions(options, context); + } + const { childrenOptions, baseOptions } = getCreateStatsOptions(); + const childOptions = Array.isArray(childrenOptions) + ? childrenOptions[idx] + : childrenOptions; + if (typeof childOptions === "boolean") { + return stat.compilation.createStatsOptions(childOptions, context); + } + return stat.compilation.createStatsOptions( + { + ...baseOptions, + ...(typeof childOptions === "string" + ? { preset: childOptions } + : childOptions && typeof childOptions === "object" + ? childOptions + : undefined) + }, + context + ); + }); + return { + version: children.every((o) => o.version), + hash: children.every((o) => o.hash), + errorsCount: children.every((o) => o.errorsCount), + warningsCount: children.every((o) => o.warningsCount), + errors: children.every((o) => o.errors), + warnings: children.every((o) => o.warnings), + children + }; + } + + /** + * Returns json output. + * @param {StatsValue=} options stats options + * @returns {StatsCompilation} json output + */ + toJson(options) { + const childOptions = this._createChildOptions(options, { + forToString: false + }); + /** @type {KnownStatsCompilation} */ + const obj = {}; + obj.children = this.stats.map((stat, idx) => { + const obj = stat.toJson(childOptions.children[idx]); + const compilationName = stat.compilation.name; + const name = + compilationName && + identifierUtils.makePathsRelative( + stat.compilation.compiler.context, + compilationName, + stat.compilation.compiler.root + ); + obj.name = name; + return obj; + }); + if (childOptions.version) { + obj.version = obj.children[0].version; + } + if (childOptions.hash) { + obj.hash = obj.children.map((j) => j.hash).join(""); + } + /** + * Returns result. + * @param {StatsCompilation} j stats error + * @param {StatsError} obj Stats error + * @returns {StatsError} result + */ + const mapError = (j, obj) => ({ + ...obj, + compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name + }); + if (childOptions.errors) { + obj.errors = []; + for (const j of obj.children) { + const errors = + /** @type {NonNullable} */ + (j.errors); + for (const i of errors) { + obj.errors.push(mapError(j, i)); + } + } + } + if (childOptions.warnings) { + obj.warnings = []; + for (const j of obj.children) { + const warnings = + /** @type {NonNullable} */ + (j.warnings); + for (const i of warnings) { + obj.warnings.push(mapError(j, i)); + } + } + } + if (childOptions.errorsCount) { + obj.errorsCount = 0; + for (const j of obj.children) { + obj.errorsCount += /** @type {number} */ (j.errorsCount); + } + } + if (childOptions.warningsCount) { + obj.warningsCount = 0; + for (const j of obj.children) { + obj.warningsCount += /** @type {number} */ (j.warningsCount); + } + } + return obj; + } + + /** + * Returns a string representation. + * @param {StatsValue=} options stats options + * @returns {string} string output + */ + toString(options) { + const childOptions = this._createChildOptions(options, { + forToString: true + }); + const results = this.stats.map((stat, idx) => { + const str = stat.toString(childOptions.children[idx]); + const compilationName = stat.compilation.name; + const name = + compilationName && + identifierUtils + .makePathsRelative( + stat.compilation.compiler.context, + compilationName, + stat.compilation.compiler.root + ) + .replace(/\|/g, " "); + if (!str) return str; + return name ? `${name}:\n${indent(str, " ")}` : str; + }); + return results.filter(Boolean).join("\n\n"); + } +} + +module.exports = MultiStats; Index: frontend/node_modules/webpack/lib/MultiWatching.js =================================================================== --- frontend/node_modules/webpack/lib/MultiWatching.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/MultiWatching.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,80 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const asyncLib = require("neo-async"); + +/** @typedef {import("./MultiCompiler")} MultiCompiler */ +/** @typedef {import("./Watching")} Watching */ +/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */ + +class MultiWatching { + /** + * Creates an instance of MultiWatching. + * @param {Watching[]} watchings child compilers' watchers + * @param {MultiCompiler} compiler the compiler + */ + constructor(watchings, compiler) { + this.watchings = watchings; + this.compiler = compiler; + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback=} callback signals when the build has completed again + * @returns {void} + */ + invalidate(callback) { + if (callback) { + asyncLib.each( + this.watchings, + (watching, callback) => watching.invalidate(callback), + (err) => { + callback(/** @type {Error | null} */ (err)); + } + ); + } else { + for (const watching of this.watchings) { + watching.invalidate(); + } + } + } + + suspend() { + for (const watching of this.watchings) { + watching.suspend(); + } + } + + resume() { + for (const watching of this.watchings) { + watching.resume(); + } + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the watcher is closed + * @returns {void} + */ + close(callback) { + asyncLib.each( + this.watchings, + (watching, finishedCallback) => { + watching.close(finishedCallback); + }, + (err) => { + this.compiler.hooks.watchClose.call(); + if (typeof callback === "function") { + this.compiler.running = false; + callback(/** @type {Error | null} */ (err)); + } + } + ); + } +} + +module.exports = MultiWatching; Index: frontend/node_modules/webpack/lib/NoEmitOnErrorsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/NoEmitOnErrorsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/NoEmitOnErrorsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,30 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "NoEmitOnErrorsPlugin"; + +class NoEmitOnErrorsPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.shouldEmit.tap(PLUGIN_NAME, (compilation) => { + if (compilation.getStats().hasErrors()) return false; + }); + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + compilation.hooks.shouldRecord.tap(PLUGIN_NAME, () => { + if (compilation.getStats().hasErrors()) return false; + }); + }); + } +} + +module.exports = NoEmitOnErrorsPlugin; Index: frontend/node_modules/webpack/lib/NodeStuffPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/NodeStuffPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/NodeStuffPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,596 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const CachedConstDependency = require("./dependencies/CachedConstDependency"); +const ConstDependency = require("./dependencies/ConstDependency"); +const ExternalModuleDependency = require("./dependencies/ExternalModuleDependency"); +const ExternalModuleInitFragmentDependency = require("./dependencies/ExternalModuleInitFragmentDependency"); +const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin"); +const NodeStuffInWebError = require("./errors/NodeStuffInWebError"); +const { evaluateToString } = require("./javascript/JavascriptParserHelpers"); +const { relative } = require("./util/fs"); +const { parseResource } = require("./util/identifier"); + +/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */ +/** @typedef {import("../declarations/WebpackOptions").NodeOptions} NodeOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./NormalModule")} NormalModule */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Expression} Expression */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ + +const PLUGIN_NAME = "NodeStuffPlugin"; +const URL_MODULE_CONSTANT_FUNCTION_NAME = "__webpack_fileURLToPath__"; + +class NodeStuffPlugin { + /** + * Creates an instance of NodeStuffPlugin. + * @param {NodeOptions} options options + */ + constructor(options) { + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const { options } = this; + + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyTemplates.set( + ExternalModuleDependency, + new ExternalModuleDependency.Template() + ); + compilation.dependencyTemplates.set( + ExternalModuleInitFragmentDependency, + new ExternalModuleInitFragmentDependency.Template() + ); + + /** + * Processes the provided parser. + * @param {JavascriptParser} parser the parser + * @param {NodeOptions} nodeOptions options + * @returns {void} + */ + const globalHandler = (parser, nodeOptions) => { + /** + * Returns const dependency. + * @param {Expression} expr expression + * @returns {ConstDependency} const dependency + */ + const getGlobalDep = (expr) => { + if (compilation.outputOptions.environment.globalThis) { + return new ConstDependency( + "globalThis", + /** @type {Range} */ (expr.range) + ); + } + + return new ConstDependency( + RuntimeGlobals.global, + /** @type {Range} */ (expr.range), + [RuntimeGlobals.global] + ); + }; + + const withWarning = nodeOptions.global === "warn"; + + parser.hooks.expression.for("global").tap(PLUGIN_NAME, (expr) => { + const dep = getGlobalDep(expr); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + + if (withWarning) { + parser.state.module.addWarning( + new NodeStuffInWebError( + dep.loc, + "global", + "The global namespace object is a Node.js feature and isn't available in browsers." + ) + ); + } + }); + + parser.hooks.rename.for("global").tap(PLUGIN_NAME, (expr) => { + const dep = getGlobalDep(expr); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return false; + }); + }; + + const hooks = ImportMetaPlugin.getCompilationHooks(compilation); + + /** + * Sets module constant. + * @param {JavascriptParser} parser the parser + * @param {"__filename" | "__dirname" | "import.meta.filename" | "import.meta.dirname"} expressionName expression name + * @param {(module: NormalModule) => string} fn function + * @param {"filename" | "dirname"} property a property + * @returns {void} + */ + const setModuleConstant = (parser, expressionName, fn, property) => { + parser.hooks.expression + .for(expressionName) + .tap(PLUGIN_NAME, (expr) => { + const dep = new ConstDependency( + fn(parser.state.module), + /** @type {Range} */ + (expr.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return true; + }); + + if ( + expressionName === "import.meta.filename" || + expressionName === "import.meta.dirname" + ) { + hooks.propertyInDestructuring.tap(PLUGIN_NAME, (usingProperty) => { + if (usingProperty.id === property) { + return `${property}: ${fn(parser.state.module)},`; + } + }); + } + }; + + /** + * Sets cached module constant. + * @param {JavascriptParser} parser the parser + * @param {"__filename" | "__dirname" | "import.meta.filename" | "import.meta.dirname"} expressionName expression name + * @param {(module: NormalModule) => string} fn function + * @param {"filename" | "dirname"} property a property + * @param {string=} warning warning + * @returns {void} + */ + const setCachedModuleConstant = ( + parser, + expressionName, + fn, + property, + warning + ) => { + parser.hooks.expression + .for(expressionName) + .tap(PLUGIN_NAME, (expr) => { + const dep = new CachedConstDependency( + JSON.stringify(fn(parser.state.module)), + /** @type {Range} */ + (expr.range), + `__webpack_${property}__` + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + + if (warning) { + parser.state.module.addWarning( + new NodeStuffInWebError(dep.loc, expressionName, warning) + ); + } + + return true; + }); + + if ( + expressionName === "import.meta.filename" || + expressionName === "import.meta.dirname" + ) { + hooks.propertyInDestructuring.tap(PLUGIN_NAME, (usingProperty) => { + if (property === usingProperty.id) { + if (warning) { + parser.state.module.addWarning( + new NodeStuffInWebError( + usingProperty.loc, + expressionName, + warning + ) + ); + } + + return `${property}: ${JSON.stringify(fn(parser.state.module))},`; + } + }); + } + }; + + /** + * Updates constant using the provided parser. + * @param {JavascriptParser} parser the parser + * @param {"__filename" | "__dirname" | "import.meta.filename" | "import.meta.dirname"} expressionName expression name + * @param {string} value value + * @param {"filename" | "dirname"} property a property + * @param {string=} warning warning + * @returns {void} + */ + const setConstant = ( + parser, + expressionName, + value, + property, + warning + ) => + setCachedModuleConstant( + parser, + expressionName, + () => value, + property, + warning + ); + + /** + * Sets url module constant. + * @param {JavascriptParser} parser the parser + * @param {"__filename" | "__dirname" | "import.meta.filename" | "import.meta.dirname"} expressionName expression name + * @param {"dirname" | "filename"} property property + * @param {() => string} value function to get value + * @returns {void} + */ + const setUrlModuleConstant = ( + parser, + expressionName, + property, + value + ) => { + parser.hooks.expression + .for(expressionName) + .tap(PLUGIN_NAME, (expr) => { + // We use `CachedConstDependency` because of `eval` devtool, there is no `import.meta` inside `eval()` + const { importMetaName, environment, module } = + compilation.outputOptions; + + // Generate `import.meta.dirname` and `import.meta.filename` when: + // - they are supported by the environment + // - it is a universal target, because we can't use `import mod from "node:url"; ` at the top file + if ( + environment.importMetaDirnameAndFilename || + (compiler.platform.web === null && + compiler.platform.node === null && + module) + ) { + const dep = new CachedConstDependency( + `${importMetaName}.${property}`, + /** @type {Range} */ + (expr.range), + `__webpack_${property}__`, + CachedConstDependency.PLACE_CHUNK + ); + + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + return; + } + + const dep = new ExternalModuleDependency( + "url", + [ + { + name: "fileURLToPath", + value: URL_MODULE_CONSTANT_FUNCTION_NAME + } + ], + undefined, + `${URL_MODULE_CONSTANT_FUNCTION_NAME}(${value()})`, + /** @type {Range} */ (expr.range), + `__webpack_${property}__`, + ExternalModuleDependency.PLACE_CHUNK + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addPresentationalDependency(dep); + + return true; + }); + + if ( + expressionName === "import.meta.filename" || + expressionName === "import.meta.dirname" + ) { + hooks.propertyInDestructuring.tap(PLUGIN_NAME, (usingProperty) => { + if (property === usingProperty.id) { + const { importMetaName, environment, module } = + compilation.outputOptions; + + if ( + environment.importMetaDirnameAndFilename || + (compiler.platform.web === null && + compiler.platform.node === null && + module) + ) { + const dep = new CachedConstDependency( + `${importMetaName}.${property}`, + null, + `__webpack_${property}__`, + CachedConstDependency.PLACE_CHUNK + ); + dep.loc = /** @type {DependencyLocation} */ ( + usingProperty.loc + ); + parser.state.module.addPresentationalDependency(dep); + return `${property}: __webpack_${property}__,`; + } + + const dep = new ExternalModuleDependency( + "url", + [ + { + name: "fileURLToPath", + value: URL_MODULE_CONSTANT_FUNCTION_NAME + } + ], + undefined, + `${URL_MODULE_CONSTANT_FUNCTION_NAME}(${value()})`, + null, + `__webpack_${property}__`, + ExternalModuleDependency.PLACE_CHUNK + ); + + dep.loc = /** @type {DependencyLocation} */ (usingProperty.loc); + parser.state.module.addPresentationalDependency(dep); + + return `${property}: __webpack_${property}__,`; + } + }); + } + }; + + /** + * Dirname and filename handler. + * @param {JavascriptParser} parser the parser + * @param {NodeOptions} nodeOptions options + * @param {{ dirname: "__dirname" | "import.meta.dirname", filename: "__filename" | "import.meta.filename" }} identifiers options + * @returns {void} + */ + const dirnameAndFilenameHandler = ( + parser, + nodeOptions, + { dirname, filename } + ) => { + // Keep `import.meta.filename` in code + if ( + nodeOptions.__filename === false && + filename === "import.meta.filename" + ) { + setModuleConstant(parser, filename, () => filename, "filename"); + } + + if (nodeOptions.__filename) { + switch (nodeOptions.__filename) { + case "mock": + setConstant(parser, filename, "/index.js", "filename"); + break; + case "warn-mock": + setConstant( + parser, + filename, + "/index.js", + "filename", + "__filename is a Node.js feature and isn't available in browsers." + ); + break; + case "node-module": { + const importMetaName = compilation.outputOptions.importMetaName; + + setUrlModuleConstant( + parser, + filename, + "filename", + () => `${importMetaName}.url` + ); + break; + } + case "eval-only": + // Keep `import.meta.filename` in the source code for the ES module output, or create a fallback using `import.meta.url` if possible + if (compilation.outputOptions.module) { + const { importMetaName } = compilation.outputOptions; + + setUrlModuleConstant( + parser, + filename, + "filename", + () => `${importMetaName}.url` + ); + } + // Replace `import.meta.filename` with `__filename` for the non-ES module output + else if (filename === "import.meta.filename") { + setModuleConstant( + parser, + filename, + () => "__filename", + "filename" + ); + } + break; + case true: + setCachedModuleConstant( + parser, + filename, + (module) => + relative( + /** @type {InputFileSystem} */ (compiler.inputFileSystem), + compiler.context, + module.resource + ), + "filename" + ); + break; + } + + parser.hooks.evaluateIdentifier + .for("__filename") + .tap(PLUGIN_NAME, (expr) => { + if (!parser.state.module) return; + const resource = parseResource(parser.state.module.resource); + return evaluateToString(resource.path)(expr); + }); + } + + // Keep `import.meta.dirname` in code + if ( + nodeOptions.__dirname === false && + dirname === "import.meta.dirname" + ) { + setModuleConstant(parser, dirname, () => dirname, "dirname"); + } + + if (nodeOptions.__dirname) { + switch (nodeOptions.__dirname) { + case "mock": + setConstant(parser, dirname, "/", "dirname"); + break; + case "warn-mock": + setConstant( + parser, + dirname, + "/", + "dirname", + "__dirname is a Node.js feature and isn't available in browsers." + ); + break; + case "node-module": { + const importMetaName = compilation.outputOptions.importMetaName; + + setUrlModuleConstant( + parser, + dirname, + "dirname", + () => `${importMetaName}.url.replace(/\\/(?:[^\\/]*)$/, "")` + ); + break; + } + case "eval-only": + // Keep `import.meta.dirname` in the source code for the ES module output and replace `__dirname` on `import.meta.dirname` + if (compilation.outputOptions.module) { + const { importMetaName } = compilation.outputOptions; + + setUrlModuleConstant( + parser, + dirname, + "dirname", + () => `${importMetaName}.url.replace(/\\/(?:[^\\/]*)$/, "")` + ); + } + // Replace `import.meta.dirname` with `__dirname` for the non-ES module output + else if (dirname === "import.meta.dirname") { + setModuleConstant( + parser, + dirname, + () => "__dirname", + "dirname" + ); + } + break; + case true: + setCachedModuleConstant( + parser, + dirname, + (module) => + relative( + /** @type {InputFileSystem} */ (compiler.inputFileSystem), + compiler.context, + /** @type {string} */ (module.context) + ), + "dirname" + ); + break; + } + + parser.hooks.evaluateIdentifier + .for(dirname) + .tap(PLUGIN_NAME, (expr) => { + if (!parser.state.module) return; + return evaluateToString( + /** @type {string} */ + (parser.state.module.context) + )(expr); + }); + } + }; + + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + * @param {JavascriptParserOptions} parserOptions the javascript parser options + * @param {boolean} a true when we need to handle `__filename` and `__dirname`, otherwise false + * @param {boolean} b true when we need to handle `import.meta.filename` and `import.meta.dirname`, otherwise false + */ + const handler = (parser, parserOptions, a, b) => { + if (b && parserOptions.node === false) { + // Keep `import.meta.dirname` and `import.meta.filename` in code + setModuleConstant( + parser, + "import.meta.dirname", + () => "import.meta.dirname", + "dirname" + ); + setModuleConstant( + parser, + "import.meta.filename", + () => "import.meta.filename", + "filename" + ); + return; + } + + let localOptions = options; + + if (parserOptions.node) { + localOptions = { ...localOptions, ...parserOptions.node }; + } + + if (localOptions.global !== false) { + globalHandler(parser, localOptions); + } + + if (a) { + dirnameAndFilenameHandler(parser, localOptions, { + dirname: "__dirname", + filename: "__filename" + }); + } + + if (b && parserOptions.importMeta !== false) { + dirnameAndFilenameHandler(parser, localOptions, { + dirname: "import.meta.dirname", + filename: "import.meta.filename" + }); + } + }; + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, (parser, parserOptions) => { + handler(parser, parserOptions, true, true); + }); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, (parser, parserOptions) => { + handler(parser, parserOptions, true, false); + }); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, (parser, parserOptions) => { + handler(parser, parserOptions, false, true); + }); + } + ); + } +} + +module.exports = NodeStuffPlugin; Index: frontend/node_modules/webpack/lib/NormalModule.js =================================================================== --- frontend/node_modules/webpack/lib/NormalModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/NormalModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1872 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const querystring = require("querystring"); +const { getContext, runLoaders } = require("loader-runner"); +const { + AsyncSeriesBailHook, + HookMap, + SyncHook, + SyncWaterfallHook +} = require("tapable"); +const { + CachedSource, + OriginalSource, + RawSource, + SourceMapSource +} = require("webpack-sources"); +const Compilation = require("./Compilation"); +const Module = require("./Module"); +const ModuleGraphConnection = require("./ModuleGraphConnection"); +const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const HookWebpackError = require("./errors/HookWebpackError"); +const ModuleBuildError = require("./errors/ModuleBuildError"); +const ModuleError = require("./errors/ModuleError"); +const ModuleParseError = require("./errors/ModuleParseError"); +const ModuleWarning = require("./errors/ModuleWarning"); +const NonErrorEmittedError = require("./errors/NonErrorEmittedError"); +const UnhandledSchemeError = require("./errors/UnhandledSchemeError"); +const LazySet = require("./util/LazySet"); +const { isSubset } = require("./util/SetHelpers"); +const { getScheme } = require("./util/URLAbsoluteSpecifier"); +const { + compareLocations, + compareSelect, + concatComparators, + keepOriginalOrder, + sortWithSourceOrder +} = require("./util/comparators"); +const createHash = require("./util/createHash"); +const { createFakeHook } = require("./util/deprecation"); +const formatLocation = require("./util/formatLocation"); +const { join } = require("./util/fs"); +const { + absolutify, + contextify, + makePathsRelative +} = require("./util/identifier"); +const makeSerializable = require("./util/makeSerializable"); +const memoize = require("./util/memoize"); +const parseJson = require("./util/parseJson"); + +/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */ +/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */ +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */ +/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */ +/** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */ +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("./Generator")} Generator */ +/** @typedef {import("./Generator").GenerateErrorFn} GenerateErrorFn */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */ +/** @typedef {import("./Module").BuildMeta} BuildMeta */ +/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */ +/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */ +/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */ +/** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */ +/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */ +/** @typedef {import("./Module").LibIdent} LibIdent */ +/** @typedef {import("./Module").NameForCondition} NameForCondition */ +/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */ +/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */ +/** @typedef {import("./Module").BuildCallback} BuildCallback */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./Module").Sources} Sources */ +/** @typedef {import("./Module").SourceType} SourceType */ +/** @typedef {import("./Module").SourceTypes} SourceTypes */ +/** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */ +/** @typedef {Iterator} SideEffectsWalk */ +/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */ +/** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */ +/** @typedef {import("./NormalModuleFactory").ParserByType} ParserByType */ +/** @typedef {import("./NormalModuleFactory").ParserOptionsByType} ParserOptionsByType */ +/** @typedef {import("./NormalModuleFactory").GeneratorByType} GeneratorByType */ +/** @typedef {import("./NormalModuleFactory").GeneratorOptionsByType} GeneratorOptionsByType */ +/** @typedef {import("./NormalModuleFactory").ResourceSchemeData} ResourceSchemeData */ +/** @typedef {import("./Parser")} Parser */ +/** @typedef {import("./Parser").PreparsedAst} PreparsedAst */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */ +/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */ +/** + * @template T + * @typedef {import("./util/deprecation").FakeHook} FakeHook + */ + +/** @typedef {{ [k: string]: EXPECTED_ANY }} ParserOptions */ +/** @typedef {{ [k: string]: EXPECTED_ANY }} GeneratorOptions */ + +/** + * @template T + * @typedef {import("../declarations/LoaderContext").LoaderContext} LoaderContext + */ + +/** + * @template T + * @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext + */ + +/** @typedef {(content: string) => boolean} NoParseFn */ + +const getInvalidDependenciesModuleWarning = memoize(() => + require("./errors/InvalidDependenciesModuleWarning") +); + +const getExtractSourceMap = memoize(() => require("./util/extractSourceMap")); + +const getValidate = memoize(() => require("schema-utils").validate); + +const getHarmonyImportSideEffectDependency = memoize(() => + require("./dependencies/HarmonyImportSideEffectDependency") +); + +/** + * @param {NormalModule} mod the module + * @param {ModuleGraph} moduleGraph the module graph + * @param {Dependency} dep the dep that triggered the bailout + */ +const recordSideEffectsBailout = (mod, moduleGraph, dep) => { + if (mod._addedSideEffectsBailout === undefined) { + mod._addedSideEffectsBailout = new WeakSet(); + } else if (mod._addedSideEffectsBailout.has(moduleGraph)) { + return; + } + mod._addedSideEffectsBailout.add(moduleGraph); + moduleGraph + .getOptimizationBailout(mod) + .push( + () => + `Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}` + ); +}; + +/** + * Generator form of `getSideEffectsConnectionState` — descends through + * `HarmonyImportSideEffectDependency` via `yield` so the trampoline in + * `getSideEffectsConnectionState` can drive the walk iteratively (#20986). + * @param {NormalModule} mod the module being evaluated + * @param {ModuleGraph} moduleGraph the module graph + * @returns {SideEffectsWalk} the generator + */ +function* walkSideEffects(mod, moduleGraph) { + if (mod.factoryMeta !== undefined) { + if (mod.factoryMeta.sideEffectFree) return false; + if (mod.factoryMeta.sideEffectFree === false) return true; + } + if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) { + return true; + } + if (mod._isEvaluatingSideEffects) { + return ModuleGraphConnection.CIRCULAR_CONNECTION; + } + + const SideEffectDep = getHarmonyImportSideEffectDependency(); + mod._isEvaluatingSideEffects = true; + /** @type {ConnectionState} */ + let current = false; + + for (const dep of mod.dependencies) { + /** @type {ConnectionState} */ + let state; + if (dep instanceof SideEffectDep) { + const refModule = moduleGraph.getModule(dep); + if (!refModule) { + state = true; + } else if (refModule instanceof NormalModule) { + state = yield walkSideEffects(refModule, moduleGraph); + } else { + state = refModule.getSideEffectsConnectionState(moduleGraph); + } + } else { + state = dep.getModuleEvaluationSideEffectsState(moduleGraph); + } + + if (state === true) { + recordSideEffectsBailout(mod, moduleGraph, dep); + mod._isEvaluatingSideEffects = false; + return true; + } + if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) { + current = ModuleGraphConnection.addConnectionStates(current, state); + } + } + + mod._isEvaluatingSideEffects = false; + // When caching is implemented here, make sure to not cache when + // at least one circular connection was folded into `current`. + return current; +} + +const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i; + +/** + * @typedef {object} LoaderItem + * @property {string} loader + * @property {string | null | undefined | Record} options + * @property {string | null=} ident + * @property {string | null=} type + */ + +/** + * @param {string} context absolute context path + * @param {string} source a source path + * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached + * @returns {string} new source path + */ +const contextifySourceUrl = (context, source, associatedObjectForCache) => { + if (source.startsWith("webpack://")) return source; + return `webpack://${makePathsRelative( + context, + source, + associatedObjectForCache + )}`; +}; + +/** + * @param {string} context absolute context path + * @param {string | RawSourceMap} sourceMap a source map + * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached + * @returns {string | RawSourceMap} new source map + */ +const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => { + if (typeof sourceMap === "string" || !Array.isArray(sourceMap.sources)) { + return sourceMap; + } + const { sourceRoot } = sourceMap; + /** @type {(source: string) => string} */ + const mapper = !sourceRoot + ? (source) => source + : sourceRoot.endsWith("/") + ? (source) => + source.startsWith("/") + ? `${sourceRoot.slice(0, -1)}${source}` + : `${sourceRoot}${source}` + : (source) => + source.startsWith("/") + ? `${sourceRoot}${source}` + : `${sourceRoot}/${source}`; + const newSources = sourceMap.sources.map((source) => + contextifySourceUrl(context, mapper(source), associatedObjectForCache) + ); + return { + ...sourceMap, + file: "x", + sourceRoot: undefined, + sources: newSources + }; +}; + +/** + * @param {string | Buffer} input the input + * @returns {string} the converted string + */ +const asString = (input) => { + if (Buffer.isBuffer(input)) { + return input.toString("utf8"); + } + return input; +}; + +/** + * @param {string | Buffer} input the input + * @returns {Buffer} the converted buffer + */ +const asBuffer = (input) => { + if (!Buffer.isBuffer(input)) { + return Buffer.from(input, "utf8"); + } + return input; +}; + +/** @typedef {[string | Buffer, string | RawSourceMap | undefined, PreparsedAst | undefined]} Result */ + +/** @typedef {LoaderContext} AnyLoaderContext */ + +/** + * @deprecated Use the `readResource` hook instead. + * @typedef {HookMap>>} DeprecatedReadResourceForScheme + */ + +/** + * @typedef {object} NormalModuleCompilationHooks + * @property {SyncHook<[AnyLoaderContext, NormalModule]>} loader + * @property {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} beforeLoaders + * @property {SyncHook<[NormalModule]>} beforeParse + * @property {SyncHook<[NormalModule]>} beforeSnapshot + * @property {DeprecatedReadResourceForScheme} readResourceForScheme + * @property {HookMap>} readResource + * @property {SyncWaterfallHook<[Result, NormalModule]>} processResult + * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild + */ + +/** + * @template {NormalModuleTypes | ""} [T=NormalModuleTypes | ""] + * @typedef {object} NormalModuleCreateData + * @property {string=} layer an optional layer in which the module is + * @property {T} type module type. When deserializing, this is set to an empty string "". + * @property {string} request request string + * @property {string} userRequest request intended by user (without loaders from config) + * @property {string} rawRequest request without resolving + * @property {LoaderItem[]} loaders list of loaders + * @property {string} resource path + query of the real resource + * @property {(ResourceSchemeData & Partial)=} resourceResolveData resource resolve data + * @property {string} context context directory for resolving + * @property {string=} matchResource path + query of the matched resource (virtual) + * @property {ParserByType[T]} parser the parser used + * @property {ParserOptionsByType[T]=} parserOptions the options of the parser used + * @property {GeneratorByType[T]} generator the generator used + * @property {GeneratorOptionsByType[T]=} generatorOptions the options of the generator used + * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module + * @property {boolean} extractSourceMap enable/disable extracting source map + */ + +/** + * @typedef {(resourcePath: string, getLoaderContext: (resourcePath: string) => AnyLoaderContext) => Promise>} ReadResource + */ + +/** @type {WeakMap} */ +const compilationHooksMap = new WeakMap(); + +class NormalModule extends Module { + /** + * @param {Compilation} compilation the compilation + * @returns {NormalModuleCompilationHooks} the attached hooks + */ + static getCompilationHooks(compilation) { + if (!(compilation instanceof Compilation)) { + throw new TypeError( + "The 'compilation' argument must be an instance of Compilation" + ); + } + let hooks = compilationHooksMap.get(compilation); + if (hooks === undefined) { + hooks = { + loader: new SyncHook(["loaderContext", "module"]), + beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]), + beforeParse: new SyncHook(["module"]), + beforeSnapshot: new SyncHook(["module"]), + // TODO webpack 6 deprecate + readResourceForScheme: new HookMap((scheme) => { + const hook = + /** @type {NormalModuleCompilationHooks} */ + (hooks).readResource.for(scheme); + return createFakeHook( + /** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({ + tap: (options, fn) => + hook.tap(options, (loaderContext) => + fn( + loaderContext.resource, + /** @type {NormalModule} */ (loaderContext._module) + ) + ), + tapAsync: (options, fn) => + hook.tapAsync(options, (loaderContext, callback) => + fn( + loaderContext.resource, + /** @type {NormalModule} */ (loaderContext._module), + callback + ) + ), + tapPromise: (options, fn) => + hook.tapPromise(options, (loaderContext) => + fn( + loaderContext.resource, + /** @type {NormalModule} */ (loaderContext._module) + ) + ) + }) + ); + }), + readResource: new HookMap( + () => new AsyncSeriesBailHook(["loaderContext"]) + ), + processResult: new SyncWaterfallHook(["result", "module"]), + needBuild: new AsyncSeriesBailHook(["module", "context"]) + }; + compilationHooksMap.set( + compilation, + /** @type {NormalModuleCompilationHooks} */ (hooks) + ); + } + return /** @type {NormalModuleCompilationHooks} */ (hooks); + } + + /** + * @param {NormalModuleCreateData} options options object + */ + constructor({ + layer, + type, + request, + userRequest, + rawRequest, + loaders, + resource, + resourceResolveData, + context, + matchResource, + parser, + parserOptions, + generator, + generatorOptions, + resolveOptions, + extractSourceMap + }) { + super(type, context || getContext(resource), layer); + + // Info from Factory + /** @type {NormalModuleCreateData['request']} */ + this.request = request; + /** @type {NormalModuleCreateData['userRequest']} */ + this.userRequest = userRequest; + /** @type {NormalModuleCreateData['rawRequest']} */ + this.rawRequest = rawRequest; + /** @type {boolean} */ + this.binary = /^(?:asset|webassembly)\b/.test(type); + /** @type {NormalModuleCreateData['parser'] | undefined} */ + this.parser = parser; + /** @type {NormalModuleCreateData['parserOptions']} */ + this.parserOptions = parserOptions; + /** @type {NormalModuleCreateData['generator'] | undefined} */ + this.generator = generator; + /** @type {NormalModuleCreateData['generatorOptions']} */ + this.generatorOptions = generatorOptions; + /** @type {NormalModuleCreateData['resource']} */ + this.resource = resource; + /** @type {NormalModuleCreateData['resourceResolveData']} */ + this.resourceResolveData = resourceResolveData; + /** @type {NormalModuleCreateData['matchResource']} */ + this.matchResource = matchResource; + /** @type {NormalModuleCreateData['loaders']} */ + this.loaders = loaders; + if (resolveOptions !== undefined) { + // already declared in super class + /** @type {NormalModuleCreateData['resolveOptions']} */ + this.resolveOptions = resolveOptions; + } + /** @type {NormalModuleCreateData['extractSourceMap']} */ + this.extractSourceMap = extractSourceMap; + + // Info from Build + /** @type {Error | null} */ + this.error = null; + /** + * @private + * @type {Source | null} + */ + this._source = null; + /** + * @private + * @type {Map | undefined} + */ + this._sourceSizes = undefined; + /** + * @private + * @type {undefined | SourceTypes} + */ + this._sourceTypes = undefined; + // Cache + /** + * @private + * @type {BuildMeta} + */ + this._lastSuccessfulBuildMeta = {}; + /** + * @private + * @type {boolean} + */ + this._forceBuild = true; + /** + * @type {boolean} + */ + this._isEvaluatingSideEffects = false; + /** + * @type {WeakSet | undefined} + */ + this._addedSideEffectsBailout = undefined; + /** + * @private + * @type {CodeGenerationResultData} + */ + this._codeGeneratorData = new Map(); + } + + /** + * Returns the unique identifier used to reference this module. + * @returns {string} a unique identifier of the module + */ + identifier() { + if (this.layer === null) { + if (this.type === JAVASCRIPT_MODULE_TYPE_AUTO) { + return this.request; + } + return `${this.type}|${this.request}`; + } + return `${this.type}|${this.request}|${this.layer}`; + } + + /** + * Returns a human-readable identifier for this module. + * @param {RequestShortener} requestShortener the request shortener + * @returns {string} a user readable identifier of the module + */ + readableIdentifier(requestShortener) { + return /** @type {string} */ (requestShortener.shorten(this.userRequest)); + } + + /** + * @returns {string | null} return the resource path + */ + getResource() { + return this.matchResource || this.resource; + } + + /** + * Gets the library identifier. + * @param {LibIdentOptions} options options + * @returns {LibIdent | null} an identifier for library inclusion + */ + libIdent(options) { + let ident = contextify( + options.context, + this.userRequest, + options.associatedObjectForCache + ); + if (this.layer) ident = `(${this.layer})/${ident}`; + return ident; + } + + /** + * Returns the path used when matching this module against rule conditions. + * @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path) + */ + nameForCondition() { + const resource = /** @type {string} */ (this.getResource()); + const idx = resource.indexOf("?"); + if (idx >= 0) return resource.slice(0, idx); + return resource; + } + + /** + * Assuming this module is in the cache. Update the (cached) module with + * the fresh module from the factory. Usually updates internal references + * and properties. + * @param {Module} module fresh module + * @returns {void} + */ + updateCacheModule(module) { + super.updateCacheModule(module); + const m = /** @type {NormalModule} */ (module); + this.binary = m.binary; + this.request = m.request; + this.userRequest = m.userRequest; + this.rawRequest = m.rawRequest; + this.parser = m.parser; + this.parserOptions = m.parserOptions; + this.generator = m.generator; + this.generatorOptions = m.generatorOptions; + this.resource = m.resource; + this.resourceResolveData = m.resourceResolveData; + this.context = m.context; + this.matchResource = m.matchResource; + this.loaders = m.loaders; + this.extractSourceMap = m.extractSourceMap; + } + + /** + * Assuming this module is in the cache. Remove internal references to allow freeing some memory. + */ + cleanupForCache() { + // Make sure to cache types and sizes before cleanup when this module has been built + // They are accessed by the stats and we don't want them to crash after cleanup + // TODO reconsider this for webpack 6 + if (this.buildInfo) { + if (this._sourceTypes === undefined) this.getSourceTypes(); + for (const type of /** @type {SourceTypes} */ (this._sourceTypes)) { + this.size(type); + } + } + super.cleanupForCache(); + this.parser = undefined; + this.parserOptions = undefined; + this.generator = undefined; + this.generatorOptions = undefined; + } + + /** + * Module should be unsafe cached. Get data that's needed for that. + * This data will be passed to restoreFromUnsafeCache later. + * @returns {UnsafeCacheData} cached data + */ + getUnsafeCacheData() { + const data = super.getUnsafeCacheData(); + data.parserOptions = this.parserOptions; + data.generatorOptions = this.generatorOptions; + return data; + } + + /** + * restore unsafe cache data + * @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData + * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching + */ + restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) { + this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory); + } + + /** + * restore unsafe cache data + * @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData + * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching + */ + _restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) { + super._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory); + this.parserOptions = unsafeCacheData.parserOptions; + this.parser = normalModuleFactory.getParser(this.type, this.parserOptions); + this.generatorOptions = unsafeCacheData.generatorOptions; + this.generator = normalModuleFactory.getGenerator( + this.type, + this.generatorOptions + ); + // we assume the generator behaves identically and keep cached sourceTypes/Sizes + } + + /** + * @param {string} context the compilation context + * @param {string} name the asset name + * @param {string | Buffer} content the content + * @param {(string | RawSourceMap)=} sourceMap an optional source map + * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching + * @returns {Source} the created source + */ + createSourceForAsset( + context, + name, + content, + sourceMap, + associatedObjectForCache + ) { + if (sourceMap) { + if ( + typeof sourceMap === "string" && + (this.useSourceMap || this.useSimpleSourceMap) + ) { + return new OriginalSource( + content, + contextifySourceUrl(context, sourceMap, associatedObjectForCache) + ); + } + + if (this.useSourceMap) { + return new SourceMapSource( + content, + name, + contextifySourceMap( + context, + /** @type {RawSourceMap} */ + (sourceMap), + associatedObjectForCache + ) + ); + } + } + + return new RawSource(content); + } + + /** + * @private + * @template T + * @param {ResolverWithOptions} resolver a resolver + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {InputFileSystem} fs file system from reading + * @param {NormalModuleCompilationHooks} hooks the hooks + * @returns {import("../declarations/LoaderContext").LoaderContext} loader context + */ + _createLoaderContext(resolver, options, compilation, fs, hooks) { + const { requestShortener } = compilation.runtimeTemplate; + const getCurrentLoaderName = () => { + const currentLoader = this.getCurrentLoader( + /** @type {AnyLoaderContext} */ + (loaderContext) + ); + if (!currentLoader) return "(not in loader scope)"; + return requestShortener.shorten(currentLoader.loader); + }; + /** + * @returns {ResolveContext} resolve context + */ + const getResolveContext = () => ({ + fileDependencies: { + add: (d) => + /** @type {AnyLoaderContext} */ + (loaderContext).addDependency(d) + }, + contextDependencies: { + add: (d) => + /** @type {AnyLoaderContext} */ + (loaderContext).addContextDependency(d) + }, + missingDependencies: { + add: (d) => + /** @type {AnyLoaderContext} */ + (loaderContext).addMissingDependency(d) + } + }); + const getAbsolutify = memoize(() => + absolutify.bindCache(compilation.compiler.root) + ); + const getAbsolutifyInContext = memoize(() => + absolutify.bindContextCache( + /** @type {string} */ + (this.context), + compilation.compiler.root + ) + ); + const getContextify = memoize(() => + contextify.bindCache(compilation.compiler.root) + ); + const getContextifyInContext = memoize(() => + contextify.bindContextCache( + /** @type {string} */ + (this.context), + compilation.compiler.root + ) + ); + const utils = { + /** + * @param {string} context context + * @param {string} request request + * @returns {string} result + */ + absolutify: (context, request) => + context === this.context + ? getAbsolutifyInContext()(request) + : getAbsolutify()(context, request), + /** + * @param {string} context context + * @param {string} request request + * @returns {string} result + */ + contextify: (context, request) => + context === this.context + ? getContextifyInContext()(request) + : getContextify()(context, request), + /** + * @param {HashFunction=} type type + * @returns {Hash} hash + */ + createHash: (type) => + createHash(type || compilation.outputOptions.hashFunction) + }; + /** @type {NormalModuleLoaderContext} */ + const loaderContext = { + version: 2, + /** + * @param {import("../declarations/LoaderContext").Schema=} schema schema + * @returns {T} options + */ + getOptions: (schema) => { + const loader = this.getCurrentLoader( + /** @type {AnyLoaderContext} */ + (loaderContext) + ); + + let { options } = /** @type {LoaderItem} */ (loader); + + if (typeof options === "string") { + if (options.startsWith("{") && options.endsWith("}")) { + try { + options = + /** @type {LoaderItem["options"]} */ + (parseJson(options)); + } catch (err) { + throw new Error( + `Cannot parse string options: ${/** @type {Error} */ (err).message}`, + { cause: err } + ); + } + } else { + options = querystring.parse(options, "&", "=", { + maxKeys: 0 + }); + } + } + + if (options === null || options === undefined) { + options = {}; + } + + if (schema && compilation.options.validate) { + let name = "Loader"; + let baseDataPath = "options"; + /** @type {RegExpExecArray | null} */ + let match; + if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) { + [, name, baseDataPath] = match; + } + getValidate()(schema, /** @type {EXPECTED_OBJECT} */ (options), { + name, + baseDataPath + }); + } + + return /** @type {T} */ (options); + }, + emitWarning: (warning) => { + if (!(warning instanceof Error)) { + warning = new NonErrorEmittedError(warning); + } + this.addWarning( + new ModuleWarning(warning, { + from: getCurrentLoaderName() + }) + ); + }, + emitError: (error) => { + if (!(error instanceof Error)) { + error = new NonErrorEmittedError(error); + } + this.addError( + new ModuleError(error, { + from: getCurrentLoaderName() + }) + ); + }, + getLogger: (name) => { + const currentLoader = this.getCurrentLoader( + /** @type {AnyLoaderContext} */ + (loaderContext) + ); + return compilation.getLogger(() => + [currentLoader && currentLoader.loader, name, this.identifier()] + .filter(Boolean) + .join("|") + ); + }, + resolve(context, request, callback) { + resolver.resolve({}, context, request, getResolveContext(), callback); + }, + getResolve(options) { + const child = options ? resolver.withOptions(options) : resolver; + return /** @type {ReturnType["getResolve"]>} */ ( + (context, request, callback) => { + if (callback) { + child.resolve( + {}, + context, + request, + getResolveContext(), + callback + ); + } else { + return new Promise((resolve, reject) => { + child.resolve( + {}, + context, + request, + getResolveContext(), + (err, result) => { + if (err) reject(err); + else resolve(result); + } + ); + }); + } + } + ); + }, + emitFile: (name, content, sourceMap, assetInfo) => { + const buildInfo = /** @type {BuildInfo} */ (this.buildInfo); + + if (!buildInfo.assets) { + buildInfo.assets = Object.create(null); + buildInfo.assetsInfo = new Map(); + } + + const assets = + /** @type {NonNullable} */ + (buildInfo.assets); + const assetsInfo = + /** @type {NonNullable} */ + (buildInfo.assetsInfo); + + assets[name] = this.createSourceForAsset( + options.context, + name, + content, + sourceMap, + compilation.compiler.root + ); + assetsInfo.set(name, assetInfo); + }, + addBuildDependency: (dep) => { + const buildInfo = /** @type {BuildInfo} */ (this.buildInfo); + + if (buildInfo.buildDependencies === undefined) { + buildInfo.buildDependencies = new LazySet(); + } + buildInfo.buildDependencies.add(dep); + }, + utils, + rootContext: options.context, + webpack: true, + sourceMap: Boolean(this.useSourceMap), + mode: options.mode || "production", + hashFunction: options.output.hashFunction, + hashDigest: options.output.hashDigest, + hashDigestLength: options.output.hashDigestLength, + hashSalt: options.output.hashSalt, + _module: this, + _compilation: compilation, + _compiler: compilation.compiler, + fs + }; + + Object.assign(loaderContext, options.loader); + + hooks.loader.call( + /** @type {AnyLoaderContext} */ + (loaderContext), + this + ); + + return /** @type {AnyLoaderContext} */ (loaderContext); + } + + /** + * @param {AnyLoaderContext} loaderContext loader context + * @param {number} index index + * @returns {LoaderItem | null} loader + */ + getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) { + if ( + this.loaders && + this.loaders.length && + index < this.loaders.length && + index >= 0 && + this.loaders[index] + ) { + return this.loaders[index]; + } + return null; + } + + /** + * @param {string} context the compilation context + * @param {string | Buffer} content the content + * @param {(string | RawSourceMap | null)=} sourceMap an optional source map + * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching + * @returns {Source} the created source + */ + createSource(context, content, sourceMap, associatedObjectForCache) { + if (Buffer.isBuffer(content)) { + return new RawSource(content); + } + + // if there is no identifier return raw source + if (!this.identifier) { + return new RawSource(content); + } + + // from here on we assume we have an identifier + const identifier = this.identifier(); + + if (this.useSourceMap && sourceMap) { + return new SourceMapSource( + content, + contextifySourceUrl(context, identifier, associatedObjectForCache), + contextifySourceMap(context, sourceMap, associatedObjectForCache) + ); + } + + if (this.useSourceMap || this.useSimpleSourceMap) { + return new OriginalSource( + content, + contextifySourceUrl(context, identifier, associatedObjectForCache) + ); + } + + return new RawSource(content); + } + + /** + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {NormalModuleCompilationHooks} hooks the hooks + * @param {BuildCallback} callback callback function + * @returns {void} + */ + _doBuild(options, compilation, resolver, fs, hooks, callback) { + const loaderContext = this._createLoaderContext( + resolver, + options, + compilation, + fs, + hooks + ); + + /** + * @param {Error | null} err err + * @param {(Result | null)=} result_ result + * @returns {void} + */ + const processResult = (err, result_) => { + if (err) { + if (!(err instanceof Error)) { + err = new NonErrorEmittedError(err); + } + const currentLoader = this.getCurrentLoader(loaderContext); + const error = new ModuleBuildError(err, { + from: + currentLoader && + compilation.runtimeTemplate.requestShortener.shorten( + currentLoader.loader + ) + }); + return callback(error); + } + const result = hooks.processResult.call( + /** @type {Result} */ + (result_), + this + ); + const source = result[0]; + const sourceMap = result.length >= 1 ? result[1] : null; + const extraInfo = result.length >= 2 ? result[2] : null; + + if (!Buffer.isBuffer(source) && typeof source !== "string") { + const currentLoader = this.getCurrentLoader(loaderContext, 0); + const err = new Error( + `Final loader (${ + currentLoader + ? compilation.runtimeTemplate.requestShortener.shorten( + currentLoader.loader + ) + : "unknown" + }) didn't return a Buffer or String` + ); + const error = new ModuleBuildError(err); + return callback(error); + } + + const isBinaryModule = + this.generatorOptions && this.generatorOptions.binary !== undefined + ? this.generatorOptions.binary + : this.binary; + + this._source = this.createSource( + options.context, + isBinaryModule ? asBuffer(source) : asString(source), + sourceMap, + compilation.compiler.root + ); + if (this._sourceSizes !== undefined) this._sourceSizes.clear(); + /** @type {PreparsedAst | null} */ + this._ast = + typeof extraInfo === "object" && + extraInfo !== null && + extraInfo.webpackAST !== undefined + ? extraInfo.webpackAST + : null; + return callback(); + }; + + const buildInfo = /** @type {BuildInfo} */ (this.buildInfo); + + buildInfo.fileDependencies = new LazySet(); + buildInfo.contextDependencies = new LazySet(); + buildInfo.missingDependencies = new LazySet(); + buildInfo.cacheable = true; + + try { + hooks.beforeLoaders.call( + this.loaders, + this, + /** @type {AnyLoaderContext} */ + (loaderContext) + ); + } catch (err) { + processResult(/** @type {Error} */ (err)); + return; + } + + if (this.loaders.length > 0) { + /** @type {BuildInfo} */ + (this.buildInfo).buildDependencies = new LazySet(); + } + + runLoaders( + { + resource: this.resource, + loaders: this.loaders, + context: loaderContext, + /** + * @param {AnyLoaderContext} loaderContext the loader context + * @param {string} resourcePath the resource Path + * @param {(err: Error | null, result?: string | Buffer, sourceMap?: Result[1]) => void} callback callback + * @returns {Promise} + */ + processResource: async (loaderContext, resourcePath, callback) => { + /** @type {ReadResource} */ + const readResource = (resourcePath, getLoaderContext) => { + const scheme = getScheme(resourcePath); + return new Promise((resolve, reject) => { + hooks.readResource + .for(scheme) + .callAsync(getLoaderContext(resourcePath), (err, result) => { + if (err) { + reject(err); + } else { + if (typeof result !== "string" && !result) { + return reject( + new UnhandledSchemeError( + /** @type {string} */ + (scheme), + resourcePath + ) + ); + } + resolve(result); + } + }); + }); + }; + try { + const result = await readResource( + resourcePath, + () => loaderContext + ); + if ( + this.extractSourceMap && + (this.useSourceMap || this.useSimpleSourceMap) + ) { + try { + const { source, sourceMap } = await getExtractSourceMap()( + result, + resourcePath, + /** @type {ReadResource} */ + (resourcePath) => + readResource( + resourcePath, + (resourcePath) => + /** @type {AnyLoaderContext} */ + ({ + addDependency(dependency) { + loaderContext.addDependency(dependency); + }, + fs: loaderContext.fs, + _module: undefined, + resourcePath, + resource: resourcePath + }) + ).catch((err) => { + throw new Error( + `Failed to parse source map. ${/** @type {Error} */ (err).message}` + ); + }) + ); + return callback(null, source, sourceMap); + } catch (err) { + this.addWarning(new ModuleWarning(/** @type {Error} */ (err))); + return callback(null, result); + } + } + return callback(null, result); + } catch (error) { + return callback(/** @type {Error} */ (error)); + } + } + }, + (err, result) => { + // Cleanup loaderContext to avoid leaking memory in ICs + loaderContext._compilation = + loaderContext._compiler = + loaderContext._module = + loaderContext.fs = + /** @type {EXPECTED_ANY} */ + (undefined); + + if (!result) { + /** @type {BuildInfo} */ + (this.buildInfo).cacheable = false; + return processResult( + err || new Error("No result from loader-runner processing"), + null + ); + } + + const buildInfo = /** @type {BuildInfo} */ (this.buildInfo); + + const fileDependencies = + /** @type {NonNullable} */ + (buildInfo.fileDependencies); + const contextDependencies = + /** @type {NonNullable} */ + (buildInfo.contextDependencies); + const missingDependencies = + /** @type {NonNullable} */ + (buildInfo.missingDependencies); + + fileDependencies.addAll(result.fileDependencies); + contextDependencies.addAll(result.contextDependencies); + missingDependencies.addAll(result.missingDependencies); + for (const loader of this.loaders) { + const buildDependencies = + /** @type {NonNullable} */ + (buildInfo.buildDependencies); + + buildDependencies.add(loader.loader); + } + buildInfo.cacheable = buildInfo.cacheable && result.cacheable; + processResult(err, result.result); + } + ); + } + + /** + * @param {Error} error the error + * @returns {void} + */ + markModuleAsErrored(error) { + // Restore build meta from successful build to keep importing state + this.buildMeta = { ...this._lastSuccessfulBuildMeta }; + this.error = error; + this.addError(error); + } + + /** + * @param {Exclude} rule rule + * @param {string} content content + * @returns {boolean} result + */ + applyNoParseRule(rule, content) { + // must start with "rule" if rule is a string + if (typeof rule === "string") { + return content.startsWith(rule); + } + + if (typeof rule === "function") { + return rule(content); + } + // we assume rule is a regexp + return rule.test(content); + } + + /** + * @param {undefined | NoParse} noParseRule no parse rule + * @param {string} request request + * @returns {boolean} check if module should not be parsed, returns "true" if the module should !not! be parsed, returns "false" if the module !must! be parsed + */ + shouldPreventParsing(noParseRule, request) { + // if no noParseRule exists, return false + // the module !must! be parsed. + if (!noParseRule) { + return false; + } + + // we only have one rule to check + if (!Array.isArray(noParseRule)) { + // returns "true" if the module is !not! to be parsed + return this.applyNoParseRule(noParseRule, request); + } + + for (let i = 0; i < noParseRule.length; i++) { + const rule = noParseRule[i]; + // early exit on first truthy match + // this module is !not! to be parsed + if (this.applyNoParseRule(rule, request)) { + return true; + } + } + // no match found, so this module !should! be parsed + return false; + } + + /** + * @param {Compilation} compilation compilation + * @private + */ + _initBuildHash(compilation) { + const hash = createHash(compilation.outputOptions.hashFunction); + if (this._source) { + hash.update("source"); + this._source.updateHash(hash); + } + hash.update("meta"); + hash.update(JSON.stringify(this.buildMeta)); + /** @type {BuildInfo} */ + (this.buildInfo).hash = hash.digest("hex"); + } + + /** + * Builds the module using the provided compilation context. + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {BuildCallback} callback callback function + * @returns {void} + */ + build(options, compilation, resolver, fs, callback) { + this._forceBuild = false; + this._source = null; + if (this._sourceSizes !== undefined) this._sourceSizes.clear(); + this._sourceTypes = undefined; + this._ast = null; + this.error = null; + this.clearWarningsAndErrors(); + this.clearDependenciesAndBlocks(); + this.buildMeta = {}; + this.buildInfo = { + cacheable: false, + parsed: true, + fileDependencies: undefined, + contextDependencies: undefined, + missingDependencies: undefined, + buildDependencies: undefined, + valueDependencies: undefined, + hash: undefined, + assets: undefined, + assetsInfo: undefined + }; + + const startTime = compilation.compiler.fsStartTime || Date.now(); + + const hooks = NormalModule.getCompilationHooks(compilation); + + return this._doBuild(options, compilation, resolver, fs, hooks, (err) => { + // if we have an error mark module as failed and exit + if (err) { + this.markModuleAsErrored(err); + this._initBuildHash(compilation); + return callback(); + } + + /** + * @param {Error} e error + * @returns {void} + */ + const handleParseError = (e) => { + const source = /** @type {Source} */ (this._source).source(); + const loaders = this.loaders.map((item) => + contextify(options.context, item.loader, compilation.compiler.root) + ); + const error = new ModuleParseError(source, e, loaders, this.type); + this.markModuleAsErrored(error); + this._initBuildHash(compilation); + return callback(); + }; + + const handleParseResult = () => { + this.dependencies.sort( + concatComparators( + compareSelect((a) => a.loc, compareLocations), + keepOriginalOrder(this.dependencies) + ) + ); + sortWithSourceOrder(this.dependencies, new WeakMap()); + this._initBuildHash(compilation); + this._lastSuccessfulBuildMeta = + /** @type {BuildMeta} */ + (this.buildMeta); + return handleBuildDone(); + }; + + const handleBuildDone = () => { + try { + hooks.beforeSnapshot.call(this); + } catch (err) { + this.markModuleAsErrored(/** @type {Error} */ (err)); + return callback(); + } + + const snapshotOptions = compilation.options.snapshot.module; + const { cacheable } = /** @type {BuildInfo} */ (this.buildInfo); + if (!cacheable || !snapshotOptions) { + return callback(); + } + // add warning for all non-absolute paths in fileDependencies, etc + // This makes it easier to find problems with watching and/or caching + /** @type {undefined | Set} */ + let nonAbsoluteDependencies; + /** + * @param {FileSystemDependencies} deps deps + */ + const checkDependencies = (deps) => { + for (const dep of deps) { + if (!ABSOLUTE_PATH_REGEX.test(dep)) { + if (nonAbsoluteDependencies === undefined) { + nonAbsoluteDependencies = new Set(); + } + nonAbsoluteDependencies.add(dep); + deps.delete(dep); + try { + const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, ""); + const absolute = join( + compilation.fileSystemInfo.fs, + /** @type {string} */ + (this.context), + depWithoutGlob + ); + if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) { + (depWithoutGlob !== dep + ? /** @type {NonNullable} */ + ( + /** @type {BuildInfo} */ + (this.buildInfo).contextDependencies + ) + : deps + ).add(absolute); + } + } catch (_err) { + // ignore + } + } + } + }; + const buildInfo = /** @type {BuildInfo} */ (this.buildInfo); + const fileDependencies = + /** @type {NonNullable} */ + (buildInfo.fileDependencies); + const contextDependencies = + /** @type {NonNullable} */ + (buildInfo.contextDependencies); + const missingDependencies = + /** @type {NonNullable} */ + (buildInfo.missingDependencies); + checkDependencies(fileDependencies); + checkDependencies(missingDependencies); + checkDependencies(contextDependencies); + if (nonAbsoluteDependencies !== undefined) { + const InvalidDependenciesModuleWarning = + getInvalidDependenciesModuleWarning(); + this.addWarning( + new InvalidDependenciesModuleWarning(this, nonAbsoluteDependencies) + ); + } + // convert file/context/missingDependencies into filesystem snapshot + compilation.fileSystemInfo.createSnapshot( + startTime, + fileDependencies, + contextDependencies, + missingDependencies, + snapshotOptions, + (err, snapshot) => { + if (err) { + this.markModuleAsErrored(err); + return; + } + buildInfo.fileDependencies = undefined; + buildInfo.contextDependencies = undefined; + buildInfo.missingDependencies = undefined; + buildInfo.snapshot = snapshot; + return callback(); + } + ); + }; + + try { + hooks.beforeParse.call(this); + } catch (err) { + this.markModuleAsErrored(/** @type {Error} */ (err)); + this._initBuildHash(compilation); + return callback(); + } + + // check if this module should !not! be parsed. + // if so, exit here; + const noParseRule = options.module && options.module.noParse; + if (this.shouldPreventParsing(noParseRule, this.request)) { + // We assume that we need module and exports + /** @type {BuildInfo} */ + (this.buildInfo).parsed = false; + this._initBuildHash(compilation); + return handleBuildDone(); + } + + try { + const source = /** @type {Source} */ (this._source).source(); + /** @type {Parser} */ + (this.parser).parse(this._ast || source, { + source, + current: this, + module: this, + compilation, + options + }); + } catch (parseErr) { + handleParseError(/** @type {Error} */ (parseErr)); + return; + } + handleParseResult(); + }); + } + + /** + * Returns the reason this module cannot be concatenated, when one exists. + * @param {ConcatenationBailoutReasonContext} context context + * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated + */ + getConcatenationBailoutReason(context) { + return /** @type {Generator} */ ( + this.generator + ).getConcatenationBailoutReason(this, context); + } + + /** + * Gets side effects connection state. + * @param {ModuleGraph} moduleGraph the module graph + * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only + */ + getSideEffectsConnectionState(moduleGraph) { + // Trampoline `walkSideEffects` so the descent doesn't consume the + // call stack (#20986). + const stack = [walkSideEffects(this, moduleGraph)]; + /** @type {ConnectionState} */ + let r = false; + while (stack.length > 0) { + const step = stack[stack.length - 1].next(r); + if (step.done) { + stack.pop(); + r = step.value; + } else { + stack.push(step.value); + } + } + return r; + } + + /** + * Returns the source types this module can generate. + * @returns {SourceTypes} types available (do not mutate) + */ + getSourceTypes() { + if (this._sourceTypes === undefined) { + this._sourceTypes = /** @type {Generator} */ (this.generator).getTypes( + this + ); + } + return this._sourceTypes; + } + + /** + * Generates code and runtime requirements for this module. + * @param {CodeGenerationContext} context context for code generation + * @returns {CodeGenerationResult} result + */ + codeGeneration({ + dependencyTemplates, + runtimeTemplate, + moduleGraph, + chunkGraph, + runtime, + concatenationScope, + codeGenerationResults, + sourceTypes + }) { + /** @type {RuntimeRequirements} */ + const runtimeRequirements = new Set(); + + const { parsed } = /** @type {BuildInfo} */ (this.buildInfo); + + if (!parsed) { + runtimeRequirements.add(RuntimeGlobals.module); + runtimeRequirements.add(RuntimeGlobals.exports); + runtimeRequirements.add(RuntimeGlobals.thisAsExports); + } + + const getData = () => this._codeGeneratorData; + + /** @type {Sources} */ + const sources = new Map(); + for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) { + // TODO webpack@6 make generateError required + const generator = + /** @type {Generator & { generateError?: GenerateErrorFn }} */ + (this.generator); + const source = this.error + ? generator.generateError + ? generator.generateError(this.error, this, { + dependencyTemplates, + runtimeTemplate, + moduleGraph, + chunkGraph, + runtimeRequirements, + runtime, + concatenationScope, + codeGenerationResults, + getData, + type + }) + : new RawSource( + `throw new Error(${JSON.stringify(this.error.message)});` + ) + : generator.generate(this, { + dependencyTemplates, + runtimeTemplate, + moduleGraph, + chunkGraph, + runtimeRequirements, + runtime, + concatenationScope, + codeGenerationResults, + getData, + type + }); + + if (source) { + sources.set(type, new CachedSource(source)); + } + } + + /** @type {CodeGenerationResult} */ + const resultEntry = { + sources, + runtimeRequirements, + data: this._codeGeneratorData + }; + return resultEntry; + } + + /** + * Gets the original source. + * @returns {Source | null} the original source for the module before webpack transformation + */ + originalSource() { + return this._source; + } + + /** + * Invalidates the cached state associated with this value. + * @returns {void} + */ + invalidateBuild() { + this._forceBuild = true; + } + + /** + * Checks whether the module needs to be rebuilt for the current build state. + * @param {NeedBuildContext} context context info + * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild + * @returns {void} + */ + needBuild(context, callback) { + const { fileSystemInfo, compilation, valueCacheVersions } = context; + // build if enforced + if (this._forceBuild) return callback(null, true); + + // always try to build in case of an error + if (this.error) return callback(null, true); + + const { cacheable, snapshot, valueDependencies } = + /** @type {BuildInfo} */ (this.buildInfo); + + // always build when module is not cacheable + if (!cacheable) return callback(null, true); + + // build when there is no snapshot to check + if (!snapshot) return callback(null, true); + + // build when valueDependencies have changed + if (valueDependencies) { + if (!valueCacheVersions) return callback(null, true); + for (const [key, value] of valueDependencies) { + if (value === undefined) return callback(null, true); + const current = valueCacheVersions.get(key); + if ( + value !== current && + (typeof value === "string" || + typeof current === "string" || + current === undefined || + !isSubset(value, current)) + ) { + return callback(null, true); + } + } + } + + // check snapshot for validity + fileSystemInfo.checkSnapshotValid(snapshot, (err, valid) => { + if (err) return callback(err); + if (!valid) return callback(null, true); + const hooks = NormalModule.getCompilationHooks(compilation); + hooks.needBuild.callAsync(this, context, (err, needBuild) => { + if (err) { + return callback( + HookWebpackError.makeWebpackError( + err, + "NormalModule.getCompilationHooks().needBuild" + ) + ); + } + callback(null, Boolean(needBuild)); + }); + }); + } + + /** + * Returns the estimated size for the requested source type. + * @param {string=} type the source type for which the size should be estimated + * @returns {number} the estimated size of the module (must be non-zero) + */ + size(type) { + const cachedSize = + this._sourceSizes === undefined ? undefined : this._sourceSizes.get(type); + if (cachedSize !== undefined) { + return cachedSize; + } + const size = Math.max( + 1, + /** @type {Generator} */ (this.generator).getSize(this, type) + ); + if (this._sourceSizes === undefined) { + this._sourceSizes = new Map(); + } + this._sourceSizes.set(type, size); + return size; + } + + /** + * Adds the provided file dependencies to the module. + * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to + * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to + * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to + * @param {FileSystemDependencies} buildDependencies set where build dependencies are added to + */ + addCacheDependencies( + fileDependencies, + contextDependencies, + missingDependencies, + buildDependencies + ) { + const { snapshot, buildDependencies: buildDeps } = + /** @type {BuildInfo} */ (this.buildInfo); + if (snapshot) { + fileDependencies.addAll(snapshot.getFileIterable()); + contextDependencies.addAll(snapshot.getContextIterable()); + missingDependencies.addAll(snapshot.getMissingIterable()); + } else { + const { + fileDependencies: fileDeps, + contextDependencies: contextDeps, + missingDependencies: missingDeps + } = /** @type {BuildInfo} */ (this.buildInfo); + if (fileDeps !== undefined) fileDependencies.addAll(fileDeps); + if (contextDeps !== undefined) contextDependencies.addAll(contextDeps); + if (missingDeps !== undefined) missingDependencies.addAll(missingDeps); + } + if (buildDeps !== undefined) { + buildDependencies.addAll(buildDeps); + } + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) { + const buildInfo = /** @type {BuildInfo} */ (this.buildInfo); + hash.update( + /** @type {string} */ + (buildInfo.hash) + ); + // Clear cached source types and re-compute so that changes in incoming + // connections (e.g. asset module newly referenced from JS via lazy + // compilation) are reflected in the hash and trigger code generation + // cache invalidation. + // https://github.com/webpack/webpack/issues/20800 + this._sourceTypes = undefined; + for (const type of this.getSourceTypes()) { + hash.update(type); + } + /** @type {Generator} */ + (this.generator).updateHash(hash, { + module: this, + ...context + }); + super.updateHash(hash, context); + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + // deserialize + write(this._source); + write(this.error); + write(this._lastSuccessfulBuildMeta); + write(this._forceBuild); + write(this._codeGeneratorData); + super.serialize(context); + } + + /** + * @param {ObjectDeserializerContext} context context + * @returns {NormalModule} module + */ + static deserialize(context) { + const obj = new NormalModule({ + // will be deserialized by Module + layer: /** @type {EXPECTED_ANY} */ (null), + type: "", + // will be filled by updateCacheModule + resource: "", + context: "", + request: /** @type {EXPECTED_ANY} */ (null), + userRequest: /** @type {EXPECTED_ANY} */ (null), + rawRequest: /** @type {EXPECTED_ANY} */ (null), + loaders: /** @type {EXPECTED_ANY} */ (null), + matchResource: /** @type {EXPECTED_ANY} */ (null), + parser: /** @type {EXPECTED_ANY} */ (null), + parserOptions: /** @type {EXPECTED_ANY} */ (null), + generator: /** @type {EXPECTED_ANY} */ (null), + generatorOptions: /** @type {EXPECTED_ANY} */ (null), + resolveOptions: /** @type {EXPECTED_ANY} */ (null), + extractSourceMap: /** @type {EXPECTED_ANY} */ (null) + }); + obj.deserialize(context); + return obj; + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + this._source = read(); + this.error = read(); + this._lastSuccessfulBuildMeta = read(); + this._forceBuild = read(); + this._codeGeneratorData = read(); + super.deserialize(context); + } +} + +makeSerializable(NormalModule, "webpack/lib/NormalModule"); + +module.exports = NormalModule; Index: frontend/node_modules/webpack/lib/NormalModuleFactory.js =================================================================== --- frontend/node_modules/webpack/lib/NormalModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/NormalModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1519 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { getContext } = require("loader-runner"); +const asyncLib = require("neo-async"); +const { + AsyncSeriesBailHook, + HookMap, + SyncBailHook, + SyncHook, + SyncWaterfallHook +} = require("tapable"); +const ChunkGraph = require("./ChunkGraph"); +const Module = require("./Module"); +const ModuleFactory = require("./ModuleFactory"); +const ModuleGraph = require("./ModuleGraph"); +const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants"); +const NormalModule = require("./NormalModule"); +const { ImportPhaseUtils } = require("./dependencies/ImportPhase"); +const BasicEffectRulePlugin = require("./rules/BasicEffectRulePlugin"); +const BasicMatcherRulePlugin = require("./rules/BasicMatcherRulePlugin"); +const ObjectMatcherRulePlugin = require("./rules/ObjectMatcherRulePlugin"); +const RuleSetCompiler = require("./rules/RuleSetCompiler"); +const UseEffectRulePlugin = require("./rules/UseEffectRulePlugin"); +const LazySet = require("./util/LazySet"); +const { getScheme } = require("./util/URLAbsoluteSpecifier"); +const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge"); +const { join } = require("./util/fs"); +const { + escapeHashInPathRequest, + parseResource, + parseResourceWithoutFragment +} = require("./util/identifier"); + +/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */ +/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */ +/** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */ +/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */ +/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */ +/** @typedef {import("./Generator")} Generator */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */ +/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */ +/** @typedef {import("./NormalModule").GeneratorOptions} GeneratorOptions */ +/** @typedef {import("./NormalModule").LoaderItem} LoaderItem */ +/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */ +/** @typedef {import("./NormalModule").ParserOptions} ParserOptions */ +/** @typedef {import("./Parser")} Parser */ +/** @typedef {import("./ResolverFactory")} ResolverFactory */ +/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */ +/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */ +/** @typedef {import("./dependencies/ImportPhase").ImportPhaseName} ImportPhaseName */ +/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */ +/** @typedef {import("./rules/RuleSetCompiler").RuleSetRules} RuleSetRules */ +/** @typedef {import("./rules/RuleSetCompiler").RuleSet} RuleSet */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */ + +/** + * Defines the callback type used by this module. + * @template T + * @typedef {import("./Compiler").Callback} Callback + */ + +/** @typedef {Pick} ModuleSettings */ +/** @typedef {NormalModuleCreateData & { settings: ModuleSettings }} CreateData */ + +/** + * Defines the resolve data type used by this module. + * @typedef {object} ResolveData + * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo + * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions + * @property {string} context + * @property {string} request + * @property {ImportPhaseName=} phase + * @property {ImportAttributes=} attributes + * @property {ModuleDependency[]} dependencies + * @property {string} dependencyType + * @property {Partial} createData + * @property {FileSystemDependencies} fileDependencies + * @property {FileSystemDependencies} missingDependencies + * @property {FileSystemDependencies} contextDependencies + * @property {Module=} ignoredModule + * @property {boolean} cacheable allow to use the unsafe cache + */ + +/** + * Defines the resource data type used by this module. + * @typedef {object} ResourceData + * @property {string} resource + * @property {string=} path + * @property {string=} query + * @property {string=} fragment + * @property {string=} context + */ + +/** + * Defines the resource scheme data type used by this module. + * @typedef {object} ResourceSchemeData + * @property {string=} mimetype mime type of the resource + * @property {string=} parameters additional parameters for the resource + * @property {"base64" | false=} encoding encoding of the resource + * @property {string=} encodedContent encoded content of the resource + */ + +/** @typedef {ResourceData & { data: ResourceSchemeData & Partial }} ResourceDataWithData */ + +/** + * Defines the parsed loader request type used by this module. + * @typedef {object} ParsedLoaderRequest + * @property {string} loader loader + * @property {string | undefined} options options + */ + +/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_AUTO} JAVASCRIPT_MODULE_TYPE_AUTO */ +/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_DYNAMIC} JAVASCRIPT_MODULE_TYPE_DYNAMIC */ +/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_ESM} JAVASCRIPT_MODULE_TYPE_ESM */ +/** @typedef {import("./ModuleTypeConstants").JSON_MODULE_TYPE} JSON_MODULE_TYPE */ +/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE} ASSET_MODULE_TYPE */ +/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_INLINE} ASSET_MODULE_TYPE_INLINE */ +/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_RESOURCE} ASSET_MODULE_TYPE_RESOURCE */ +/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_SOURCE} ASSET_MODULE_TYPE_SOURCE */ +/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_BYTES} ASSET_MODULE_TYPE_BYTES */ +/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_ASYNC} WEBASSEMBLY_MODULE_TYPE_ASYNC */ +/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_SYNC} WEBASSEMBLY_MODULE_TYPE_SYNC */ +/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE} CSS_MODULE_TYPE */ +/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_GLOBAL} CSS_MODULE_TYPE_GLOBAL */ +/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_MODULE} CSS_MODULE_TYPE_MODULE */ +/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_AUTO} CSS_MODULE_TYPE_AUTO */ +/** @typedef {import("./ModuleTypeConstants").HTML_MODULE_TYPE} HTML_MODULE_TYPE */ + +/** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO | HTML_MODULE_TYPE} KnownNormalModuleTypes */ +/** @typedef {KnownNormalModuleTypes | string} NormalModuleTypes */ + +const EMPTY_RESOLVE_OPTIONS = {}; +/** @type {ParserOptions} */ +const EMPTY_PARSER_OPTIONS = {}; +/** @type {GeneratorOptions} */ +const EMPTY_GENERATOR_OPTIONS = {}; +/** @type {ParsedLoaderRequest[]} */ +const EMPTY_ELEMENTS = []; + +const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/; +const LEADING_DOT_EXTENSION_REGEX = /^[^.]/; + +/** + * Returns ident. + * @param {LoaderItem} data data + * @returns {string} ident + */ +const loaderToIdent = (data) => { + if (!data.options) { + return data.loader; + } + if (typeof data.options === "string") { + return `${data.loader}?${data.options}`; + } + if (typeof data.options !== "object") { + throw new Error("loader options must be string or object"); + } + if (data.ident) { + return `${data.loader}??${data.ident}`; + } + return `${data.loader}?${JSON.stringify(data.options)}`; +}; + +/** + * Stringify loaders and resource. + * @param {LoaderItem[]} loaders loaders + * @param {string} resource resource + * @returns {string} stringified loaders and resource + */ +const stringifyLoadersAndResource = (loaders, resource) => { + let str = ""; + for (const loader of loaders) { + str += `${loaderToIdent(loader)}!`; + } + return str + resource; +}; + +/** + * Checks whether it needs calls. + * @param {number} times times + * @param {(err?: null | Error) => void} callback callback + * @returns {(err?: null | Error) => void} callback + */ +const needCalls = (times, callback) => (err) => { + if (--times === 0) { + return callback(err); + } + if (err && times > 0) { + times = Number.NaN; + return callback(err); + } +}; + +/** + * Merges global options. + * @template T + * @template O + * @param {T} globalOptions global options + * @param {string} type type + * @param {O} localOptions local options + * @returns {T & O | T | O} result + */ +const mergeGlobalOptions = (globalOptions, type, localOptions) => { + const parts = type.split("/"); + /** @type {undefined | T} */ + let result; + let current = ""; + for (const part of parts) { + current = current ? `${current}/${part}` : part; + const options = + /** @type {T} */ + (globalOptions[/** @type {keyof T} */ (current)]); + if (typeof options === "object") { + result = + result === undefined ? options : cachedCleverMerge(result, options); + } + } + if (result === undefined) { + return localOptions; + } + return cachedCleverMerge(result, localOptions); +}; + +// TODO webpack 6 remove +/** + * Deprecation changed hook message. + * @template {import("tapable").Hook} T + * @param {string} name name + * @param {T} hook hook + * @returns {string} result + */ +const deprecationChangedHookMessage = (name, hook) => { + const names = hook.taps.map((tapped) => tapped.name).join(", "); + + return ( + `NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` + + "Do not return the passed object, but modify it instead. " + + "Returning false will ignore the request and results in no module created." + ); +}; + +const ruleSetCompiler = new RuleSetCompiler([ + new BasicMatcherRulePlugin("test", "resource"), + new BasicMatcherRulePlugin("scheme"), + new BasicMatcherRulePlugin("mimetype"), + new BasicMatcherRulePlugin("dependency"), + new BasicMatcherRulePlugin("include", "resource"), + new BasicMatcherRulePlugin("exclude", "resource", true), + new BasicMatcherRulePlugin("resource"), + new BasicMatcherRulePlugin("resourceQuery"), + new BasicMatcherRulePlugin("resourceFragment"), + new BasicMatcherRulePlugin("realResource"), + new BasicMatcherRulePlugin("issuer"), + new BasicMatcherRulePlugin("compiler"), + new BasicMatcherRulePlugin("issuerLayer"), + new BasicMatcherRulePlugin("phase"), + new ObjectMatcherRulePlugin("assert", "attributes", (value) => { + if (value) { + return ( + /** @type {ImportAttributes} */ (value)._isLegacyAssert !== undefined + ); + } + + return false; + }), + new ObjectMatcherRulePlugin("with", "attributes", (value) => { + if (value) { + return !(/** @type {ImportAttributes} */ (value)._isLegacyAssert); + } + return false; + }), + new ObjectMatcherRulePlugin("descriptionData"), + new BasicEffectRulePlugin("type"), + new BasicEffectRulePlugin("sideEffects"), + new BasicEffectRulePlugin("parser"), + new BasicEffectRulePlugin("resolve"), + new BasicEffectRulePlugin("generator"), + new BasicEffectRulePlugin("layer"), + new BasicEffectRulePlugin("extractSourceMap"), + new UseEffectRulePlugin() +]); + +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */ +/** @typedef {import("./javascript/JavascriptGenerator")} JavascriptGenerator */ +/** @typedef {import("../declarations/WebpackOptions").EmptyGeneratorOptions} EmptyGeneratorOptions */ + +/** @typedef {import("./json/JsonParser")} JsonParser */ +/** @typedef {import("../declarations/WebpackOptions").JsonParserOptions} JsonParserOptions */ +/** @typedef {import("./json/JsonGenerator")} JsonGenerator */ +/** @typedef {import("../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */ + +/** @typedef {import("./asset/AssetParser")} AssetParser */ +/** @typedef {import("./asset/AssetSourceParser")} AssetSourceParser */ +/** @typedef {import("./asset/AssetBytesParser")} AssetBytesParser */ +/** @typedef {import("../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */ +/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} EmptyParserOptions */ +/** @typedef {import("./asset/AssetGenerator")} AssetGenerator */ +/** @typedef {import("../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */ +/** @typedef {import("../declarations/WebpackOptions").AssetInlineGeneratorOptions} AssetInlineGeneratorOptions */ +/** @typedef {import("../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */ +/** @typedef {import("./asset/AssetSourceGenerator")} AssetSourceGenerator */ +/** @typedef {import("./asset/AssetBytesGenerator")} AssetBytesGenerator */ + +/** @typedef {import("./wasm-async/AsyncWebAssemblyParser")} AsyncWebAssemblyParser */ +/** @typedef {import("./wasm-sync/WebAssemblyParser")} WebAssemblyParser */ + +/** @typedef {import("./css/CssParser")} CssParser */ +/** @typedef {import("../declarations/WebpackOptions").CssParserOptions} CssParserOptions */ +/** @typedef {import("../declarations/WebpackOptions").CssModuleParserOptions} CssModuleParserOptions */ +/** @typedef {import("./css/CssGenerator")} CssGenerator */ +/** @typedef {import("../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */ +/** @typedef {import("../declarations/WebpackOptions").CssModuleGeneratorOptions} CssModuleGeneratorOptions */ + +/** @typedef {import("./html/HtmlParser")} HtmlParser */ +/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} HtmlParserOptions */ +/** @typedef {import("./html/HtmlGenerator")} HtmlGenerator */ +/** @typedef {import("../declarations/WebpackOptions").HtmlGeneratorOptions} HtmlGeneratorOptions */ + +/* eslint-disable jsdoc/type-formatting */ +/** + * Defines the shared type used by this module. + * @typedef {[ + * [JAVASCRIPT_MODULE_TYPE_AUTO, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions], + * [JAVASCRIPT_MODULE_TYPE_DYNAMIC, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions], + * [JAVASCRIPT_MODULE_TYPE_ESM, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions], + * [JSON_MODULE_TYPE, JsonParser, JsonParserOptions, JsonGenerator, JsonGeneratorOptions], + * [ASSET_MODULE_TYPE, AssetParser, AssetParserOptions, AssetGenerator, AssetGeneratorOptions], + * [ASSET_MODULE_TYPE_INLINE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions], + * [ASSET_MODULE_TYPE_RESOURCE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions], + * [ASSET_MODULE_TYPE_SOURCE, AssetSourceParser, EmptyParserOptions, AssetSourceGenerator, EmptyGeneratorOptions], + * [ASSET_MODULE_TYPE_BYTES, AssetBytesParser, EmptyParserOptions, AssetBytesGenerator, EmptyGeneratorOptions], + * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions], + * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions], + * [CSS_MODULE_TYPE, CssParser, CssParserOptions, CssGenerator, CssGeneratorOptions], + * [CSS_MODULE_TYPE_AUTO, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions], + * [CSS_MODULE_TYPE_MODULE, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions], + * [CSS_MODULE_TYPE_GLOBAL, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions], + * [HTML_MODULE_TYPE, HtmlParser, HtmlParserOptions, HtmlGenerator, HtmlGeneratorOptions], + * [string, Parser, ParserOptions, Generator, GeneratorOptions], + * ]} ParsersAndGeneratorsByTypes + */ +/* eslint-enable jsdoc/type-formatting */ + +/** + * Defines the extract tuple elements type used by this module. + * @template {unknown[]} T + * @template {number[]} I + * @typedef {{ [K in keyof I]: K extends keyof I ? I[K] extends keyof T ? T[I[K]] : never : never }} ExtractTupleElements + */ + +/** + * Represents the normal module factory runtime component. + * @template {unknown[]} T + * @template {number[]} A + * @template [R=void] + * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record, R extends number ? Head[R] : R>> & RecordFactoryFromTuple : unknown } RecordFactoryFromTuple + */ + +/** + * Maps each tuple in `T` to a record from its `[0]` key to its `[I]` value. + * @template {unknown[]} T + * @template {number} I + * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record & TupleToTypeMap : unknown } TupleToTypeMap + */ + +/** @typedef {TupleToTypeMap} ParserByType */ +/** @typedef {TupleToTypeMap} ParserOptionsByType */ +/** @typedef {TupleToTypeMap} GeneratorByType */ +/** @typedef {TupleToTypeMap} GeneratorOptionsByType */ + +class NormalModuleFactory extends ModuleFactory { + /** + * Creates an instance of NormalModuleFactory. + * @param {object} param params + * @param {string=} param.context context + * @param {InputFileSystem} param.fs file system + * @param {ResolverFactory} param.resolverFactory resolverFactory + * @param {ModuleOptions} param.options options + * @param {AssociatedObjectForCache} param.associatedObjectForCache an object to which the cache will be attached + */ + constructor({ + context, + fs, + resolverFactory, + options, + associatedObjectForCache + }) { + super(); + this.hooks = Object.freeze({ + /** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */ + resolve: new AsyncSeriesBailHook(["resolveData"]), + /** @type {HookMap>} */ + resolveForScheme: new HookMap( + () => new AsyncSeriesBailHook(["resourceData", "resolveData"]) + ), + /** @type {HookMap>} */ + resolveInScheme: new HookMap( + () => new AsyncSeriesBailHook(["resourceData", "resolveData"]) + ), + /** @type {AsyncSeriesBailHook<[ResolveData], Module | undefined>} */ + factorize: new AsyncSeriesBailHook(["resolveData"]), + /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */ + beforeResolve: new AsyncSeriesBailHook(["resolveData"]), + /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */ + afterResolve: new AsyncSeriesBailHook(["resolveData"]), + /** @type {AsyncSeriesBailHook<[CreateData, ResolveData], Module | void>} */ + createModule: new AsyncSeriesBailHook(["createData", "resolveData"]), + /** @type {SyncWaterfallHook<[Module, CreateData, ResolveData]>} */ + module: new SyncWaterfallHook(["module", "createData", "resolveData"]), + /** @type {import("tapable").TypedHookMap>} */ + createParser: new HookMap(() => new SyncBailHook(["parserOptions"])), + /** @type {import("tapable").TypedHookMap>} */ + parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])), + /** @type {import("tapable").TypedHookMap>} */ + createGenerator: new HookMap( + () => new SyncBailHook(["generatorOptions"]) + ), + /** @type {import("tapable").TypedHookMap>} */ + generator: new HookMap( + () => new SyncHook(["generator", "generatorOptions"]) + ), + /** @type {HookMap>} */ + createModuleClass: new HookMap( + () => new SyncBailHook(["createData", "resolveData"]) + ) + }); + /** @type {ResolverFactory} */ + this.resolverFactory = resolverFactory; + /** @type {RuleSet} */ + this.ruleSet = ruleSetCompiler.compile([ + { + rules: /** @type {RuleSetRules} */ (options.defaultRules) + }, + { + rules: /** @type {RuleSetRules} */ (options.rules) + } + ]); + /** @type {string} */ + this.context = context || ""; + /** @type {InputFileSystem} */ + this.fs = fs; + this._globalParserOptions = options.parser; + this._globalGeneratorOptions = options.generator; + /** @type {Map>} */ + this.parserCache = new Map(); + /** @type {Map>} */ + this.generatorCache = new Map(); + /** @type {Set} */ + this._restoredUnsafeCacheEntries = new Set(); + + /** @type {(resource: string) => import("./util/identifier").ParsedResource} */ + const cacheParseResource = parseResource.bindCache( + associatedObjectForCache + ); + const cachedParseResourceWithoutFragment = + parseResourceWithoutFragment.bindCache(associatedObjectForCache); + this._parseResourceWithoutFragment = cachedParseResourceWithoutFragment; + + this.hooks.factorize.tapAsync( + { + name: "NormalModuleFactory", + stage: 100 + }, + (resolveData, callback) => { + this.hooks.resolve.callAsync(resolveData, (err, result) => { + if (err) return callback(err); + + // Ignored + if (result === false) return callback(); + + // direct module + if (result instanceof Module) return callback(null, result); + + if (typeof result === "object") { + throw new Error( + `${deprecationChangedHookMessage( + "resolve", + this.hooks.resolve + )} Returning a Module object will result in this module used as result.` + ); + } + + this.hooks.afterResolve.callAsync(resolveData, (err, result) => { + if (err) return callback(err); + + if (typeof result === "object") { + throw new Error( + deprecationChangedHookMessage( + "afterResolve", + this.hooks.afterResolve + ) + ); + } + + // Ignored + if (result === false) return callback(); + + const createData = + /** @type {CreateData} */ + (resolveData.createData); + + this.hooks.createModule.callAsync( + createData, + resolveData, + (err, createdModule) => { + if (!createdModule) { + if (!resolveData.request) { + return callback(new Error("Empty dependency (no request)")); + } + + // TODO webpack 6 make it required and move javascript/wasm/asset properties to own module + createdModule = this.hooks.createModuleClass + .for(createData.settings.type) + .call(createData, resolveData); + + if (!createdModule) { + createdModule = /** @type {Module} */ ( + new NormalModule(createData) + ); + } + } + + createdModule = this.hooks.module.call( + createdModule, + createData, + resolveData + ); + + return callback(null, createdModule); + } + ); + }); + }); + } + ); + this.hooks.resolve.tapAsync( + { + name: "NormalModuleFactory", + stage: 100 + }, + (data, callback) => { + const { + contextInfo, + context, + dependencies, + dependencyType, + request, + phase, + attributes, + resolveOptions, + fileDependencies, + missingDependencies, + contextDependencies + } = data; + const loaderResolver = this.getResolver("loader"); + + /** @type {ResourceData | undefined} */ + let matchResourceData; + /** @type {string} */ + let unresolvedResource; + /** @type {ParsedLoaderRequest[]} */ + let elements; + let noPreAutoLoaders = false; + let noAutoLoaders = false; + let noPrePostAutoLoaders = false; + + const contextScheme = getScheme(context); + /** @type {string | undefined} */ + let scheme = getScheme(request); + + if (!scheme) { + /** @type {string} */ + let requestWithoutMatchResource = request; + const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request); + if (matchResourceMatch) { + let matchResource = matchResourceMatch[1]; + // Check if matchResource starts with ./ or ../ + if (matchResource.charCodeAt(0) === 46) { + // 46 is "." + const secondChar = matchResource.charCodeAt(1); + if ( + secondChar === 47 || // 47 is "/" + (secondChar === 46 && matchResource.charCodeAt(2) === 47) // "../" + ) { + // Resolve relative path against context + matchResource = join(this.fs, context, matchResource); + } + } + + matchResourceData = { + ...cacheParseResource(matchResource), + resource: matchResource + }; + requestWithoutMatchResource = request.slice( + matchResourceMatch[0].length + ); + } + + scheme = getScheme(requestWithoutMatchResource); + + if (!scheme && !contextScheme) { + const firstChar = requestWithoutMatchResource.charCodeAt(0); + const secondChar = requestWithoutMatchResource.charCodeAt(1); + noPreAutoLoaders = firstChar === 45 && secondChar === 33; // startsWith "-!" + noAutoLoaders = noPreAutoLoaders || firstChar === 33; // startsWith "!" + noPrePostAutoLoaders = firstChar === 33 && secondChar === 33; // startsWith "!!"; + const rawElements = requestWithoutMatchResource + .slice( + noPreAutoLoaders || noPrePostAutoLoaders + ? 2 + : noAutoLoaders + ? 1 + : 0 + ) + .split(/!+/); + unresolvedResource = /** @type {string} */ (rawElements.pop()); + elements = rawElements.map((el) => { + const { path, query } = cachedParseResourceWithoutFragment(el); + return { + loader: path, + options: query ? query.slice(1) : undefined + }; + }); + scheme = getScheme(unresolvedResource); + } else { + unresolvedResource = requestWithoutMatchResource; + elements = EMPTY_ELEMENTS; + } + } else { + unresolvedResource = request; + elements = EMPTY_ELEMENTS; + } + + /** @type {ResolveContext} */ + const resolveContext = { + fileDependencies, + missingDependencies, + contextDependencies + }; + + /** @type {ResourceDataWithData} */ + let resourceData; + + /** @type {undefined | LoaderItem[]} */ + let loaders; + + const continueCallback = needCalls(2, (err) => { + if (err) return callback(err); + + // translate option idents + try { + for (const item of /** @type {LoaderItem[]} */ (loaders)) { + if (typeof item.options === "string" && item.options[0] === "?") { + const ident = item.options.slice(1); + if (ident === "[[missing ident]]") { + throw new Error( + "No ident is provided by referenced loader. " + + "When using a function for Rule.use in config you need to " + + "provide an 'ident' property for referenced loader options." + ); + } + item.options = this.ruleSet.references.get(ident); + if (item.options === undefined) { + throw new Error( + "Invalid ident is provided by referenced loader" + ); + } + item.ident = ident; + } + } + } catch (identErr) { + return callback(/** @type {Error} */ (identErr)); + } + + if (!resourceData) { + // ignored + return callback(null, dependencies[0].createIgnoredModule(context)); + } + + const userRequest = + (matchResourceData !== undefined + ? `${matchResourceData.resource}!=!` + : "") + + stringifyLoadersAndResource( + /** @type {LoaderItem[]} */ (loaders), + resourceData.resource + ); + + /** @type {ModuleSettings} */ + const settings = {}; + /** @type {LoaderItem[]} */ + const useLoadersPost = []; + /** @type {LoaderItem[]} */ + const useLoaders = []; + /** @type {LoaderItem[]} */ + const useLoadersPre = []; + + // handle .webpack[] suffix + /** @type {string} */ + let resource; + /** @type {RegExpExecArray | null} */ + let match; + if ( + matchResourceData && + typeof (resource = matchResourceData.resource) === "string" && + (match = /\.webpack\[([^\]]+)\]$/.exec(resource)) + ) { + settings.type = match[1]; + matchResourceData.resource = matchResourceData.resource.slice( + 0, + -settings.type.length - 10 + ); + } else { + settings.type = JAVASCRIPT_MODULE_TYPE_AUTO; + const resourceDataForRules = matchResourceData || resourceData; + + const result = this.ruleSet.exec({ + resource: resourceDataForRules.path, + realResource: resourceData.path, + resourceQuery: resourceDataForRules.query, + resourceFragment: resourceDataForRules.fragment, + scheme, + phase, + attributes, + mimetype: matchResourceData + ? "" + : resourceData.data.mimetype || "", + dependency: dependencyType, + descriptionData: matchResourceData + ? undefined + : resourceData.data.descriptionFileData, + issuer: contextInfo.issuer, + compiler: contextInfo.compiler, + issuerLayer: contextInfo.issuerLayer || "" + }); + for (const r of result) { + // https://github.com/webpack/webpack/issues/16466 + // if a request exists PrePostAutoLoaders, should disable modifying Rule.type + if (r.type === "type" && noPrePostAutoLoaders) { + continue; + } + if (r.type === "use") { + if (!noAutoLoaders && !noPrePostAutoLoaders) { + useLoaders.push(r.value); + } + } else if (r.type === "use-post") { + if (!noPrePostAutoLoaders) { + useLoadersPost.push(r.value); + } + } else if (r.type === "use-pre") { + if (!noPreAutoLoaders && !noPrePostAutoLoaders) { + useLoadersPre.push(r.value); + } + } else if ( + typeof r.value === "object" && + r.value !== null && + typeof settings[ + /** @type {keyof ModuleSettings} */ + (r.type) + ] === "object" && + settings[/** @type {keyof ModuleSettings} */ (r.type)] !== null + ) { + const type = /** @type {keyof ModuleSettings} */ (r.type); + settings[type] = cachedCleverMerge(settings[type], r.value); + } else { + const type = /** @type {keyof ModuleSettings} */ (r.type); + settings[type] = r.value; + } + } + } + + /** @type {undefined | LoaderItem[]} */ + let postLoaders; + /** @type {undefined | LoaderItem[]} */ + let normalLoaders; + /** @type {undefined | LoaderItem[]} */ + let preLoaders; + + const continueCallback = needCalls(3, (err) => { + if (err) { + return callback(err); + } + const allLoaders = /** @type {LoaderItem[]} */ (postLoaders); + if (matchResourceData === undefined) { + for (const loader of /** @type {LoaderItem[]} */ (loaders)) { + allLoaders.push(loader); + } + for (const loader of /** @type {LoaderItem[]} */ ( + normalLoaders + )) { + allLoaders.push(loader); + } + } else { + for (const loader of /** @type {LoaderItem[]} */ ( + normalLoaders + )) { + allLoaders.push(loader); + } + for (const loader of /** @type {LoaderItem[]} */ (loaders)) { + allLoaders.push(loader); + } + } + for (const loader of /** @type {LoaderItem[]} */ (preLoaders)) { + allLoaders.push(loader); + } + const type = /** @type {NormalModuleTypes} */ (settings.type); + const resolveOptions = settings.resolve; + const layer = settings.layer; + + try { + Object.assign(data.createData, { + layer: + layer === undefined ? contextInfo.issuerLayer || null : layer, + request: stringifyLoadersAndResource( + allLoaders, + resourceData.resource + ), + userRequest, + rawRequest: request, + loaders: allLoaders, + resource: resourceData.resource, + context: + resourceData.context || getContext(resourceData.resource), + matchResource: matchResourceData + ? matchResourceData.resource + : undefined, + resourceResolveData: resourceData.data, + settings, + type, + parser: this.getParser(type, settings.parser), + parserOptions: settings.parser, + generator: this.getGenerator(type, settings.generator), + generatorOptions: settings.generator, + resolveOptions, + extractSourceMap: settings.extractSourceMap || false + }); + } catch (createDataErr) { + return callback(/** @type {Error} */ (createDataErr)); + } + callback(); + }); + this.resolveRequestArray( + contextInfo, + this.context, + useLoadersPost, + loaderResolver, + resolveContext, + (err, result) => { + postLoaders = result; + continueCallback(err); + } + ); + this.resolveRequestArray( + contextInfo, + this.context, + useLoaders, + loaderResolver, + resolveContext, + (err, result) => { + normalLoaders = result; + continueCallback(err); + } + ); + this.resolveRequestArray( + contextInfo, + this.context, + useLoadersPre, + loaderResolver, + resolveContext, + (err, result) => { + preLoaders = result; + continueCallback(err); + } + ); + }); + + this.resolveRequestArray( + contextInfo, + contextScheme ? this.context : context, + /** @type {LoaderItem[]} */ (elements), + loaderResolver, + resolveContext, + (err, result) => { + if (err) return continueCallback(err); + loaders = result; + continueCallback(); + } + ); + + /** + * Processes the provided string. + * @param {string} context context + */ + const defaultResolve = (context) => { + if (/^(?:$|\?)/.test(unresolvedResource)) { + resourceData = { + ...cacheParseResource(unresolvedResource), + resource: unresolvedResource, + data: {} + }; + continueCallback(); + } + + // resource without scheme and with path + else { + const normalResolver = this.getResolver( + "normal", + dependencyType + ? cachedSetProperty( + resolveOptions || EMPTY_RESOLVE_OPTIONS, + "dependencyType", + dependencyType + ) + : resolveOptions + ); + this.resolveResource( + contextInfo, + context, + escapeHashInPathRequest(unresolvedResource), + normalResolver, + resolveContext, + (err, _resolvedResource, resolvedResourceResolveData) => { + if (err) return continueCallback(err); + if (_resolvedResource !== false) { + const resolvedResource = + /** @type {string} */ + (_resolvedResource); + resourceData = { + ...cacheParseResource(resolvedResource), + resource: resolvedResource, + data: + /** @type {ResolveRequest} */ + (resolvedResourceResolveData) + }; + } + continueCallback(); + } + ); + } + }; + + // resource with scheme + if (scheme) { + resourceData = { + resource: unresolvedResource, + data: {}, + path: undefined, + query: undefined, + fragment: undefined, + context: undefined + }; + this.hooks.resolveForScheme + .for(scheme) + .callAsync(resourceData, data, (err) => { + if (err) return continueCallback(err); + continueCallback(); + }); + } + + // resource within scheme + else if (contextScheme) { + resourceData = { + resource: unresolvedResource, + data: {}, + path: undefined, + query: undefined, + fragment: undefined, + context: undefined + }; + this.hooks.resolveInScheme + .for(contextScheme) + .callAsync(resourceData, data, (err, handled) => { + if (err) return continueCallback(err); + if (!handled) return defaultResolve(this.context); + continueCallback(); + }); + } + + // resource without scheme and without path + else { + defaultResolve(context); + } + } + ); + } + + cleanupForCache() { + for (const module of this._restoredUnsafeCacheEntries) { + ChunkGraph.clearChunkGraphForModule(module); + ModuleGraph.clearModuleGraphForModule(module); + module.cleanupForCache(); + } + } + + /** + * Processes the provided data. + * @param {ModuleFactoryCreateData} data data object + * @param {ModuleFactoryCallback} callback callback + * @returns {void} + */ + create(data, callback) { + const dependencies = /** @type {ModuleDependency[]} */ (data.dependencies); + const context = data.context || this.context; + const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS; + const dependency = dependencies[0]; + const request = dependency.request; + const attributes = + /** @type {ModuleDependency & { attributes: ImportAttributes }} */ + (dependency).attributes; + const phase = + typeof ( + /** @type {ModuleDependency & { phase?: ImportPhaseType }} */ + (dependency).phase + ) === "number" + ? ImportPhaseUtils.stringify( + /** @type {ModuleDependency & { phase?: ImportPhaseType }} */ + (dependency).phase + ) + : "evaluation"; + const dependencyType = dependency.category || ""; + const contextInfo = data.contextInfo; + /** @type {FileSystemDependencies} */ + const fileDependencies = new LazySet(); + /** @type {FileSystemDependencies} */ + const missingDependencies = new LazySet(); + /** @type {FileSystemDependencies} */ + const contextDependencies = new LazySet(); + /** @type {ResolveData} */ + const resolveData = { + contextInfo, + resolveOptions, + context, + request, + phase, + attributes, + dependencies, + dependencyType, + fileDependencies, + missingDependencies, + contextDependencies, + createData: {}, + cacheable: true + }; + this.hooks.beforeResolve.callAsync(resolveData, (err, result) => { + if (err) { + return callback(err, { + fileDependencies, + missingDependencies, + contextDependencies, + cacheable: false + }); + } + + // Ignored + if (result === false) { + /** @type {ModuleFactoryResult} * */ + const factoryResult = { + fileDependencies, + missingDependencies, + contextDependencies, + cacheable: resolveData.cacheable + }; + + if (resolveData.ignoredModule) { + factoryResult.module = resolveData.ignoredModule; + } + + return callback(null, factoryResult); + } + + if (typeof result === "object") { + throw new Error( + deprecationChangedHookMessage( + "beforeResolve", + this.hooks.beforeResolve + ) + ); + } + + this.hooks.factorize.callAsync(resolveData, (err, module) => { + if (err) { + return callback(err, { + fileDependencies, + missingDependencies, + contextDependencies, + cacheable: false + }); + } + + /** @type {ModuleFactoryResult} * */ + const factoryResult = { + module, + fileDependencies, + missingDependencies, + contextDependencies, + cacheable: resolveData.cacheable + }; + + callback(null, factoryResult); + }); + }); + } + + /** + * Processes the provided context info. + * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info + * @param {string} context context + * @param {string} unresolvedResource unresolved resource + * @param {ResolverWithOptions} resolver resolver + * @param {ResolveContext} resolveContext resolver context + * @param {(err: null | Error, res?: string | false, req?: ResolveRequest) => void} callback callback + */ + resolveResource( + contextInfo, + context, + unresolvedResource, + resolver, + resolveContext, + callback + ) { + resolver.resolve( + contextInfo, + context, + unresolvedResource, + resolveContext, + (err, resolvedResource, resolvedResourceResolveData) => { + if (err) { + return this._resolveResourceErrorHints( + err, + contextInfo, + context, + unresolvedResource, + resolver, + resolveContext, + (err2, hints) => { + if (err2) { + err.message += ` +A fatal error happened during resolving additional hints for this error: ${err2.message}`; + err.stack += ` + +A fatal error happened during resolving additional hints for this error: +${err2.stack}`; + return callback(err); + } + if (hints && hints.length > 0) { + err.message += ` +${hints.join("\n\n")}`; + } + + // Check if the extension is missing a leading dot (e.g. "js" instead of ".js") + let appendResolveExtensionsHint = false; + const specifiedExtensions = [...resolver.options.extensions]; + const expectedExtensions = specifiedExtensions.map( + (extension) => { + if (LEADING_DOT_EXTENSION_REGEX.test(extension)) { + appendResolveExtensionsHint = true; + return `.${extension}`; + } + return extension; + } + ); + if (appendResolveExtensionsHint) { + err.message += `\nDid you miss the leading dot in 'resolve.extensions'? Did you mean '${JSON.stringify( + expectedExtensions + )}' instead of '${JSON.stringify(specifiedExtensions)}'?`; + } + + callback(err); + } + ); + } + callback(err, resolvedResource, resolvedResourceResolveData); + } + ); + } + + /** + * Resolve resource error hints. + * @param {Error} error error + * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info + * @param {string} context context + * @param {string} unresolvedResource unresolved resource + * @param {ResolverWithOptions} resolver resolver + * @param {ResolveContext} resolveContext resolver context + * @param {Callback} callback callback + * @private + */ + _resolveResourceErrorHints( + error, + contextInfo, + context, + unresolvedResource, + resolver, + resolveContext, + callback + ) { + asyncLib.parallel( + [ + (callback) => { + if (!resolver.options.fullySpecified) return callback(); + resolver + .withOptions({ + fullySpecified: false + }) + .resolve( + contextInfo, + context, + unresolvedResource, + resolveContext, + (err, resolvedResource) => { + if (!err && resolvedResource) { + const resource = parseResource(resolvedResource).path.replace( + /^.*[\\/]/, + "" + ); + return callback( + null, + `Did you mean '${resource}'? +BREAKING CHANGE: The request '${unresolvedResource}' failed to resolve only because it was resolved as fully specified +(probably because the origin is strict EcmaScript Module, e. g. a module with javascript mimetype, a '*.mjs' file, or a '*.js' file where the package.json contains '"type": "module"'). +The extension in the request is mandatory for it to be fully specified. +Add the extension to the request.` + ); + } + callback(); + } + ); + }, + (callback) => { + if (!resolver.options.enforceExtension) return callback(); + resolver + .withOptions({ + enforceExtension: false, + extensions: [] + }) + .resolve( + contextInfo, + context, + unresolvedResource, + resolveContext, + (err, resolvedResource) => { + if (!err && resolvedResource) { + let hint = ""; + const match = /\.[^.]+(?:\?|$)/.exec(unresolvedResource); + if (match) { + const fixedRequest = unresolvedResource.replace( + /(\.[^.]+)(\?|$)/, + "$2" + ); + hint = resolver.options.extensions.has(match[1]) + ? `Did you mean '${fixedRequest}'?` + : `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`; + } else { + hint = + "Did you mean to omit the extension or to remove 'resolve.enforceExtension'?"; + } + return callback( + null, + `The request '${unresolvedResource}' failed to resolve only because 'resolve.enforceExtension' was specified. +${hint} +Including the extension in the request is no longer possible. Did you mean to enforce including the extension in requests with 'resolve.extensions: []' instead?` + ); + } + callback(); + } + ); + }, + (callback) => { + if ( + /^\.\.?\//.test(unresolvedResource) || + resolver.options.preferRelative + ) { + return callback(); + } + resolver.resolve( + contextInfo, + context, + `./${unresolvedResource}`, + resolveContext, + (err, resolvedResource) => { + if (err || !resolvedResource) return callback(); + const moduleDirectories = resolver.options.modules + .map((m) => (Array.isArray(m) ? m.join(", ") : m)) + .join(", "); + callback( + null, + `Did you mean './${unresolvedResource}'? +Requests that should resolve in the current directory need to start with './'. +Requests that start with a name are treated as module requests and resolve within module directories (${moduleDirectories}). +If changing the source code is not an option there is also a resolve options called 'preferRelative' which tries to resolve these kind of requests in the current directory too.` + ); + } + ); + } + ], + (err, hints) => { + if (err) return callback(err); + callback(null, /** @type {string[]} */ (hints).filter(Boolean)); + } + ); + } + + /** + * Resolves request array. + * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info + * @param {string} context context + * @param {LoaderItem[]} array array + * @param {ResolverWithOptions} resolver resolver + * @param {ResolveContext} resolveContext resolve context + * @param {Callback} callback callback + * @returns {void} result + */ + resolveRequestArray( + contextInfo, + context, + array, + resolver, + resolveContext, + callback + ) { + // LoaderItem + if (array.length === 0) return callback(null, array); + asyncLib.map( + array, + /** + * Handles the callback logic for this hook. + * @param {LoaderItem} item item + * @param {Callback} callback callback + */ + (item, callback) => { + resolver.resolve( + contextInfo, + context, + item.loader, + resolveContext, + (err, result, resolveRequest) => { + if ( + err && + /^[^/]*$/.test(item.loader) && + !item.loader.endsWith("-loader") + ) { + return resolver.resolve( + contextInfo, + context, + `${item.loader}-loader`, + resolveContext, + (err2) => { + if (!err2) { + err.message = + `${err.message}\n` + + "BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" + + ` You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` + + " see https://webpack.js.org/migrate/3/#automatic-loader-module-name-extension-removed"; + } + callback(err); + } + ); + } + if (err) return callback(err); + + const parsedResult = this._parseResourceWithoutFragment( + /** @type {string} */ + (result) + ); + + const type = /\.mjs$/i.test(parsedResult.path) + ? "module" + : /\.cjs$/i.test(parsedResult.path) + ? "commonjs" + : /** @type {ResolveRequest} */ + (resolveRequest).descriptionFileData === undefined + ? undefined + : /** @type {string} */ + ( + /** @type {ResolveRequest} */ + (resolveRequest).descriptionFileData.type + ); + /** @type {LoaderItem} */ + const resolved = { + loader: parsedResult.path, + type, + options: + item.options === undefined + ? parsedResult.query + ? parsedResult.query.slice(1) + : undefined + : item.options, + ident: item.options === undefined ? undefined : item.ident + }; + + return callback(null, resolved); + } + ); + }, + (err, value) => { + callback( + /** @type {Error | null} */ (err), + /** @type {(LoaderItem)[]} */ (value) + ); + } + ); + } + + /** + * Returns parser. + * @template {string} T + * @param {T} type type + * @param {ParserOptions} parserOptions parser options + * @returns {ParserByType[T]} parser + */ + getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) { + let cache = this.parserCache.get(type); + + if (cache === undefined) { + cache = new WeakMap(); + this.parserCache.set(type, cache); + } + + let parser = cache.get(parserOptions); + + if (parser === undefined) { + parser = this.createParser(type, parserOptions); + cache.set(parserOptions, parser); + } + + return /** @type {ParserByType[T]} */ (parser); + } + + /** + * Creates a parser from the provided type. + * @template {string} T + * @param {T} type type + * @param {ParserOptions} parserOptions parser options + * @returns {ParserByType[T]} parser + */ + createParser(type, parserOptions = {}) { + parserOptions = mergeGlobalOptions( + this._globalParserOptions, + type, + parserOptions + ); + const parser = this.hooks.createParser.for(type).call(parserOptions); + if (!parser) { + throw new Error(`No parser registered for ${type}`); + } + this.hooks.parser.for(type).call(parser, parserOptions); + return /** @type {ParserByType[T]} */ (parser); + } + + /** + * Returns generator. + * @template {string} T + * @param {T} type type of generator + * @param {GeneratorOptions} generatorOptions generator options + * @returns {GeneratorByType[T]} generator + */ + getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) { + let cache = this.generatorCache.get(type); + + if (cache === undefined) { + cache = new WeakMap(); + this.generatorCache.set(type, cache); + } + + let generator = cache.get(generatorOptions); + + if (generator === undefined) { + generator = this.createGenerator(type, generatorOptions); + cache.set(generatorOptions, generator); + } + + return /** @type {GeneratorByType[T]} */ (generator); + } + + /** + * Creates a generator. + * @template {string} T + * @param {T} type type of generator + * @param {GeneratorOptions} generatorOptions generator options + * @returns {GeneratorByType[T]} generator + */ + createGenerator(type, generatorOptions = {}) { + generatorOptions = mergeGlobalOptions( + this._globalGeneratorOptions, + type, + generatorOptions + ); + const generator = this.hooks.createGenerator + .for(type) + .call(generatorOptions); + if (!generator) { + throw new Error(`No generator registered for ${type}`); + } + this.hooks.generator.for(type).call(generator, generatorOptions); + return /** @type {GeneratorByType[T]} */ (generator); + } + + /** + * Returns the resolver. + * @param {Parameters[0]} type type of resolver + * @param {Parameters[1]=} resolveOptions options + * @returns {ReturnType} the resolver + */ + getResolver(type, resolveOptions) { + return this.resolverFactory.get(type, resolveOptions); + } +} + +module.exports = NormalModuleFactory; Index: frontend/node_modules/webpack/lib/NormalModuleReplacementPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/NormalModuleReplacementPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/NormalModuleReplacementPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,75 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { dirname, join } = require("./util/fs"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ + +/** @typedef {(resolveData: ResolveData) => void} ModuleReplacer */ + +const PLUGIN_NAME = "NormalModuleReplacementPlugin"; + +class NormalModuleReplacementPlugin { + /** + * Create an instance of the plugin + * @param {RegExp} resourceRegExp the resource matcher + * @param {string | ModuleReplacer} newResource the resource replacement + */ + constructor(resourceRegExp, newResource) { + this.resourceRegExp = resourceRegExp; + this.newResource = newResource; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const resourceRegExp = this.resourceRegExp; + const newResource = this.newResource; + compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => { + nmf.hooks.beforeResolve.tap(PLUGIN_NAME, (result) => { + if (resourceRegExp.test(result.request)) { + if (typeof newResource === "function") { + newResource(result); + } else { + result.request = newResource; + } + } + }); + nmf.hooks.afterResolve.tap(PLUGIN_NAME, (result) => { + const createData = result.createData; + if (resourceRegExp.test(/** @type {string} */ (createData.resource))) { + if (typeof newResource === "function") { + newResource(result); + } else { + const fs = + /** @type {InputFileSystem} */ + (compiler.inputFileSystem); + if ( + newResource.startsWith("/") || + (newResource.length > 1 && newResource[1] === ":") + ) { + createData.resource = newResource; + } else { + createData.resource = join( + fs, + dirname(fs, /** @type {string} */ (createData.resource)), + newResource + ); + } + } + } + }); + }); + } +} + +module.exports = NormalModuleReplacementPlugin; Index: frontend/node_modules/webpack/lib/NullFactory.js =================================================================== --- frontend/node_modules/webpack/lib/NullFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/NullFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,25 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const ModuleFactory = require("./ModuleFactory"); + +/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */ + +class NullFactory extends ModuleFactory { + /** + * Processes the provided data. + * @param {ModuleFactoryCreateData} data data object + * @param {ModuleFactoryCallback} callback callback + * @returns {void} + */ + create(data, callback) { + return callback(); + } +} + +module.exports = NullFactory; Index: frontend/node_modules/webpack/lib/OptimizationStages.js =================================================================== --- frontend/node_modules/webpack/lib/OptimizationStages.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/OptimizationStages.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,10 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Florent Cailhol @ooflorent +*/ + +"use strict"; + +module.exports.STAGE_ADVANCED = 10; +module.exports.STAGE_BASIC = -10; +module.exports.STAGE_DEFAULT = 0; Index: frontend/node_modules/webpack/lib/OptionsApply.js =================================================================== --- frontend/node_modules/webpack/lib/OptionsApply.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/OptionsApply.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,25 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./config/normalization").WebpackOptionsInterception} WebpackOptionsInterception */ +/** @typedef {import("./Compiler")} Compiler */ + +class OptionsApply { + /** + * Returns options object. + * @param {WebpackOptions} options options object + * @param {Compiler} compiler compiler object + * @param {WebpackOptionsInterception=} interception intercepted options + * @returns {WebpackOptions} options object + */ + process(options, compiler, interception) { + return options; + } +} + +module.exports = OptionsApply; Index: frontend/node_modules/webpack/lib/Parser.js =================================================================== --- frontend/node_modules/webpack/lib/Parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./NormalModule")} NormalModule */ + +/** @typedef {Record} PreparsedAst */ + +/** + * Defines the parser state base type used by this module. + * @typedef {object} ParserStateBase + * @property {string | Buffer} source + * @property {NormalModule} current + * @property {NormalModule} module + * @property {Compilation} compilation + * @property {WebpackOptions} options + */ + +/** @typedef {ParserStateBase & Record} ParserState */ + +class Parser { + /* istanbul ignore next */ + /** + * Parses the provided source and updates the parser state. + * @abstract + * @param {string | Buffer | PreparsedAst} source the source to parse + * @param {ParserState} state the parser state + * @returns {ParserState} the parser state + */ + parse(source, state) { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } +} + +module.exports = Parser; Index: frontend/node_modules/webpack/lib/PlatformPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/PlatformPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/PlatformPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Authors Ivan Kopeykin @vankop +*/ + +"use strict"; + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */ + +const PLUGIN_NAME = "PlatformPlugin"; + +/** + * Should be used only for "target === false" or + * when you want to overwrite platform target properties + */ +class PlatformPlugin { + /** + * Creates an instance of PlatformPlugin. + * @param {Partial} platform target properties + */ + constructor(platform) { + /** @type {Partial} */ + this.platform = platform; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.environment.tap(PLUGIN_NAME, () => { + compiler.platform = { + ...compiler.platform, + ...this.platform + }; + }); + } +} + +module.exports = PlatformPlugin; Index: frontend/node_modules/webpack/lib/PrefetchPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/PrefetchPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/PrefetchPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,57 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const PrefetchDependency = require("./dependencies/PrefetchDependency"); + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "PrefetchPlugin"; + +class PrefetchPlugin { + /** + * Creates an instance of PrefetchPlugin. + * @param {string} context context or request if context is not set + * @param {string=} request request + */ + constructor(context, request) { + if (request) { + this.context = context; + this.request = request; + } else { + this.context = null; + this.request = context; + } + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyFactories.set( + PrefetchDependency, + normalModuleFactory + ); + } + ); + compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => { + compilation.addModuleChain( + this.context || compiler.context, + new PrefetchDependency(this.request), + (err) => { + callback(err); + } + ); + }); + } +} + +module.exports = PrefetchPlugin; Index: frontend/node_modules/webpack/lib/ProgressPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ProgressPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ProgressPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,812 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Compiler = require("./Compiler"); +const MultiCompiler = require("./MultiCompiler"); +const NormalModule = require("./NormalModule"); +const { contextify } = require("./util/identifier"); +const memoize = require("./util/memoize"); + +const getColors = memoize(() => { + const cli = require("./cli"); + + return cli.createColors({ useColor: cli.isColorSupported() }); +}); + +const BAR_LENGTH = 25; +const BLOCK_CHAR = "━"; +const BULLET_ICON = "●"; + +/** @typedef {import("tapable").Tap} Tap */ +/** + * Defines the hook type used by this module. + * @template T, R, AdditionalOptions + * @typedef {import("tapable").Hook} Hook + */ +/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */ +/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */ +/** @typedef {import("./Compilation").FactorizeModuleOptions} FactorizeModuleOptions */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */ +/** @typedef {import("./logging/Logger").Logger} Logger */ +/** @typedef {import("./cli").Colors} Colors */ + +/** + * Defines the async queue type used by this module. + * @template T, K, R + * @typedef {import("./util/AsyncQueue")} AsyncQueue + */ + +/** + * Defines the counts data type used by this module. + * @typedef {object} CountsData + * @property {number} modulesCount modules count + * @property {number} dependenciesCount dependencies count + */ + +/** + * Returns median. + * @param {number} a a + * @param {number} b b + * @param {number} c c + * @returns {number} median + */ +const median3 = (a, b, c) => a + b + c - Math.max(a, b, c) - Math.min(a, b, c); + +/** @typedef {(percentage: number, msg: string, ...args: string[]) => void} HandlerFn */ + +/** + * @param {Logger} logger logger + * @param {{ value: string | undefined, time: number }[]} lastStateInfo mutable state + * @param {number} percentage percentage + * @param {string} msg msg + * @param {string[]} args args + */ +const reportProfile = (logger, lastStateInfo, percentage, msg, args) => { + if (percentage === 0) { + lastStateInfo.length = 0; + } + const fullState = [msg, ...args]; + const state = fullState.map((s) => s.replace(/\d+\/\d+ /g, "")); + const now = Date.now(); + const len = Math.max(state.length, lastStateInfo.length); + for (let i = len; i >= 0; i--) { + const stateItem = i < state.length ? state[i] : undefined; + const lastStateItem = + i < lastStateInfo.length ? lastStateInfo[i] : undefined; + if (lastStateItem) { + if (stateItem !== lastStateItem.value) { + const diff = now - lastStateItem.time; + if (lastStateItem.value) { + let reportState = lastStateItem.value; + if (i > 0) { + reportState = `${lastStateInfo[i - 1].value} > ${reportState}`; + } + const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`; + const d = diff; + // This depends on timing so we ignore it for coverage + /* eslint-disable no-lone-blocks */ + /* istanbul ignore next */ + { + if (d > 10000) { + logger.error(stateMsg); + } else if (d > 1000) { + logger.warn(stateMsg); + } else if (d > 10) { + logger.info(stateMsg); + } else if (d > 5) { + logger.log(stateMsg); + } else { + logger.debug(stateMsg); + } + } + /* eslint-enable no-lone-blocks */ + } + if (stateItem === undefined) { + lastStateInfo.length = i; + } else { + lastStateItem.value = stateItem; + lastStateItem.time = now; + lastStateInfo.length = i + 1; + } + } + } else { + lastStateInfo[i] = { + value: stateItem, + time: now + }; + } + } +}; + +/** + * @param {string} name progress bar name + * @param {string} color progress bar color + * @returns {(percentage: number) => string} bar renderer + */ +const createReportBar = (name, color) => { + const c = getColors(); + + return (percentage) => { + const w = Math.round(percentage * BAR_LENGTH); + const filled = BLOCK_CHAR.repeat(w); + const empty = BLOCK_CHAR.repeat(BAR_LENGTH - w); + const colorFn = + color in c ? c[/** @type {keyof Colors} */ (color)] : c.green; + + return `${[BULLET_ICON, name, filled].map(colorFn).join(" ")}${c.white(empty)}`; + }; +}; + +/** @typedef {Required, boolean>>} ProgressBarOptions */ + +/** + * Creates a default handler. + * @param {boolean | null | undefined} profile need profile + * @param {Logger} logger logger + * @param {ProgressBarOptions | false} progressBar render bar + * @returns {HandlerFn} default handler + */ +const createDefaultHandler = (profile, logger, progressBar) => { + /** @type {{ value: string | undefined, time: number }[]} */ + const lastStateInfo = []; + + /** @type {HandlerFn} */ + const defaultHandler = (percentage, msg, ...args) => { + if (profile) { + reportProfile(logger, lastStateInfo, percentage, msg, args); + } + + if (progressBar) { + const reportBar = createReportBar(progressBar.name, progressBar.color); + const c = getColors(); + /** @type {string} */ + const currentBar = reportBar(percentage); + + if (percentage === 1) { + logger.status(); + } else if (msg) { + logger.status( + `${currentBar} (${Math.floor(percentage * 100)}%)`, + `\n${[msg, ...args].map(c.gray).join(" ")}` + ); + } else { + logger.status(`${currentBar} (${Math.floor(percentage * 100)}%)`); + } + return; + } + + logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args); + if (percentage === 1 || (!msg && args.length === 0)) logger.status(); + }; + + return defaultHandler; +}; + +const SKIPPED_QUEUE_CONTEXTS = ["import-module", "load-module"]; + +/** + * Defines the report progress callback. + * @callback ReportProgress + * @param {number} p percentage + * @param {...string} args additional arguments + * @returns {void} + */ + +/** @type {WeakMap} */ +const progressReporters = new WeakMap(); + +const PLUGIN_NAME = "ProgressPlugin"; + +/** @type {Required>} */ +const DEFAULT_OPTIONS = { + profile: false, + modulesCount: 5000, + dependenciesCount: 10000, + modules: true, + dependencies: true, + activeModules: false, + entries: true, + percentBy: null, + progressBar: false +}; + +class ProgressPlugin { + /** + * Returns a progress reporter, if any. + * @param {Compiler} compiler the current compiler + * @returns {ReportProgress | undefined} a progress reporter, if any + */ + static getReporter(compiler) { + return progressReporters.get(compiler); + } + + /** + * Creates an instance of ProgressPlugin. + * @param {ProgressPluginArgument} options options + */ + constructor(options = {}) { + if (typeof options === "function") { + options = { + handler: options + }; + } + + /** @type {ProgressPluginOptions} */ + this.options = options; + + const merged = { ...DEFAULT_OPTIONS, ...options }; + this.profile = merged.profile; + this.handler = merged.handler; + this.modulesCount = merged.modulesCount; + this.dependenciesCount = merged.dependenciesCount; + this.showEntries = merged.entries; + this.showModules = merged.modules; + this.showDependencies = merged.dependencies; + this.showActiveModules = merged.activeModules; + this.percentBy = merged.percentBy; + + const progressBar = merged.progressBar === true ? {} : merged.progressBar; + /** @type {ProgressBarOptions | false} */ + this.progressBar = progressBar + ? { name: "Build", color: "green", ...progressBar } + : false; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler | MultiCompiler} compiler webpack compiler + * @returns {void} + */ + apply(compiler) { + const handler = + this.handler || + createDefaultHandler( + this.profile, + compiler.getInfrastructureLogger("webpack.Progress"), + this.progressBar + ); + if (compiler instanceof MultiCompiler) { + this._applyOnMultiCompiler(compiler, handler); + } else if (compiler instanceof Compiler) { + this._applyOnCompiler(compiler, handler); + } + } + + /** + * Apply on multi compiler. + * @param {MultiCompiler} compiler webpack multi-compiler + * @param {HandlerFn} handler function that executes for every progress step + * @returns {void} + */ + _applyOnMultiCompiler(compiler, handler) { + const states = compiler.compilers.map( + () => /** @type {[number, ...string[]]} */ ([0]) + ); + for (const [idx, item] of compiler.compilers.entries()) { + new ProgressPlugin((p, msg, ...args) => { + states[idx] = [p, msg, ...args]; + let sum = 0; + for (const [p] of states) sum += p; + handler(sum / states.length, `[${idx}] ${msg}`, ...args); + }).apply(item); + } + } + + /** + * Processes the provided compiler. + * @param {Compiler} compiler webpack compiler + * @param {HandlerFn} handler function that executes for every progress step + * @returns {void} + */ + _applyOnCompiler(compiler, handler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => require("../schemas/plugins/ProgressPlugin.json"), + this.options, + { + name: "Progress Plugin", + baseDataPath: "options" + }, + (options) => require("../schemas/plugins/ProgressPlugin.check")(options) + ); + }); + + const showEntries = this.showEntries; + const showModules = this.showModules; + const showDependencies = this.showDependencies; + const showActiveModules = this.showActiveModules; + let lastActiveModule = ""; + let currentLoader = ""; + let lastModulesCount = 0; + let lastDependenciesCount = 0; + let lastEntriesCount = 0; + let modulesCount = 0; + let skippedModulesCount = 0; + let dependenciesCount = 0; + let skippedDependenciesCount = 0; + let entriesCount = 1; + let doneModules = 0; + let doneDependencies = 0; + let doneEntries = 0; + /** @type {Set} */ + const activeModules = new Set(); + let lastUpdate = 0; + + const updateThrottled = () => { + if (lastUpdate + 500 < Date.now()) update(); + }; + + const update = () => { + /** @type {string[]} */ + const items = []; + const percentByModules = + doneModules / + Math.max(lastModulesCount || this.modulesCount || 1, modulesCount); + const percentByEntries = + doneEntries / + Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount); + const percentByDependencies = + doneDependencies / + Math.max(lastDependenciesCount || 1, dependenciesCount); + /** @type {number} */ + let percentageFactor; + + switch (this.percentBy) { + case "entries": + percentageFactor = percentByEntries; + break; + case "dependencies": + percentageFactor = percentByDependencies; + break; + case "modules": + percentageFactor = percentByModules; + break; + default: + percentageFactor = median3( + percentByModules, + percentByEntries, + percentByDependencies + ); + } + + const percentage = 0.1 + percentageFactor * 0.55; + + if (currentLoader) { + items.push( + `import loader ${contextify( + compiler.context, + currentLoader, + compiler.root + )}` + ); + } else { + /** @type {string[]} */ + const statItems = []; + if (showEntries) { + statItems.push(`${doneEntries}/${entriesCount} entries`); + } + if (showDependencies) { + statItems.push( + `${doneDependencies}/${dependenciesCount} dependencies` + ); + } + if (showModules) { + statItems.push(`${doneModules}/${modulesCount} modules`); + } + if (showActiveModules) { + statItems.push(`${activeModules.size} active`); + } + if (statItems.length > 0) { + items.push(statItems.join(" ")); + } + if (showActiveModules) { + items.push(lastActiveModule); + } + } + handler(percentage, "building", ...items); + lastUpdate = Date.now(); + }; + + /** + * Processes the provided factorize queue. + * @template T + * @param {AsyncQueue} factorizeQueue async queue + * @param {T} _item item + */ + const factorizeAdd = (factorizeQueue, _item) => { + if (SKIPPED_QUEUE_CONTEXTS.includes(factorizeQueue.getContext())) { + skippedDependenciesCount++; + } + dependenciesCount++; + if (dependenciesCount < 50 || dependenciesCount % 100 === 0) { + updateThrottled(); + } + }; + + const factorizeDone = () => { + doneDependencies++; + if (doneDependencies < 50 || doneDependencies % 100 === 0) { + updateThrottled(); + } + }; + + /** + * Processes the provided add module queue. + * @template T + * @param {AsyncQueue} addModuleQueue async queue + * @param {T} _item item + */ + const moduleAdd = (addModuleQueue, _item) => { + if (SKIPPED_QUEUE_CONTEXTS.includes(addModuleQueue.getContext())) { + skippedModulesCount++; + } + modulesCount++; + if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled(); + }; + + // only used when showActiveModules is set + /** + * Processes the provided module. + * @param {Module} module the module + */ + const moduleBuild = (module) => { + const ident = module.identifier(); + if (ident) { + activeModules.add(ident); + lastActiveModule = ident; + update(); + } + }; + + /** + * Processes the provided entry. + * @param {Dependency} entry entry dependency + * @param {EntryOptions} options options object + */ + const entryAdd = (entry, options) => { + entriesCount++; + if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled(); + }; + + /** + * Processes the provided module. + * @param {Module} module the module + */ + const moduleDone = (module) => { + doneModules++; + if (showActiveModules) { + const ident = module.identifier(); + if (ident) { + activeModules.delete(ident); + if (lastActiveModule === ident) { + lastActiveModule = ""; + for (const m of activeModules) { + lastActiveModule = m; + } + update(); + return; + } + } + } + if (doneModules < 50 || doneModules % 100 === 0) updateThrottled(); + }; + + /** + * Processes the provided entry. + * @param {Dependency} entry entry dependency + * @param {EntryOptions} options options object + */ + const entryDone = (entry, options) => { + doneEntries++; + update(); + }; + + const cache = compiler.getCache(PLUGIN_NAME).getItemCache("counts", null); + + /** @type {Promise | undefined} */ + let cacheGetPromise; + + compiler.hooks.beforeCompile.tap(PLUGIN_NAME, () => { + if (!cacheGetPromise) { + cacheGetPromise = cache.getPromise().then( + (data) => { + if (data) { + lastModulesCount = lastModulesCount || data.modulesCount; + lastDependenciesCount = + lastDependenciesCount || data.dependenciesCount; + } + return data; + }, + (_err) => { + // Ignore error + } + ); + } + }); + + compiler.hooks.afterCompile.tapPromise(PLUGIN_NAME, (compilation) => { + if (compilation.compiler.isChild()) return Promise.resolve(); + return /** @type {Promise} */ (cacheGetPromise).then( + async (oldData) => { + const realModulesCount = modulesCount - skippedModulesCount; + const realDependenciesCount = + dependenciesCount - skippedDependenciesCount; + + if ( + !oldData || + oldData.modulesCount !== realModulesCount || + oldData.dependenciesCount !== realDependenciesCount + ) { + await cache.storePromise({ + modulesCount: realModulesCount, + dependenciesCount: realDependenciesCount + }); + } + } + ); + }); + + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + if (compilation.compiler.isChild()) return; + lastModulesCount = modulesCount; + lastEntriesCount = entriesCount; + lastDependenciesCount = dependenciesCount; + modulesCount = + skippedModulesCount = + dependenciesCount = + skippedDependenciesCount = + entriesCount = + 0; + doneModules = doneDependencies = doneEntries = 0; + + compilation.factorizeQueue.hooks.added.tap(PLUGIN_NAME, (item) => + factorizeAdd(compilation.factorizeQueue, item) + ); + compilation.factorizeQueue.hooks.result.tap(PLUGIN_NAME, factorizeDone); + + compilation.addModuleQueue.hooks.added.tap(PLUGIN_NAME, (item) => + moduleAdd(compilation.addModuleQueue, item) + ); + compilation.processDependenciesQueue.hooks.result.tap( + PLUGIN_NAME, + moduleDone + ); + + if (showActiveModules) { + compilation.hooks.buildModule.tap(PLUGIN_NAME, moduleBuild); + } + + compilation.hooks.addEntry.tap(PLUGIN_NAME, entryAdd); + compilation.hooks.failedEntry.tap(PLUGIN_NAME, entryDone); + compilation.hooks.succeedEntry.tap(PLUGIN_NAME, entryDone); + + // @ts-expect-error avoid dynamic require if bundled with webpack + if (typeof __webpack_require__ !== "function") { + /** @type {Set} */ + const requiredLoaders = new Set(); + NormalModule.getCompilationHooks(compilation).beforeLoaders.tap( + PLUGIN_NAME, + (loaders) => { + for (const loader of loaders) { + if ( + loader.type !== "module" && + !requiredLoaders.has(loader.loader) + ) { + requiredLoaders.add(loader.loader); + currentLoader = loader.loader; + update(); + require(loader.loader); + } + } + if (currentLoader) { + currentLoader = ""; + update(); + } + } + ); + } + + const hooks = { + finishModules: "finish module graph", + seal: "plugins", + optimizeDependencies: "dependencies optimization", + afterOptimizeDependencies: "after dependencies optimization", + beforeChunks: "chunk graph", + afterChunks: "after chunk graph", + optimize: "optimizing", + optimizeModules: "module optimization", + afterOptimizeModules: "after module optimization", + optimizeChunks: "chunk optimization", + afterOptimizeChunks: "after chunk optimization", + optimizeTree: "module and chunk tree optimization", + afterOptimizeTree: "after module and chunk tree optimization", + optimizeChunkModules: "chunk modules optimization", + afterOptimizeChunkModules: "after chunk modules optimization", + reviveModules: "module reviving", + beforeModuleIds: "before module ids", + moduleIds: "module ids", + optimizeModuleIds: "module id optimization", + afterOptimizeModuleIds: "module id optimization", + reviveChunks: "chunk reviving", + beforeChunkIds: "before chunk ids", + chunkIds: "chunk ids", + optimizeChunkIds: "chunk id optimization", + afterOptimizeChunkIds: "after chunk id optimization", + recordModules: "record modules", + recordChunks: "record chunks", + beforeModuleHash: "module hashing", + beforeCodeGeneration: "code generation", + beforeRuntimeRequirements: "runtime requirements", + beforeHash: "hashing", + afterHash: "after hashing", + recordHash: "record hash", + beforeModuleAssets: "module assets processing", + beforeChunkAssets: "chunk assets processing", + processAssets: "asset processing", + afterProcessAssets: "after asset optimization", + record: "recording", + afterSeal: "after seal" + }; + const numberOfHooks = Object.keys(hooks).length; + for (const [idx, name] of Object.keys(hooks).entries()) { + const title = hooks[/** @type {keyof typeof hooks} */ (name)]; + const percentage = (idx / numberOfHooks) * 0.25 + 0.7; + compilation.hooks[/** @type {keyof typeof hooks} */ (name)].intercept({ + name: PLUGIN_NAME, + call() { + handler(percentage, "sealing", title); + }, + done() { + progressReporters.set(compiler, undefined); + handler(percentage, "sealing", title); + }, + result() { + handler(percentage, "sealing", title); + }, + error() { + handler(percentage, "sealing", title); + }, + tap(tap) { + // p is percentage from 0 to 1 + // args is any number of messages in a hierarchical matter + progressReporters.set(compilation.compiler, (p, ...args) => { + handler(percentage, "sealing", title, tap.name, ...args); + }); + handler(percentage, "sealing", title, tap.name); + } + }); + } + }); + compiler.hooks.make.intercept({ + name: PLUGIN_NAME, + call() { + handler(0.1, "building"); + }, + done() { + handler(0.65, "building"); + } + }); + /** + * Processes the provided hook. + * @template {Hook} T + * @param {T} hook hook + * @param {number} progress progress from 0 to 1 + * @param {string} category category + * @param {string} name name + */ + const interceptHook = (hook, progress, category, name) => { + hook.intercept({ + name: PLUGIN_NAME, + call() { + handler(progress, category, name); + }, + done() { + progressReporters.set(compiler, undefined); + handler(progress, category, name); + }, + result() { + handler(progress, category, name); + }, + error() { + handler(progress, category, name); + }, + /** + * Processes the provided tap. + * @param {Tap} tap tap + */ + tap(tap) { + progressReporters.set(compiler, (p, ...args) => { + handler(progress, category, name, tap.name, ...args); + }); + handler(progress, category, name, tap.name); + } + }); + }; + compiler.cache.hooks.endIdle.intercept({ + name: PLUGIN_NAME, + call() { + handler(0, ""); + } + }); + interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle"); + compiler.hooks.beforeRun.intercept({ + name: PLUGIN_NAME, + call() { + handler(0, ""); + } + }); + interceptHook(compiler.hooks.beforeRun, 0.01, "setup", "before run"); + interceptHook(compiler.hooks.run, 0.02, "setup", "run"); + interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run"); + interceptHook( + compiler.hooks.normalModuleFactory, + 0.04, + "setup", + "normal module factory" + ); + interceptHook( + compiler.hooks.contextModuleFactory, + 0.05, + "setup", + "context module factory" + ); + interceptHook( + compiler.hooks.beforeCompile, + 0.06, + "setup", + "before compile" + ); + interceptHook(compiler.hooks.compile, 0.07, "setup", "compile"); + interceptHook(compiler.hooks.thisCompilation, 0.08, "setup", "compilation"); + interceptHook(compiler.hooks.compilation, 0.09, "setup", "compilation"); + interceptHook(compiler.hooks.finishMake, 0.69, "building", "finish"); + interceptHook(compiler.hooks.emit, 0.95, "emitting", "emit"); + interceptHook(compiler.hooks.afterEmit, 0.98, "emitting", "after emit"); + interceptHook(compiler.hooks.done, 0.99, "done", "plugins"); + compiler.hooks.done.intercept({ + name: PLUGIN_NAME, + done() { + handler(0.99, ""); + } + }); + interceptHook( + compiler.cache.hooks.storeBuildDependencies, + 0.99, + "cache", + "store build dependencies" + ); + interceptHook(compiler.cache.hooks.shutdown, 0.99, "cache", "shutdown"); + interceptHook(compiler.cache.hooks.beginIdle, 0.99, "cache", "begin idle"); + interceptHook( + compiler.hooks.watchClose, + 0.99, + "end", + "closing watch compilation" + ); + compiler.cache.hooks.beginIdle.intercept({ + name: PLUGIN_NAME, + done() { + handler(1, ""); + } + }); + compiler.cache.hooks.shutdown.intercept({ + name: PLUGIN_NAME, + done() { + handler(1, ""); + } + }); + } +} + +ProgressPlugin.defaultOptions = DEFAULT_OPTIONS; + +ProgressPlugin.createDefaultHandler = createDefaultHandler; + +module.exports = ProgressPlugin; Index: frontend/node_modules/webpack/lib/ProvidePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/ProvidePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ProvidePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,123 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const ConstDependency = require("./dependencies/ConstDependency"); +const ProvidedDependency = require("./dependencies/ProvidedDependency"); +const { approve } = require("./javascript/JavascriptParserHelpers"); + +/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ + +const PLUGIN_NAME = "ProvidePlugin"; + +class ProvidePlugin { + /** + * Creates an instance of ProvidePlugin. + * @param {Record} definitions the provided identifiers + */ + constructor(definitions) { + this.definitions = definitions; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const definitions = this.definitions; + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyTemplates.set( + ConstDependency, + new ConstDependency.Template() + ); + compilation.dependencyFactories.set( + ProvidedDependency, + normalModuleFactory + ); + compilation.dependencyTemplates.set( + ProvidedDependency, + new ProvidedDependency.Template() + ); + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + * @param {JavascriptParserOptions} parserOptions options + * @returns {void} + */ + const handler = (parser, parserOptions) => { + for (const name of Object.keys(definitions)) { + const request = [ + ...(Array.isArray(definitions[name]) + ? definitions[name] + : [definitions[name]]) + ]; + const splittedName = name.split("."); + if (splittedName.length > 0) { + for (const [i, _] of splittedName.slice(1).entries()) { + const name = splittedName.slice(0, i + 1).join("."); + parser.hooks.canRename.for(name).tap(PLUGIN_NAME, approve); + } + } + + parser.hooks.expression.for(name).tap(PLUGIN_NAME, (expr) => { + const nameIdentifier = name.includes(".") + ? `__webpack_provided_${name.replace(/\./g, "_dot_")}` + : name; + const dep = new ProvidedDependency( + request[0], + nameIdentifier, + request.slice(1), + /** @type {Range} */ (expr.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addDependency(dep); + return true; + }); + + parser.hooks.call.for(name).tap(PLUGIN_NAME, (expr) => { + const nameIdentifier = name.includes(".") + ? `__webpack_provided_${name.replace(/\./g, "_dot_")}` + : name; + const dep = new ProvidedDependency( + request[0], + nameIdentifier, + request.slice(1), + /** @type {Range} */ (expr.callee.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.callee.loc); + parser.state.module.addDependency(dep); + parser.walkExpressions(expr.arguments); + return true; + }); + } + }; + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } +} + +module.exports = ProvidePlugin; Index: frontend/node_modules/webpack/lib/RawModule.js =================================================================== --- frontend/node_modules/webpack/lib/RawModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/RawModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,192 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { OriginalSource, RawSource } = require("webpack-sources"); +const Module = require("./Module"); +const { + JAVASCRIPT_TYPE, + JAVASCRIPT_TYPES +} = require("./ModuleSourceTypeConstants"); +const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants"); +const makeSerializable = require("./util/makeSerializable"); + +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("./Generator").SourceTypes} SourceTypes */ +/** @typedef {import("./Module").BuildCallback} BuildCallback */ +/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */ +/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */ +/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */ +/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */ +/** @typedef {import("./Module").Sources} Sources */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ + +class RawModule extends Module { + /** + * Creates an instance of RawModule. + * @param {string} source source code + * @param {string} identifier unique identifier + * @param {string=} readableIdentifier readable identifier + * @param {ReadOnlyRuntimeRequirements=} runtimeRequirements runtime requirements needed for the source code + */ + constructor(source, identifier, readableIdentifier, runtimeRequirements) { + super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null); + this.sourceStr = source; + this.identifierStr = identifier || this.sourceStr; + this.readableIdentifierStr = readableIdentifier || this.identifierStr; + this.runtimeRequirements = runtimeRequirements || null; + } + + /** + * Returns the source types this module can generate. + * @returns {SourceTypes} types available (do not mutate) + */ + getSourceTypes() { + return JAVASCRIPT_TYPES; + } + + /** + * Returns the unique identifier used to reference this module. + * @returns {string} a unique identifier of the module + */ + identifier() { + return this.identifierStr; + } + + /** + * Returns the estimated size for the requested source type. + * @param {string=} type the source type for which the size should be estimated + * @returns {number} the estimated size of the module (must be non-zero) + */ + size(type) { + return Math.max(1, this.sourceStr.length); + } + + /** + * Returns a human-readable identifier for this module. + * @param {RequestShortener} requestShortener the request shortener + * @returns {string} a user readable identifier of the module + */ + readableIdentifier(requestShortener) { + return /** @type {string} */ ( + requestShortener.shorten(this.readableIdentifierStr) + ); + } + + /** + * Checks whether the module needs to be rebuilt for the current build state. + * @param {NeedBuildContext} context context info + * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild + * @returns {void} + */ + needBuild(context, callback) { + return callback(null, !this.buildMeta); + } + + /** + * Builds the module using the provided compilation context. + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {BuildCallback} callback callback function + * @returns {void} + */ + build(options, compilation, resolver, fs, callback) { + this.buildMeta = {}; + this.buildInfo = { + cacheable: true + }; + callback(); + } + + /** + * Gets side effects connection state. + * @param {ModuleGraph} moduleGraph the module graph + * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only + */ + getSideEffectsConnectionState(moduleGraph) { + if (this.factoryMeta !== undefined) { + if (this.factoryMeta.sideEffectFree) return false; + if (this.factoryMeta.sideEffectFree === false) return true; + } + return true; + } + + /** + * Generates code and runtime requirements for this module. + * @param {CodeGenerationContext} context context for code generation + * @returns {CodeGenerationResult} result + */ + codeGeneration(context) { + /** @type {Sources} */ + const sources = new Map(); + if (this.useSourceMap || this.useSimpleSourceMap) { + sources.set( + JAVASCRIPT_TYPE, + new OriginalSource(this.sourceStr, this.identifier()) + ); + } else { + sources.set(JAVASCRIPT_TYPE, new RawSource(this.sourceStr)); + } + return { sources, runtimeRequirements: this.runtimeRequirements }; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) { + hash.update(this.sourceStr); + super.updateHash(hash, context); + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + + write(this.sourceStr); + write(this.identifierStr); + write(this.readableIdentifierStr); + write(this.runtimeRequirements); + + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + + this.sourceStr = read(); + this.identifierStr = read(); + this.readableIdentifierStr = read(); + this.runtimeRequirements = read(); + + super.deserialize(context); + } +} + +makeSerializable(RawModule, "webpack/lib/RawModule"); + +module.exports = RawModule; Index: frontend/node_modules/webpack/lib/RecordIdsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/RecordIdsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/RecordIdsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,224 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { compareNumbers } = require("./util/comparators"); +const identifierUtils = require("./util/identifier"); + +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Module")} Module */ + +/** + * Defines the records chunks type used by this module. + * @typedef {object} RecordsChunks + * @property {Record=} byName + * @property {Record=} bySource + * @property {number[]=} usedIds + */ + +/** + * Defines the records modules type used by this module. + * @typedef {object} RecordsModules + * @property {Record=} byIdentifier + * @property {number[]=} usedIds + */ + +/** + * Defines the records type used by this module. + * @typedef {object} Records + * @property {RecordsChunks=} chunks + * @property {RecordsModules=} modules + */ + +/** + * Defines the record ids plugin options type used by this module. + * @typedef {object} RecordIdsPluginOptions + * @property {boolean=} portableIds true, when ids need to be portable + */ + +/** @typedef {Set} UsedIds */ + +const PLUGIN_NAME = "RecordIdsPlugin"; + +class RecordIdsPlugin { + /** + * Creates an instance of RecordIdsPlugin. + * @param {RecordIdsPluginOptions=} options object + */ + constructor(options) { + this.options = options || {}; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the Compiler + * @returns {void} + */ + apply(compiler) { + const portableIds = this.options.portableIds; + + const makePathsRelative = + identifierUtils.makePathsRelative.bindContextCache( + compiler.context, + compiler.root + ); + + /** + * Gets module identifier. + * @param {Module} module the module + * @returns {string} the (portable) identifier + */ + const getModuleIdentifier = (module) => { + if (portableIds) { + return makePathsRelative(module.identifier()); + } + return module.identifier(); + }; + + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + compilation.hooks.recordModules.tap(PLUGIN_NAME, (modules, records) => { + const chunkGraph = compilation.chunkGraph; + if (!records.modules) records.modules = {}; + if (!records.modules.byIdentifier) records.modules.byIdentifier = {}; + /** @type {UsedIds} */ + const usedIds = new Set(); + for (const module of modules) { + const moduleId = chunkGraph.getModuleId(module); + if (typeof moduleId !== "number") continue; + const identifier = getModuleIdentifier(module); + records.modules.byIdentifier[identifier] = moduleId; + usedIds.add(moduleId); + } + records.modules.usedIds = [...usedIds].sort(compareNumbers); + }); + compilation.hooks.reviveModules.tap(PLUGIN_NAME, (modules, records) => { + if (!records.modules) return; + if (records.modules.byIdentifier) { + const chunkGraph = compilation.chunkGraph; + /** @type {UsedIds} */ + const usedIds = new Set(); + for (const module of modules) { + const moduleId = chunkGraph.getModuleId(module); + if (moduleId !== null) continue; + const identifier = getModuleIdentifier(module); + const id = records.modules.byIdentifier[identifier]; + if (id === undefined) continue; + if (usedIds.has(id)) continue; + usedIds.add(id); + chunkGraph.setModuleId(module, id); + } + } + if (Array.isArray(records.modules.usedIds)) { + compilation.usedModuleIds = new Set(records.modules.usedIds); + } + }); + + /** @typedef {string[]} ChunkSources */ + + /** + * Gets chunk sources. + * @param {Chunk} chunk the chunk + * @returns {ChunkSources} sources of the chunk + */ + const getChunkSources = (chunk) => { + /** @type {ChunkSources} */ + const sources = []; + for (const chunkGroup of chunk.groupsIterable) { + const index = chunkGroup.chunks.indexOf(chunk); + if (chunkGroup.name) { + sources.push(`${index} ${chunkGroup.name}`); + } else { + for (const origin of chunkGroup.origins) { + if (origin.module) { + if (origin.request) { + sources.push( + `${index} ${getModuleIdentifier(origin.module)} ${ + origin.request + }` + ); + } else if (typeof origin.loc === "string") { + sources.push( + `${index} ${getModuleIdentifier(origin.module)} ${ + origin.loc + }` + ); + } else if ( + origin.loc && + typeof origin.loc === "object" && + "start" in origin.loc + ) { + sources.push( + `${index} ${getModuleIdentifier( + origin.module + )} ${JSON.stringify(origin.loc.start)}` + ); + } + } + } + } + } + return sources; + }; + + compilation.hooks.recordChunks.tap(PLUGIN_NAME, (chunks, records) => { + if (!records.chunks) records.chunks = {}; + if (!records.chunks.byName) records.chunks.byName = {}; + if (!records.chunks.bySource) records.chunks.bySource = {}; + /** @type {UsedIds} */ + const usedIds = new Set(); + for (const chunk of chunks) { + if (typeof chunk.id !== "number") continue; + const name = chunk.name; + if (name) records.chunks.byName[name] = chunk.id; + const sources = getChunkSources(chunk); + for (const source of sources) { + records.chunks.bySource[source] = chunk.id; + } + usedIds.add(chunk.id); + } + records.chunks.usedIds = [...usedIds].sort(compareNumbers); + }); + compilation.hooks.reviveChunks.tap(PLUGIN_NAME, (chunks, records) => { + if (!records.chunks) return; + /** @type {UsedIds} */ + const usedIds = new Set(); + if (records.chunks.byName) { + for (const chunk of chunks) { + if (chunk.id !== null) continue; + if (!chunk.name) continue; + const id = records.chunks.byName[chunk.name]; + if (id === undefined) continue; + if (usedIds.has(id)) continue; + usedIds.add(id); + chunk.id = id; + chunk.ids = [id]; + } + } + if (records.chunks.bySource) { + for (const chunk of chunks) { + if (chunk.id !== null) continue; + const sources = getChunkSources(chunk); + for (const source of sources) { + const id = records.chunks.bySource[source]; + if (id === undefined) continue; + if (usedIds.has(id)) continue; + usedIds.add(id); + chunk.id = id; + chunk.ids = [id]; + break; + } + } + } + if (Array.isArray(records.chunks.usedIds)) { + compilation.usedChunkIds = new Set(records.chunks.usedIds); + } + }); + }); + } +} + +module.exports = RecordIdsPlugin; Index: frontend/node_modules/webpack/lib/RequestShortener.js =================================================================== --- frontend/node_modules/webpack/lib/RequestShortener.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/RequestShortener.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,44 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { contextify } = require("./util/identifier"); + +/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */ + +/** + * Shortens absolute or verbose request strings so diagnostics and stats output + * can be rendered relative to a chosen base directory. + */ +class RequestShortener { + /** + * Binds a context-aware shortening function to the provided directory and + * optional cache owner. + * @param {string} dir the directory + * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached + */ + constructor(dir, associatedObjectForCache) { + this.contextify = contextify.bindContextCache( + dir, + associatedObjectForCache + ); + } + + /** + * Returns a request string rewritten relative to the configured directory + * when one is provided. + * @param {string | undefined | null} request the request to shorten + * @returns {string | undefined | null} the shortened request + */ + shorten(request) { + if (!request) { + return request; + } + return this.contextify(request); + } +} + +module.exports = RequestShortener; Index: frontend/node_modules/webpack/lib/ResolverFactory.js =================================================================== --- frontend/node_modules/webpack/lib/ResolverFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/ResolverFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,161 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Factory = require("enhanced-resolve").ResolverFactory; +const { HookMap, SyncHook, SyncWaterfallHook } = require("tapable"); +const { + cachedCleverMerge, + removeOperations, + resolveByProperty +} = require("./util/cleverMerge"); + +/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */ +/** @typedef {import("enhanced-resolve").Resolver} Resolver */ +/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} WebpackResolveOptions */ +/** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */ + +/** @typedef {WebpackResolveOptions & { dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */ +/** + * Defines the with options type used by this module. + * @typedef {object} WithOptions + * @property {(options: Partial) => ResolverWithOptions} withOptions create a resolver with additional/different options + */ + +/** @typedef {Resolver & WithOptions} ResolverWithOptions */ + +// need to be hoisted on module level for caching identity +/** @type {ResolveOptionsWithDependencyType} */ +const EMPTY_RESOLVE_OPTIONS = {}; + +/** + * Convert to resolve options. + * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType enhanced options + * @returns {ResolveOptions} merged options + */ +const convertToResolveOptions = (resolveOptionsWithDepType) => { + const { dependencyType, plugins, ...remaining } = resolveOptionsWithDepType; + + // check type compat + /** @type {Partial} */ + const partialOptions = { + ...remaining, + plugins: + plugins && + /** @type {ResolvePluginInstance[]} */ ( + plugins.filter((item) => item !== "...") + ) + }; + + if (!partialOptions.fileSystem) { + throw new Error( + "fileSystem is missing in resolveOptions, but it's required for enhanced-resolve" + ); + } + // These weird types validate that we checked all non-optional properties + const options = + /** @type {Partial & Pick} */ ( + partialOptions + ); + + return /** @type {ResolveOptions} */ ( + removeOperations( + resolveByProperty(options, "byDependency", dependencyType), + // Keep the `unsafeCache` because it can be a `Proxy` + ["unsafeCache"] + ) + ); +}; + +/** + * Represents the resolver factory runtime component. + * @typedef {object} ResolverCache + * @property {WeakMap} direct + * @property {Map} stringified + */ + +module.exports = class ResolverFactory { + constructor() { + this.hooks = Object.freeze({ + /** @type {HookMap>} */ + resolveOptions: new HookMap( + () => new SyncWaterfallHook(["resolveOptions"]) + ), + /** @type {HookMap>} */ + resolver: new HookMap( + () => new SyncHook(["resolver", "resolveOptions", "userResolveOptions"]) + ) + }); + /** @type {Map} */ + this.cache = new Map(); + } + + /** + * Returns the resolver. + * @param {string} type type of resolver + * @param {ResolveOptionsWithDependencyType=} resolveOptions options + * @returns {ResolverWithOptions} the resolver + */ + get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) { + let typedCaches = this.cache.get(type); + if (!typedCaches) { + typedCaches = { + direct: new WeakMap(), + stringified: new Map() + }; + this.cache.set(type, typedCaches); + } + const cachedResolver = typedCaches.direct.get(resolveOptions); + if (cachedResolver) { + return cachedResolver; + } + const ident = JSON.stringify(resolveOptions); + const resolver = typedCaches.stringified.get(ident); + if (resolver) { + typedCaches.direct.set(resolveOptions, resolver); + return resolver; + } + const newResolver = this._create(type, resolveOptions); + typedCaches.direct.set(resolveOptions, newResolver); + typedCaches.stringified.set(ident, newResolver); + return newResolver; + } + + /** + * Returns the resolver. + * @param {string} type type of resolver + * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType options + * @returns {ResolverWithOptions} the resolver + */ + _create(type, resolveOptionsWithDepType) { + /** @type {ResolveOptionsWithDependencyType} */ + const originalResolveOptions = { ...resolveOptionsWithDepType }; + + const resolveOptions = convertToResolveOptions( + this.hooks.resolveOptions.for(type).call(resolveOptionsWithDepType) + ); + const resolver = /** @type {ResolverWithOptions} */ ( + Factory.createResolver(resolveOptions) + ); + if (!resolver) { + throw new Error("No resolver created"); + } + /** @type {WeakMap, ResolverWithOptions>} */ + const childCache = new WeakMap(); + resolver.withOptions = (options) => { + const cacheEntry = childCache.get(options); + if (cacheEntry !== undefined) return cacheEntry; + const mergedOptions = cachedCleverMerge(originalResolveOptions, options); + const resolver = this.get(type, mergedOptions); + childCache.set(options, resolver); + return resolver; + }; + this.hooks.resolver + .for(type) + .call(resolver, resolveOptions, originalResolveOptions); + return resolver; + } +}; Index: frontend/node_modules/webpack/lib/RuntimeGlobals.js =================================================================== --- frontend/node_modules/webpack/lib/RuntimeGlobals.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/RuntimeGlobals.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,457 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** + * the AMD define function + */ +module.exports.amdDefine = "__webpack_require__.amdD"; + +/** + * the AMD options + */ +module.exports.amdOptions = "__webpack_require__.amdO"; + +/** + * Creates an async module. The body function must be a async function. + * "module.exports" will be decorated with an AsyncModulePromise. + * The body function will be called. + * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));". + * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function. + * Signature: function( + * module: Module, + * body: (handleDependencies: (deps: AsyncModulePromise[]) => Promise & () => void, + * hasAwaitAfterDependencies?: boolean + * ) => void + */ +module.exports.asyncModule = "__webpack_require__.a"; + +/** + * The internal symbol that asyncModule is using. + */ +module.exports.asyncModuleDoneSymbol = "__webpack_require__.aD"; + +/** + * The internal symbol that asyncModule is using. + */ +module.exports.asyncModuleExportSymbol = "__webpack_require__.aE"; + +/** + * the baseURI of current document + */ +module.exports.baseURI = "__webpack_require__.b"; + +/** + * global callback functions for installing chunks + */ +module.exports.chunkCallback = "webpackChunk"; + +/** + * the chunk name of the chunk with the runtime + */ +module.exports.chunkName = "__webpack_require__.cn"; + +/** + * compatibility get default export + */ +module.exports.compatGetDefaultExport = "__webpack_require__.n"; + +/** + * compile a wasm module from id and hash, returning WebAssembly.Module + */ +module.exports.compileWasm = "__webpack_require__.vs"; + +/** + * create a fake namespace object + */ +module.exports.createFakeNamespaceObject = "__webpack_require__.t"; + +/** + * function to promote a string to a TrustedScript using webpack's Trusted + * Types policy + * Arguments: (script: string) => TrustedScript + */ +module.exports.createScript = "__webpack_require__.ts"; + +/** + * function to promote a string to a TrustedScriptURL using webpack's Trusted + * Types policy + * Arguments: (url: string) => TrustedScriptURL + */ +module.exports.createScriptUrl = "__webpack_require__.tu"; + +module.exports.cssInjectStyle = "__webpack_require__.is"; + +/** + * The current scope when getting a module from a remote + */ +module.exports.currentRemoteGetScope = "__webpack_require__.R"; + +/** + * resolve async transitive dependencies for deferred module + */ +module.exports.deferredModuleAsyncTransitiveDependencies = + "__webpack_require__.zT"; + +/** + * the internal symbol for getting the async transitive dependencies for deferred module + */ +module.exports.deferredModuleAsyncTransitiveDependenciesSymbol = + "__webpack_require__.zS"; + +/** + * the exported property define getters function + */ +module.exports.definePropertyGetters = "__webpack_require__.d"; + +/** + * the chunk ensure function + */ +module.exports.ensureChunk = "__webpack_require__.e"; + +/** + * an object with handlers to ensure a chunk + */ +module.exports.ensureChunkHandlers = "__webpack_require__.f"; + +/** + * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries + */ +module.exports.ensureChunkIncludeEntries = + "__webpack_require__.f (include entries)"; + +/** + * the module id of the entry point + */ +module.exports.entryModuleId = "__webpack_require__.s"; + +/** + * esm module id + */ +module.exports.esmId = "__webpack_esm_id__"; + +/** + * esm module ids + */ +module.exports.esmIds = "__webpack_esm_ids__"; + +/** + * esm modules + */ +module.exports.esmModules = "__webpack_esm_modules__"; + +/** + * esm runtime + */ +module.exports.esmRuntime = "__webpack_esm_runtime__"; + +/** + * the internal exports object + */ +module.exports.exports = "__webpack_exports__"; + +/** + * method to install a chunk that was loaded somehow + * Signature: ({ id, ids, modules, runtime }) => void + */ +module.exports.externalInstallChunk = "__webpack_require__.C"; + +/** + * the filename of the css part of the chunk + */ +module.exports.getChunkCssFilename = "__webpack_require__.k"; + +/** + * the filename of the script part of the chunk + */ +module.exports.getChunkScriptFilename = "__webpack_require__.u"; + +/** + * the filename of the css part of the hot update chunk + */ +module.exports.getChunkUpdateCssFilename = "__webpack_require__.hk"; + +/** + * the filename of the script part of the hot update chunk + */ +module.exports.getChunkUpdateScriptFilename = "__webpack_require__.hu"; + +/** + * the webpack hash + */ +module.exports.getFullHash = "__webpack_require__.h"; + +/** + * function to return webpack's Trusted Types policy + * Arguments: () => TrustedTypePolicy + */ +module.exports.getTrustedTypesPolicy = "__webpack_require__.tt"; + +/** + * the filename of the HMR manifest + */ +module.exports.getUpdateManifestFilename = "__webpack_require__.hmrF"; + +/** + * the global object + */ +module.exports.global = "__webpack_require__.g"; + +/** + * harmony module decorator + */ +module.exports.harmonyModuleDecorator = "__webpack_require__.hmd"; + +/** + * a flag when a module/chunk/tree has css modules + */ +module.exports.hasCssModules = "has css modules"; + +/** + * a flag when a chunk has a fetch priority + */ +module.exports.hasFetchPriority = "has fetch priority"; + +/** + * the shorthand for Object.prototype.hasOwnProperty + * using of it decreases the compiled bundle size + */ +module.exports.hasOwnProperty = "__webpack_require__.o"; + +/** + * function downloading the update manifest + */ +module.exports.hmrDownloadManifest = "__webpack_require__.hmrM"; + +/** + * array with handler functions to download chunk updates + */ +module.exports.hmrDownloadUpdateHandlers = "__webpack_require__.hmrC"; + +/** + * array with handler functions when a module should be invalidated + */ +module.exports.hmrInvalidateModuleHandlers = "__webpack_require__.hmrI"; + +/** + * object with all hmr module data for all modules + */ +module.exports.hmrModuleData = "__webpack_require__.hmrD"; + +/** + * the prefix for storing state of runtime modules when hmr is enabled + */ +module.exports.hmrRuntimeStatePrefix = "__webpack_require__.hmrS"; + +/** + * The sharing init sequence function (only runs once per share scope). + * Has one argument, the name of the share scope. + * Creates a share scope if not existing + */ +module.exports.initializeSharing = "__webpack_require__.I"; + +/** + * instantiate a wasm instance from module exports object, id, hash and importsObject + */ +module.exports.instantiateWasm = "__webpack_require__.v"; + +/** + * interceptor for module executions + */ +module.exports.interceptModuleExecution = "__webpack_require__.i"; + +/** + * function to load a script tag. + * Arguments: (url: string, done: (event) => void), key?: string | number, chunkId?: string | number) => void + * done function is called when loading has finished or timeout occurred. + * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url. + */ +module.exports.loadScript = "__webpack_require__.l"; + +/** + * make a deferred namespace object + */ +module.exports.makeDeferredNamespaceObject = "__webpack_require__.z"; + +/** + * define compatibility on export + */ +module.exports.makeNamespaceObject = "__webpack_require__.r"; + +/** + * make a optimized deferred namespace object + */ +module.exports.makeOptimizedDeferredNamespaceObject = "__webpack_require__.zO"; + +/** + * the internal module object + */ +module.exports.module = "module"; + +/** + * the module cache + */ +module.exports.moduleCache = "__webpack_require__.c"; + +/** + * the module functions + */ +module.exports.moduleFactories = "__webpack_require__.m"; + +/** + * the module functions, with only write access + */ +module.exports.moduleFactoriesAddOnly = "__webpack_require__.m (add only)"; + +/** + * the internal module object + */ +module.exports.moduleId = "module.id"; + +/** + * the internal module object + */ +module.exports.moduleLoaded = "module.loaded"; + +/** + * node.js module decorator + */ +module.exports.nodeModuleDecorator = "__webpack_require__.nmd"; + +/** + * register deferred code, which will run when certain + * chunks are loaded. + * Signature: (chunkIds: Id[], fn: () => any, priority: int >= 0 = 0) => any + * Returned value will be returned directly when all chunks are already loaded + * When (priority & 1) it will wait for all other handlers with lower priority to + * be executed before itself is executed + */ +module.exports.onChunksLoaded = "__webpack_require__.O"; + +/** + * the chunk prefetch function + */ +module.exports.prefetchChunk = "__webpack_require__.E"; + +/** + * an object with handlers to prefetch a chunk + */ +module.exports.prefetchChunkHandlers = "__webpack_require__.F"; + +/** + * the chunk preload function + */ +module.exports.preloadChunk = "__webpack_require__.G"; + +/** + * an object with handlers to preload a chunk + */ +module.exports.preloadChunkHandlers = "__webpack_require__.H"; + +/** + * the bundle public path + */ +module.exports.publicPath = "__webpack_require__.p"; + +/** + * a RelativeURL class when relative URLs are used + */ +module.exports.relativeUrl = "__webpack_require__.U"; + +/** + * the internal require function + */ +module.exports.require = "__webpack_require__"; + +/** + * access to properties of the internal require function/object + */ +module.exports.requireScope = "__webpack_require__.*"; + +/** + * runtime need to return the exports of the last entry module + */ +module.exports.returnExportsFromRuntime = "return-exports-from-runtime"; + +/** + * the runtime id of the current runtime + */ +module.exports.runtimeId = "__webpack_require__.j"; + +/** + * the script nonce + */ +module.exports.scriptNonce = "__webpack_require__.nc"; + +/** + * set .name to "default" for anonymous default exports per ES spec + */ +module.exports.setAnonymousDefaultName = "__webpack_require__.dn"; + +/** + * an object with all share scopes + */ +module.exports.shareScopeMap = "__webpack_require__.S"; + +/** + * startup signal from runtime + * This will be called when the runtime chunk has been loaded. + */ +module.exports.startup = "__webpack_require__.x"; + +/** + * method to startup an entrypoint with needed chunks. + * Signature: (moduleId: Id, chunkIds: Id[]) => any. + * Returns the exports of the module or a Promise + */ +module.exports.startupEntrypoint = "__webpack_require__.X"; + +/** + * Describes how this item operation behaves. + * @deprecated + * creating a default startup function with the entry modules + */ +module.exports.startupNoDefault = "__webpack_require__.x (no default handler)"; + +/** + * startup signal from runtime but only used to add logic after the startup + */ +module.exports.startupOnlyAfter = "__webpack_require__.x (only after)"; + +/** + * startup signal from runtime but only used to add sync logic before the startup + */ +module.exports.startupOnlyBefore = "__webpack_require__.x (only before)"; + +/** + * the System polyfill object + */ +module.exports.system = "__webpack_require__.System"; + +/** + * the System.register context object + */ +module.exports.systemContext = "__webpack_require__.y"; + +/** + * top-level this need to be the exports object + */ +module.exports.thisAsExports = "top-level-this-exports"; + +/** + * to binary helper, convert base64 to Uint8Array + */ +module.exports.toBinary = "__webpack_require__.tb"; + +/** + * the uncaught error handler for the webpack runtime + */ +module.exports.uncaughtErrorHandler = "__webpack_require__.oe"; + +/** + * an object containing all installed WebAssembly.Instance export objects keyed by module id + */ +module.exports.wasmInstances = "__webpack_require__.w"; Index: frontend/node_modules/webpack/lib/RuntimeModule.js =================================================================== --- frontend/node_modules/webpack/lib/RuntimeModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/RuntimeModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,257 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { RawSource } = require("webpack-sources"); +const OriginalSource = require("webpack-sources").OriginalSource; +const Module = require("./Module"); +const { + JAVASCRIPT_TYPES, + RUNTIME_TYPES +} = require("./ModuleSourceTypeConstants"); +const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants"); + +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("./Generator").SourceTypes} SourceTypes */ +/** @typedef {import("./Module").BuildMeta} BuildMeta */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./Module").BuildCallback} BuildCallback */ +/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */ +/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */ +/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */ +/** @typedef {import("./Module").Sources} Sources */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("./util/Hash")} Hash */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./Module").BasicSourceTypes} BasicSourceTypes */ + +class RuntimeModule extends Module { + /** + * Creates an instance of RuntimeModule. + * @param {string} name a readable name + * @param {number=} stage an optional stage + */ + constructor(name, stage = 0) { + super(WEBPACK_MODULE_TYPE_RUNTIME); + /** @type {string} */ + this.name = name; + /** @type {number} */ + this.stage = stage; + /** @type {BuildMeta} */ + this.buildMeta = {}; + /** @type {BuildInfo} */ + this.buildInfo = {}; + /** @type {Compilation | undefined} */ + this.compilation = undefined; + /** @type {Chunk | undefined} */ + this.chunk = undefined; + /** @type {ChunkGraph | undefined} */ + this.chunkGraph = undefined; + /** @type {boolean} */ + this.fullHash = false; + /** @type {boolean} */ + this.dependentHash = false; + /** @type {string | undefined | null} */ + this._cachedGeneratedCode = undefined; + } + + /** + * Processes the provided compilation. + * @param {Compilation} compilation the compilation + * @param {Chunk} chunk the chunk + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {void} + */ + attach(compilation, chunk, chunkGraph = compilation.chunkGraph) { + this.compilation = compilation; + this.chunk = chunk; + this.chunkGraph = chunkGraph; + } + + /** + * Returns the unique identifier used to reference this module. + * @returns {string} a unique identifier of the module + */ + identifier() { + return `webpack/runtime/${this.name}`; + } + + /** + * Returns a human-readable identifier for this module. + * @param {RequestShortener} requestShortener the request shortener + * @returns {string} a user readable identifier of the module + */ + readableIdentifier(requestShortener) { + return `webpack/runtime/${this.name}`; + } + + /** + * Checks whether the module needs to be rebuilt for the current build state. + * @param {NeedBuildContext} context context info + * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild + * @returns {void} + */ + needBuild(context, callback) { + return callback(null, false); + } + + /** + * Builds the module using the provided compilation context. + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {BuildCallback} callback callback function + * @returns {void} + */ + build(options, compilation, resolver, fs, callback) { + // do nothing + // should not be called as runtime modules are added later to the compilation + callback(); + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) { + hash.update(this.name); + hash.update(`${this.stage}`); + try { + const code = + this.fullHash || this.dependentHash + ? // Do not use getGeneratedCode here, because i. e. compilation hash might be not + // ready at this point. We will cache it later instead. + this.generate() + : this.getGeneratedCode(); + if (code !== null && code !== undefined) { + hash.update(code); + } + } catch (err) { + hash.update(/** @type {Error} */ (err).message); + } + super.updateHash(hash, context); + } + + /** + * Returns the source types this module can generate. + * @returns {SourceTypes} types available (do not mutate) + */ + getSourceTypes() { + return RUNTIME_TYPES; + } + + /** + * Basic source types are high-level categories like javascript, css, webassembly, etc. + * We only have built-in knowledge about the javascript basic type here; other basic types may be + * added or changed over time by generators and do not need to be handled or detected here. + * + * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init" + * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS. + * @returns {BasicSourceTypes} types available (do not mutate) + */ + getSourceBasicTypes() { + return JAVASCRIPT_TYPES; + } + + /** + * Generates code and runtime requirements for this module. + * @param {CodeGenerationContext} context context for code generation + * @returns {CodeGenerationResult} result + */ + codeGeneration(context) { + /** @type {Sources} */ + const sources = new Map(); + const generatedCode = this.getGeneratedCode(); + if (generatedCode) { + sources.set( + WEBPACK_MODULE_TYPE_RUNTIME, + this.useSourceMap || this.useSimpleSourceMap + ? new OriginalSource(generatedCode, this.identifier()) + : new RawSource(generatedCode) + ); + } + return { + sources, + runtimeRequirements: null + }; + } + + /** + * Returns the estimated size for the requested source type. + * @param {string=} type the source type for which the size should be estimated + * @returns {number} the estimated size of the module (must be non-zero) + */ + size(type) { + try { + const source = this.getGeneratedCode(); + return source ? source.length : 0; + } catch (_err) { + return 0; + } + } + + /* istanbul ignore next */ + /** + * Generates runtime code for this runtime module. + * @abstract + * @returns {string | null} runtime code + */ + generate() { + const AbstractMethodError = require("./errors/AbstractMethodError"); + + throw new AbstractMethodError(); + } + + /** + * Gets generated code. + * @returns {string | null} runtime code + */ + getGeneratedCode() { + if (this._cachedGeneratedCode) { + return this._cachedGeneratedCode; + } + return (this._cachedGeneratedCode = this.generate()); + } + + /** + * Returns true, if the runtime module should get it's own scope. + * @returns {boolean} true, if the runtime module should get it's own scope + */ + shouldIsolate() { + return true; + } +} + +/** + * Runtime modules without any dependencies to other runtime modules + */ +RuntimeModule.STAGE_NORMAL = 0; + +/** + * Runtime modules with simple dependencies on other runtime modules + */ +RuntimeModule.STAGE_BASIC = 5; + +/** + * Runtime modules which attach to handlers of other runtime modules + */ +RuntimeModule.STAGE_ATTACH = 10; + +/** + * Runtime modules which trigger actions on bootstrap + */ +RuntimeModule.STAGE_TRIGGER = 20; + +module.exports = RuntimeModule; Index: frontend/node_modules/webpack/lib/RuntimePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/RuntimePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/RuntimePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,560 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const RuntimeGlobals = require("./RuntimeGlobals"); +const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirementsDependency"); +const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin"); +const AsyncModuleRuntimeModule = require("./runtime/AsyncModuleRuntimeModule"); +const AutoPublicPathRuntimeModule = require("./runtime/AutoPublicPathRuntimeModule"); +const BaseUriRuntimeModule = require("./runtime/BaseUriRuntimeModule"); +const CompatGetDefaultExportRuntimeModule = require("./runtime/CompatGetDefaultExportRuntimeModule"); +const CompatRuntimeModule = require("./runtime/CompatRuntimeModule"); +const CreateFakeNamespaceObjectRuntimeModule = require("./runtime/CreateFakeNamespaceObjectRuntimeModule"); +const CreateScriptRuntimeModule = require("./runtime/CreateScriptRuntimeModule"); +const CreateScriptUrlRuntimeModule = require("./runtime/CreateScriptUrlRuntimeModule"); +const DefinePropertyGettersRuntimeModule = require("./runtime/DefinePropertyGettersRuntimeModule"); +const EnsureChunkRuntimeModule = require("./runtime/EnsureChunkRuntimeModule"); +const GetChunkFilenameRuntimeModule = require("./runtime/GetChunkFilenameRuntimeModule"); +const GetMainFilenameRuntimeModule = require("./runtime/GetMainFilenameRuntimeModule"); +const GetTrustedTypesPolicyRuntimeModule = require("./runtime/GetTrustedTypesPolicyRuntimeModule"); +const GlobalRuntimeModule = require("./runtime/GlobalRuntimeModule"); +const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModule"); +const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule"); +const { + MakeDeferredNamespaceObjectRuntimeModule, + MakeOptimizedDeferredNamespaceObjectRuntimeModule +} = require("./runtime/MakeDeferredNamespaceObjectRuntime"); +const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule"); +const NonceRuntimeModule = require("./runtime/NonceRuntimeModule"); +const OnChunksLoadedRuntimeModule = require("./runtime/OnChunksLoadedRuntimeModule"); +const PublicPathRuntimeModule = require("./runtime/PublicPathRuntimeModule"); +const RelativeUrlRuntimeModule = require("./runtime/RelativeUrlRuntimeModule"); +const RuntimeIdRuntimeModule = require("./runtime/RuntimeIdRuntimeModule"); +const SetAnonymousDefaultNameRuntimeModule = require("./runtime/SetAnonymousDefaultNameRuntimeModule"); +const SystemContextRuntimeModule = require("./runtime/SystemContextRuntimeModule"); +const ToBinaryRuntimeModule = require("./runtime/ToBinaryRuntimeModule"); +const ShareRuntimeModule = require("./sharing/ShareRuntimeModule"); +const StringXor = require("./util/StringXor"); +const memoize = require("./util/memoize"); + +/** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Compiler")} Compiler */ + +const getJavascriptModulesPlugin = memoize(() => + require("./javascript/JavascriptModulesPlugin") +); +const getCssModulesPlugin = memoize(() => require("./css/CssModulesPlugin")); + +const GLOBALS_ON_REQUIRE = [ + RuntimeGlobals.chunkName, + RuntimeGlobals.runtimeId, + RuntimeGlobals.compatGetDefaultExport, + RuntimeGlobals.createFakeNamespaceObject, + RuntimeGlobals.createScript, + RuntimeGlobals.createScriptUrl, + RuntimeGlobals.getTrustedTypesPolicy, + RuntimeGlobals.definePropertyGetters, + RuntimeGlobals.ensureChunk, + RuntimeGlobals.entryModuleId, + RuntimeGlobals.getFullHash, + RuntimeGlobals.global, + RuntimeGlobals.makeNamespaceObject, + RuntimeGlobals.moduleCache, + RuntimeGlobals.moduleFactories, + RuntimeGlobals.moduleFactoriesAddOnly, + RuntimeGlobals.interceptModuleExecution, + RuntimeGlobals.publicPath, + RuntimeGlobals.baseURI, + RuntimeGlobals.relativeUrl, + // TODO webpack 6 - rename to nonce, because we use it for CSS too + RuntimeGlobals.scriptNonce, + RuntimeGlobals.uncaughtErrorHandler, + RuntimeGlobals.asyncModule, + RuntimeGlobals.wasmInstances, + RuntimeGlobals.instantiateWasm, + RuntimeGlobals.shareScopeMap, + RuntimeGlobals.initializeSharing, + RuntimeGlobals.loadScript, + RuntimeGlobals.setAnonymousDefaultName, + RuntimeGlobals.systemContext, + RuntimeGlobals.onChunksLoaded, + RuntimeGlobals.makeOptimizedDeferredNamespaceObject, + RuntimeGlobals.makeDeferredNamespaceObject +]; + +const MODULE_DEPENDENCIES = { + [RuntimeGlobals.moduleLoaded]: [RuntimeGlobals.module], + [RuntimeGlobals.moduleId]: [RuntimeGlobals.module] +}; + +const TREE_DEPENDENCIES = { + [RuntimeGlobals.definePropertyGetters]: [RuntimeGlobals.hasOwnProperty], + [RuntimeGlobals.compatGetDefaultExport]: [ + RuntimeGlobals.definePropertyGetters + ], + [RuntimeGlobals.createFakeNamespaceObject]: [ + RuntimeGlobals.definePropertyGetters, + RuntimeGlobals.makeNamespaceObject, + RuntimeGlobals.require + ], + [RuntimeGlobals.makeOptimizedDeferredNamespaceObject]: [ + RuntimeGlobals.require + ], + [RuntimeGlobals.makeDeferredNamespaceObject]: [ + RuntimeGlobals.createFakeNamespaceObject, + RuntimeGlobals.require + ], + [RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap], + [RuntimeGlobals.shareScopeMap]: [RuntimeGlobals.hasOwnProperty] +}; + +const FULLHASH_REGEXP = /\[(?:full)?hash(?::\d+)?\]/; + +const PLUGIN_NAME = "RuntimePlugin"; + +class RuntimePlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the Compiler + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const globalChunkLoading = compilation.outputOptions.chunkLoading; + /** + * Checks whether this runtime plugin is chunk loading disabled for chunk. + * @param {Chunk} chunk chunk + * @returns {boolean} true, when chunk loading is disabled for the chunk + */ + const isChunkLoadingDisabledForChunk = (chunk) => { + const options = chunk.getEntryOptions(); + const chunkLoading = + options && options.chunkLoading !== undefined + ? options.chunkLoading + : globalChunkLoading; + return chunkLoading === false; + }; + compilation.dependencyTemplates.set( + RuntimeRequirementsDependency, + new RuntimeRequirementsDependency.Template() + ); + for (const req of GLOBALS_ON_REQUIRE) { + compilation.hooks.runtimeRequirementInModule + .for(req) + .tap(PLUGIN_NAME, (module, set) => { + set.add(RuntimeGlobals.requireScope); + }); + compilation.hooks.runtimeRequirementInTree + .for(req) + .tap(PLUGIN_NAME, (module, set) => { + set.add(RuntimeGlobals.requireScope); + }); + } + for (const req of Object.keys(TREE_DEPENDENCIES)) { + const deps = + TREE_DEPENDENCIES[/** @type {keyof TREE_DEPENDENCIES} */ (req)]; + compilation.hooks.runtimeRequirementInTree + .for(req) + .tap(PLUGIN_NAME, (chunk, set) => { + for (const dep of deps) set.add(dep); + }); + } + for (const req of Object.keys(MODULE_DEPENDENCIES)) { + const deps = + MODULE_DEPENDENCIES[/** @type {keyof MODULE_DEPENDENCIES} */ (req)]; + compilation.hooks.runtimeRequirementInModule + .for(req) + .tap(PLUGIN_NAME, (chunk, set) => { + for (const dep of deps) set.add(dep); + }); + } + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.definePropertyGetters) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule( + chunk, + new DefinePropertyGettersRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.makeNamespaceObject) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule( + chunk, + new MakeNamespaceObjectRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.createFakeNamespaceObject) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule( + chunk, + new CreateFakeNamespaceObjectRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.makeOptimizedDeferredNamespaceObject) + .tap("RuntimePlugin", (chunk, runtimeRequirement) => { + compilation.addRuntimeModule( + chunk, + new MakeOptimizedDeferredNamespaceObjectRuntimeModule( + runtimeRequirement.has(RuntimeGlobals.asyncModule) + ) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.makeDeferredNamespaceObject) + .tap("RuntimePlugin", (chunk, runtimeRequirement) => { + compilation.addRuntimeModule( + chunk, + new MakeDeferredNamespaceObjectRuntimeModule( + runtimeRequirement.has(RuntimeGlobals.asyncModule) + ) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.hasOwnProperty) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule( + chunk, + new HasOwnPropertyRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.compatGetDefaultExport) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule( + chunk, + new CompatGetDefaultExportRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.setAnonymousDefaultName) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule( + chunk, + new SetAnonymousDefaultNameRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.runtimeId) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule()); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.publicPath) + .tap(PLUGIN_NAME, (chunk, set) => { + const { outputOptions } = compilation; + const { publicPath: globalPublicPath, scriptType } = outputOptions; + const entryOptions = chunk.getEntryOptions(); + const publicPath = + entryOptions && entryOptions.publicPath !== undefined + ? entryOptions.publicPath + : globalPublicPath; + + if (publicPath === "auto") { + const module = new AutoPublicPathRuntimeModule(); + if ( + scriptType !== "module" && + !outputOptions.environment.globalThis + ) { + set.add(RuntimeGlobals.global); + } + + compilation.addRuntimeModule(chunk, module); + } else { + const module = new PublicPathRuntimeModule(publicPath); + + if ( + typeof publicPath !== "string" || + FULLHASH_REGEXP.test(publicPath) + ) { + module.fullHash = true; + } + + compilation.addRuntimeModule(chunk, module); + } + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.global) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule(chunk, new GlobalRuntimeModule()); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.asyncModule) + .tap(PLUGIN_NAME, (chunk) => { + const experiments = compilation.options.experiments; + compilation.addRuntimeModule( + chunk, + new AsyncModuleRuntimeModule(experiments.deferImport) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.systemContext) + .tap(PLUGIN_NAME, (chunk) => { + const entryOptions = chunk.getEntryOptions(); + const libraryType = + entryOptions && entryOptions.library !== undefined + ? entryOptions.library.type + : /** @type {LibraryOptions} */ + (compilation.outputOptions.library).type; + + if (libraryType === "system") { + compilation.addRuntimeModule( + chunk, + new SystemContextRuntimeModule() + ); + } + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.getChunkScriptFilename) + .tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => { + if ( + typeof compilation.outputOptions.chunkFilename === "string" && + FULLHASH_REGEXP.test(compilation.outputOptions.chunkFilename) + ) { + set.add(RuntimeGlobals.getFullHash); + } + compilation.addRuntimeModule( + chunk, + new GetChunkFilenameRuntimeModule( + "javascript", + "javascript", + RuntimeGlobals.getChunkScriptFilename, + (chunk) => + getJavascriptModulesPlugin().chunkHasJs(chunk, chunkGraph) && + (chunk.filenameTemplate || + (chunk.canBeInitial() + ? compilation.outputOptions.filename + : compilation.outputOptions.chunkFilename)), + set.has(RuntimeGlobals.hmrDownloadUpdateHandlers) + ) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.getChunkCssFilename) + .tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => { + if ( + typeof compilation.outputOptions.cssChunkFilename === "string" && + FULLHASH_REGEXP.test(compilation.outputOptions.cssChunkFilename) + ) { + set.add(RuntimeGlobals.getFullHash); + } + compilation.addRuntimeModule( + chunk, + new GetChunkFilenameRuntimeModule( + "css", + "css", + RuntimeGlobals.getChunkCssFilename, + (chunk) => { + const cssModulePlugin = getCssModulesPlugin(); + + return ( + cssModulePlugin.chunkHasCss(chunk, chunkGraph) && + cssModulePlugin.getChunkFilenameTemplate( + chunk, + compilation.outputOptions + ) + ); + }, + set.has(RuntimeGlobals.hmrDownloadUpdateHandlers) + ) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.getChunkUpdateScriptFilename) + .tap(PLUGIN_NAME, (chunk, set) => { + if ( + FULLHASH_REGEXP.test( + compilation.outputOptions.hotUpdateChunkFilename + ) + ) { + set.add(RuntimeGlobals.getFullHash); + } + compilation.addRuntimeModule( + chunk, + new GetChunkFilenameRuntimeModule( + "javascript", + "javascript update", + RuntimeGlobals.getChunkUpdateScriptFilename, + (_chunk) => compilation.outputOptions.hotUpdateChunkFilename, + true + ) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.getUpdateManifestFilename) + .tap(PLUGIN_NAME, (chunk, set) => { + if ( + FULLHASH_REGEXP.test( + compilation.outputOptions.hotUpdateMainFilename + ) + ) { + set.add(RuntimeGlobals.getFullHash); + } + compilation.addRuntimeModule( + chunk, + new GetMainFilenameRuntimeModule( + "update manifest", + RuntimeGlobals.getUpdateManifestFilename, + compilation.outputOptions.hotUpdateMainFilename + ) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.ensureChunk) + .tap(PLUGIN_NAME, (chunk, set) => { + const hasAsyncChunks = chunk.hasAsyncChunks(); + if (hasAsyncChunks) { + set.add(RuntimeGlobals.ensureChunkHandlers); + } + compilation.addRuntimeModule( + chunk, + new EnsureChunkRuntimeModule(set) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.ensureChunkIncludeEntries) + .tap(PLUGIN_NAME, (chunk, set) => { + set.add(RuntimeGlobals.ensureChunkHandlers); + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.shareScopeMap) + .tap(PLUGIN_NAME, (chunk, set) => { + compilation.addRuntimeModule(chunk, new ShareRuntimeModule()); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.loadScript) + .tap(PLUGIN_NAME, (chunk, set) => { + const withCreateScriptUrl = Boolean( + compilation.outputOptions.trustedTypes + ); + if (withCreateScriptUrl) { + set.add(RuntimeGlobals.createScriptUrl); + } + const withFetchPriority = set.has(RuntimeGlobals.hasFetchPriority); + compilation.addRuntimeModule( + chunk, + new LoadScriptRuntimeModule(withCreateScriptUrl, withFetchPriority) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.createScript) + .tap(PLUGIN_NAME, (chunk, set) => { + if (compilation.outputOptions.trustedTypes) { + set.add(RuntimeGlobals.getTrustedTypesPolicy); + } + compilation.addRuntimeModule(chunk, new CreateScriptRuntimeModule()); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.createScriptUrl) + .tap(PLUGIN_NAME, (chunk, set) => { + if (compilation.outputOptions.trustedTypes) { + set.add(RuntimeGlobals.getTrustedTypesPolicy); + } + compilation.addRuntimeModule( + chunk, + new CreateScriptUrlRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.getTrustedTypesPolicy) + .tap(PLUGIN_NAME, (chunk, set) => { + compilation.addRuntimeModule( + chunk, + new GetTrustedTypesPolicyRuntimeModule(set) + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.relativeUrl) + .tap(PLUGIN_NAME, (chunk, _set) => { + compilation.addRuntimeModule(chunk, new RelativeUrlRuntimeModule()); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.onChunksLoaded) + .tap(PLUGIN_NAME, (chunk, _set) => { + compilation.addRuntimeModule( + chunk, + new OnChunksLoadedRuntimeModule() + ); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.baseURI) + .tap(PLUGIN_NAME, (chunk) => { + if (isChunkLoadingDisabledForChunk(chunk)) { + compilation.addRuntimeModule(chunk, new BaseUriRuntimeModule()); + return true; + } + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.scriptNonce) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule(chunk, new NonceRuntimeModule()); + return true; + }); + compilation.hooks.runtimeRequirementInTree + .for(RuntimeGlobals.toBinary) + .tap(PLUGIN_NAME, (chunk) => { + compilation.addRuntimeModule(chunk, new ToBinaryRuntimeModule()); + return true; + }); + // TODO webpack 6: remove CompatRuntimeModule + compilation.hooks.additionalTreeRuntimeRequirements.tap( + PLUGIN_NAME, + (chunk, _set) => { + const { mainTemplate } = compilation; + if ( + mainTemplate.hooks.bootstrap.isUsed() || + mainTemplate.hooks.localVars.isUsed() || + mainTemplate.hooks.requireEnsure.isUsed() || + mainTemplate.hooks.requireExtensions.isUsed() + ) { + compilation.addRuntimeModule(chunk, new CompatRuntimeModule()); + } + } + ); + JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap( + PLUGIN_NAME, + (chunk, hash, { chunkGraph }) => { + const xor = new StringXor(); + for (const m of chunkGraph.getChunkRuntimeModulesIterable(chunk)) { + xor.add(chunkGraph.getModuleHash(m, chunk.runtime)); + } + xor.updateHash(hash); + } + ); + }); + } +} + +module.exports = RuntimePlugin; Index: frontend/node_modules/webpack/lib/RuntimeTemplate.js =================================================================== --- frontend/node_modules/webpack/lib/RuntimeTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/RuntimeTemplate.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1322 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const InitFragment = require("./InitFragment"); +const RuntimeGlobals = require("./RuntimeGlobals"); +const Template = require("./Template"); +const { + getOutgoingAsyncModules +} = require("./async-modules/AsyncModuleHelpers"); +const { ImportPhaseUtils } = require("./dependencies/ImportPhase"); +const { + getMakeDeferredNamespaceModeFromExportsType, + getOptimizedDeferredModule +} = require("./runtime/MakeDeferredNamespaceObjectRuntime"); +const { equals } = require("./util/ArrayHelpers"); +const compileBooleanMatcher = require("./util/compileBooleanMatcher"); +const memoize = require("./util/memoize"); +const { propertyAccess } = require("./util/property"); +const { forEachRuntime, subtractRuntime } = require("./util/runtime"); + +const getHarmonyImportDependency = memoize(() => + require("./dependencies/HarmonyImportDependency") +); +const getImportDependency = memoize(() => + require("./dependencies/ImportDependency") +); + +/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */ +/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Dependency")} Dependency */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./Module").BuildMeta} BuildMeta */ +/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./RequestShortener")} RequestShortener */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ +/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */ +/** @typedef {import("./NormalModuleFactory").ModuleDependency} ModuleDependency */ + +/** + * No module id error message. + * @param {Module} module the module + * @param {ChunkGraph} chunkGraph the chunk graph + * @returns {string} error message + */ +const noModuleIdErrorMessage = ( + module, + chunkGraph +) => `Module ${module.identifier()} has no id assigned. +This should not happen. +It's in these chunks: ${ + Array.from( + chunkGraph.getModuleChunksIterable(module), + (c) => c.name || c.id || c.debugId + ).join(", ") || "none" +} (If module is in no chunk this indicates a bug in some chunk/module optimization logic) +Module has these incoming connections: ${Array.from( + chunkGraph.moduleGraph.getIncomingConnections(module), + (connection) => + `\n - ${ + connection.originModule && connection.originModule.identifier() + } ${connection.dependency && connection.dependency.type} ${ + (connection.explanations && [...connection.explanations].join(", ")) || "" + }` +).join("")}`; + +/** + * Gets global object. + * @param {string | undefined} definition global object definition + * @returns {string | undefined} save to use global object + */ +function getGlobalObject(definition) { + if (!definition) return definition; + const trimmed = definition.trim(); + + if ( + // identifier, we do not need real identifier regarding ECMAScript/Unicode + /^[_\p{L}][_0-9\p{L}]*$/iu.test(trimmed) || + // iife + // call expression + // expression in parentheses + /^(?:[_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu.test(trimmed) + ) { + return trimmed; + } + + return `Object(${trimmed})`; +} + +class RuntimeTemplate { + /** + * Creates an instance of RuntimeTemplate. + * @param {Compilation} compilation the compilation + * @param {OutputOptions} outputOptions the compilation output options + * @param {RequestShortener} requestShortener the request shortener + */ + constructor(compilation, outputOptions, requestShortener) { + this.compilation = compilation; + this.outputOptions = /** @type {OutputOptions} */ (outputOptions || {}); + this.requestShortener = requestShortener; + this.globalObject = + /** @type {string} */ + (getGlobalObject(outputOptions.globalObject)); + this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength); + } + + isIIFE() { + return this.outputOptions.iife; + } + + isModule() { + return this.outputOptions.module; + } + + isNeutralPlatform() { + return ( + !this.compilation.compiler.platform.web && + !this.compilation.compiler.platform.node + ); + } + + supportsConst() { + return this.outputOptions.environment.const; + } + + supportsMethodShorthand() { + return this.outputOptions.environment.methodShorthand; + } + + supportsArrowFunction() { + return this.outputOptions.environment.arrowFunction; + } + + supportsAsyncFunction() { + return this.outputOptions.environment.asyncFunction; + } + + supportsOptionalChaining() { + return this.outputOptions.environment.optionalChaining; + } + + supportsForOf() { + return this.outputOptions.environment.forOf; + } + + supportsDestructuring() { + return this.outputOptions.environment.destructuring; + } + + supportsBigIntLiteral() { + return this.outputOptions.environment.bigIntLiteral; + } + + supportsDynamicImport() { + return this.outputOptions.environment.dynamicImport; + } + + supportsEcmaScriptModuleSyntax() { + return this.outputOptions.environment.module; + } + + supportTemplateLiteral() { + return this.outputOptions.environment.templateLiteral; + } + + supportNodePrefixForCoreModules() { + return this.outputOptions.environment.nodePrefixForCoreModules; + } + + /** + * Renders node prefix for core module. + * @param {string} mod a module + * @returns {string} a module with `node:` prefix when supported, otherwise an original name + */ + renderNodePrefixForCoreModule(mod) { + return this.outputOptions.environment.nodePrefixForCoreModules + ? `"node:${mod}"` + : `"${mod}"`; + } + + /** + * Renders return const when it is supported, otherwise var. + * @returns {"const" | "var"} return `const` when it is supported, otherwise `var` + */ + renderConst() { + return this.supportsConst() ? "const" : "var"; + } + + /** + * Returning function. + * @param {string} returnValue return value + * @param {string} args arguments + * @returns {string} returning function + */ + returningFunction(returnValue, args = "") { + return this.supportsArrowFunction() + ? `(${args}) => (${returnValue})` + : `function(${args}) { return ${returnValue}; }`; + } + + /** + * Returns basic function. + * @param {string} args arguments + * @param {string | string[]} body body + * @returns {string} basic function + */ + basicFunction(args, body) { + return this.supportsArrowFunction() + ? `(${args}) => {\n${Template.indent(body)}\n}` + : `function(${args}) {\n${Template.indent(body)}\n}`; + } + + /** + * Returns result expression. + * @param {(string | { expr: string })[]} args args + * @returns {string} result expression + */ + concatenation(...args) { + const len = args.length; + + if (len === 2) return this._es5Concatenation(args); + if (len === 0) return '""'; + if (len === 1) { + return typeof args[0] === "string" + ? JSON.stringify(args[0]) + : `"" + ${args[0].expr}`; + } + if (!this.supportTemplateLiteral()) return this._es5Concatenation(args); + + // cost comparison between template literal and concatenation: + // both need equal surroundings: `xxx` vs "xxx" + // template literal has constant cost of 3 chars for each expression + // es5 concatenation has cost of 3 + n chars for n expressions in row + // when a es5 concatenation ends with an expression it reduces cost by 3 + // when a es5 concatenation starts with an single expression it reduces cost by 3 + // e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3) + // e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12) + + let templateCost = 0; + let concatenationCost = 0; + + let lastWasExpr = false; + for (const arg of args) { + const isExpr = typeof arg !== "string"; + if (isExpr) { + templateCost += 3; + concatenationCost += lastWasExpr ? 1 : 4; + } + lastWasExpr = isExpr; + } + if (lastWasExpr) concatenationCost -= 3; + if (typeof args[0] !== "string" && typeof args[1] === "string") { + concatenationCost -= 3; + } + + if (concatenationCost <= templateCost) return this._es5Concatenation(args); + + return `\`${args + .map((arg) => (typeof arg === "string" ? arg : `\${${arg.expr}}`)) + .join("")}\``; + } + + /** + * Returns result expression. + * @param {(string | { expr: string })[]} args args (len >= 2) + * @returns {string} result expression + * @private + */ + _es5Concatenation(args) { + const str = args + .map((arg) => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr)) + .join(" + "); + + // when the first two args are expression, we need to prepend "" + to force string + // concatenation instead of number addition. + return typeof args[0] !== "string" && typeof args[1] !== "string" + ? `"" + ${str}` + : str; + } + + /** + * Expression function. + * @param {string} expression expression + * @param {string} args arguments + * @returns {string} expression function code + */ + expressionFunction(expression, args = "") { + return this.supportsArrowFunction() + ? `(${args}) => (${expression})` + : `function(${args}) { ${expression}; }`; + } + + /** + * Returns empty function code. + * @returns {string} empty function code + */ + emptyFunction() { + return this.supportsArrowFunction() ? "x => {}" : "function() {}"; + } + + /** + * Returns destructure array code. + * @param {string[]} items items + * @param {string} value value + * @returns {string} destructure array code + */ + destructureArray(items, value) { + return this.supportsDestructuring() + ? `var [${items.join(", ")}] = ${value};` + : Template.asString( + items.map((item, i) => `var ${item} = ${value}[${i}];`) + ); + } + + /** + * Destructure object. + * @param {string[]} items items + * @param {string} value value + * @returns {string} destructure object code + */ + destructureObject(items, value) { + return this.supportsDestructuring() + ? `var {${items.join(", ")}} = ${value};` + : Template.asString( + items.map( + (item) => `var ${item} = ${value}${propertyAccess([item])};` + ) + ); + } + + /** + * Returns iIFE code. + * @param {string} args arguments + * @param {string} body body + * @returns {string} IIFE code + */ + iife(args, body) { + return `(${this.basicFunction(args, body)})()`; + } + + /** + * Returns for each code. + * @param {string} variable variable + * @param {string} array array + * @param {string | string[]} body body + * @returns {string} for each code + */ + forEach(variable, array, body) { + return this.supportsForOf() + ? `for(const ${variable} of ${array}) {\n${Template.indent(body)}\n}` + : `${array}.forEach(function(${variable}) {\n${Template.indent( + body + )}\n});`; + } + + /** + * Returns comment. + * @param {object} options Information content of the comment + * @param {string=} options.request request string used originally + * @param {(string | null)=} options.chunkName name of the chunk referenced + * @param {string=} options.chunkReason reason information of the chunk + * @param {string=} options.message additional message + * @param {string=} options.exportName name of the export + * @returns {string} comment + */ + comment({ request, chunkName, chunkReason, message, exportName }) { + /** @type {string} */ + let content; + if (this.outputOptions.pathinfo) { + content = [message, request, chunkName, chunkReason] + .filter(Boolean) + .map((item) => this.requestShortener.shorten(item)) + .join(" | "); + } else { + content = [message, chunkName, chunkReason] + .filter(Boolean) + .map((item) => this.requestShortener.shorten(item)) + .join(" | "); + } + if (!content) return ""; + if (this.outputOptions.pathinfo) { + return `${Template.toComment(content)} `; + } + return `${Template.toNormalComment(content)} `; + } + + /** + * Throw missing module error block. + * @param {object} options generation options + * @param {string=} options.request request string used originally + * @returns {string} generated error block + */ + throwMissingModuleErrorBlock({ request }) { + const err = `Cannot find module '${request}'`; + return `var e = new Error(${JSON.stringify( + err + )}); e.code = 'MODULE_NOT_FOUND'; throw e;`; + } + + /** + * Throw missing module error function. + * @param {object} options generation options + * @param {string=} options.request request string used originally + * @returns {string} generated error function + */ + throwMissingModuleErrorFunction({ request }) { + return `function webpackMissingModule() { ${this.throwMissingModuleErrorBlock( + { request } + )} }`; + } + + /** + * Returns generated error IIFE. + * @param {object} options generation options + * @param {string=} options.request request string used originally + * @returns {string} generated error IIFE + */ + missingModule({ request }) { + return `Object(${this.throwMissingModuleErrorFunction({ request })}())`; + } + + /** + * Missing module statement. + * @param {object} options generation options + * @param {string=} options.request request string used originally + * @returns {string} generated error statement + */ + missingModuleStatement({ request }) { + return `${this.missingModule({ request })};\n`; + } + + /** + * Missing module promise. + * @param {object} options generation options + * @param {string=} options.request request string used originally + * @returns {string} generated error code + */ + missingModulePromise({ request }) { + return `Promise.resolve().then(${this.throwMissingModuleErrorFunction({ + request + })})`; + } + + /** + * Returns the code. + * @param {object} options options object + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {Module} options.module the module + * @param {string=} options.request the request that should be printed as comment + * @param {string=} options.idExpr expression to use as id expression + * @param {"expression" | "promise" | "statements"} options.type which kind of code should be returned + * @returns {string} the code + */ + weakError({ module, chunkGraph, request, idExpr, type }) { + const moduleId = chunkGraph.getModuleId(module); + const errorMessage = + moduleId === null + ? JSON.stringify("Module is not available (weak dependency)") + : idExpr + ? `"Module '" + ${idExpr} + "' is not available (weak dependency)"` + : JSON.stringify( + `Module '${moduleId}' is not available (weak dependency)` + ); + const comment = request ? `${Template.toNormalComment(request)} ` : ""; + const errorStatements = `var e = new Error(${errorMessage}); ${ + comment + }e.code = 'MODULE_NOT_FOUND'; throw e;`; + switch (type) { + case "statements": + return errorStatements; + case "promise": + return `Promise.resolve().then(${this.basicFunction( + "", + errorStatements + )})`; + case "expression": + return this.iife("", errorStatements); + } + } + + /** + * Returns the expression. + * @param {object} options options object + * @param {Module} options.module the module + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {string=} options.request the request that should be printed as comment + * @param {boolean=} options.weak if the dependency is weak (will create a nice error message) + * @returns {string} the expression + */ + moduleId({ module, chunkGraph, request, weak }) { + if (!module) { + return this.missingModule({ + request + }); + } + const moduleId = chunkGraph.getModuleId(module); + if (moduleId === null) { + if (weak) { + return "null /* weak dependency, without id */"; + } + throw new Error( + `RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage( + module, + chunkGraph + )}` + ); + } + return `${this.comment({ request })}${JSON.stringify(moduleId)}`; + } + + /** + * Returns the expression. + * @param {object} options options object + * @param {Module | null} options.module the module + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {string=} options.request the request that should be printed as comment + * @param {boolean=} options.weak if the dependency is weak (will create a nice error message) + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @returns {string} the expression + */ + moduleRaw({ module, chunkGraph, request, weak, runtimeRequirements }) { + if (!module) { + return this.missingModule({ + request + }); + } + const moduleId = chunkGraph.getModuleId(module); + if (moduleId === null) { + if (weak) { + // only weak referenced modules don't get an id + // we can always emit an error emitting code here + return this.weakError({ + module, + chunkGraph, + request, + type: "expression" + }); + } + throw new Error( + `RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage( + module, + chunkGraph + )}` + ); + } + runtimeRequirements.add(RuntimeGlobals.require); + return `${RuntimeGlobals.require}(${this.moduleId({ + module, + chunkGraph, + request, + weak + })})`; + } + + /** + * Returns the expression. + * @param {object} options options object + * @param {Module | null} options.module the module + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {string} options.request the request that should be printed as comment + * @param {boolean=} options.weak if the dependency is weak (will create a nice error message) + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @returns {string} the expression + */ + moduleExports({ module, chunkGraph, request, weak, runtimeRequirements }) { + return this.moduleRaw({ + module, + chunkGraph, + request, + weak, + runtimeRequirements + }); + } + + /** + * Returns the expression. + * @param {object} options options object + * @param {Module} options.module the module + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {string} options.request the request that should be printed as comment + * @param {boolean=} options.strict if the current module is in strict esm mode + * @param {boolean=} options.weak if the dependency is weak (will create a nice error message) + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @returns {string} the expression + */ + moduleNamespace({ + module, + chunkGraph, + request, + strict, + weak, + runtimeRequirements + }) { + if (!module) { + return this.missingModule({ + request + }); + } + if (chunkGraph.getModuleId(module) === null) { + if (weak) { + // only weak referenced modules don't get an id + // we can always emit an error emitting code here + return this.weakError({ + module, + chunkGraph, + request, + type: "expression" + }); + } + throw new Error( + `RuntimeTemplate.moduleNamespace(): ${noModuleIdErrorMessage( + module, + chunkGraph + )}` + ); + } + const moduleId = this.moduleId({ + module, + chunkGraph, + request, + weak + }); + const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict); + switch (exportsType) { + case "namespace": + return this.moduleRaw({ + module, + chunkGraph, + request, + weak, + runtimeRequirements + }); + case "default-with-named": + runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject); + return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 3)`; + case "default-only": + runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject); + return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 1)`; + case "dynamic": + runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject); + return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 7)`; + } + } + + /** + * Module namespace promise. + * @param {object} options options object + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {AsyncDependenciesBlock=} options.block the current dependencies block + * @param {Module} options.module the module + * @param {string} options.request the request that should be printed as comment + * @param {string} options.message a message for the comment + * @param {boolean=} options.strict if the current module is in strict esm mode + * @param {boolean=} options.weak if the dependency is weak (will create a nice error message) + * @param {Dependency} options.dependency dependency + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @returns {string} the promise expression + */ + moduleNamespacePromise({ + chunkGraph, + block, + module, + request, + message, + strict, + weak, + dependency, + runtimeRequirements + }) { + if (!module) { + return this.missingModulePromise({ + request + }); + } + const moduleId = chunkGraph.getModuleId(module); + if (moduleId === null) { + if (weak) { + // only weak referenced modules don't get an id + // we can always emit an error emitting code here + return this.weakError({ + module, + chunkGraph, + request, + type: "promise" + }); + } + throw new Error( + `RuntimeTemplate.moduleNamespacePromise(): ${noModuleIdErrorMessage( + module, + chunkGraph + )}` + ); + } + const promise = this.blockPromise({ + chunkGraph, + block, + message, + runtimeRequirements + }); + + /** @type {string} */ + let appending; + let idExpr = JSON.stringify(chunkGraph.getModuleId(module)); + const comment = this.comment({ + request + }); + let header = ""; + if (weak) { + if (idExpr.length > 8) { + // 'var x="nnnnnn";x,"+x+",x' vs '"nnnnnn",nnnnnn,"nnnnnn"' + header += `var id = ${idExpr}; `; + idExpr = "id"; + } + runtimeRequirements.add(RuntimeGlobals.moduleFactories); + header += `if(!${ + RuntimeGlobals.moduleFactories + }[${idExpr}]) { ${this.weakError({ + module, + chunkGraph, + request, + idExpr, + type: "statements" + })} } `; + } + const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict); + + const isModuleDeferred = + (dependency instanceof getHarmonyImportDependency() || + dependency instanceof getImportDependency()) && + ImportPhaseUtils.isDefer(dependency.phase) && + !(/** @type {BuildMeta} */ (module.buildMeta).async); + + if (isModuleDeferred) { + runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject); + + let mode = getMakeDeferredNamespaceModeFromExportsType(exportsType); + if (mode) mode = `${mode} | 16`; + + const asyncDeps = Array.from( + getOutgoingAsyncModules(chunkGraph.moduleGraph, module), + (m) => chunkGraph.getModuleId(m) + ).filter((id) => id !== null); + if (asyncDeps.length) { + if (header) { + appending = `.then(${this.basicFunction( + "", + `${header}return ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)});` + )})`; + } else { + runtimeRequirements.add(RuntimeGlobals.require); + appending = `.then(${this.returningFunction(`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)})`)})`; + } + appending += `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`; + } else if (header) { + appending = `.then(${this.basicFunction( + "", + `${header}return ${RuntimeGlobals.makeDeferredNamespaceObject}(${comment}${idExpr}, ${mode});` + )})`; + } else { + runtimeRequirements.add(RuntimeGlobals.require); + appending = `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`; + } + } else { + let fakeType = 16; + switch (exportsType) { + case "namespace": + if (header) { + const rawModule = this.moduleRaw({ + module, + chunkGraph, + request, + weak, + runtimeRequirements + }); + appending = `.then(${this.basicFunction( + "", + `${header}return ${rawModule};` + )})`; + } else { + runtimeRequirements.add(RuntimeGlobals.require); + appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`; + } + break; + case "dynamic": + fakeType |= 4; + /* fall through */ + case "default-with-named": + fakeType |= 2; + /* fall through */ + case "default-only": + runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject); + if (chunkGraph.moduleGraph.isAsync(module)) { + if (header) { + const rawModule = this.moduleRaw({ + module, + chunkGraph, + request, + weak, + runtimeRequirements + }); + appending = `.then(${this.basicFunction( + "", + `${header}return ${rawModule};` + )})`; + } else { + runtimeRequirements.add(RuntimeGlobals.require); + appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`; + } + appending += `.then(${this.returningFunction( + `${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`, + "m" + )})`; + } else { + fakeType |= 1; + if (header) { + const moduleIdExpr = this.moduleId({ + module, + chunkGraph, + request, + weak + }); + const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`; + appending = `.then(${this.basicFunction( + "", + `${header}return ${returnExpression};` + )})`; + } else { + appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`; + } + } + break; + } + } + + return `${promise || "Promise.resolve()"}${appending}`; + } + + /** + * Runtime condition expression. + * @param {object} options options object + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated + * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @returns {string} expression + */ + runtimeConditionExpression({ + chunkGraph, + runtimeCondition, + runtime, + runtimeRequirements + }) { + if (runtimeCondition === undefined) return "true"; + if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`; + /** @type {Set} */ + const positiveRuntimeIds = new Set(); + forEachRuntime(runtimeCondition, (runtime) => + positiveRuntimeIds.add( + `${chunkGraph.getRuntimeId(/** @type {string} */ (runtime))}` + ) + ); + /** @type {Set} */ + const negativeRuntimeIds = new Set(); + forEachRuntime(subtractRuntime(runtime, runtimeCondition), (runtime) => + negativeRuntimeIds.add( + `${chunkGraph.getRuntimeId(/** @type {string} */ (runtime))}` + ) + ); + runtimeRequirements.add(RuntimeGlobals.runtimeId); + return compileBooleanMatcher.fromLists( + [...positiveRuntimeIds], + [...negativeRuntimeIds] + )(RuntimeGlobals.runtimeId); + } + + /** + * Returns the import statement and the compat statement. + * @param {object} options options object + * @param {boolean=} options.update whether a new variable should be created or the existing one updated + * @param {Module} options.module the module + * @param {Module} options.originModule module in which the statement is emitted + * @param {ModuleGraph} options.moduleGraph the module graph + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @param {string} options.importVar name of the import variable + * @param {string=} options.request the request that should be printed as comment + * @param {boolean=} options.weak true, if this is a weak dependency + * @param {ModuleDependency=} options.dependency module dependency + * @returns {[string, string]} the import statement and the compat statement + */ + importStatement({ + update, + module, + moduleGraph, + chunkGraph, + request, + importVar, + originModule, + weak, + dependency, + runtimeRequirements + }) { + if (!module) { + return [ + this.missingModuleStatement({ + request + }), + "" + ]; + } + + if (chunkGraph.getModuleId(module) === null) { + if (weak) { + // only weak referenced modules don't get an id + // we can always emit an error emitting code here + return [ + this.weakError({ + module, + chunkGraph, + request, + type: "statements" + }), + "" + ]; + } + throw new Error( + `RuntimeTemplate.importStatement(): ${noModuleIdErrorMessage( + module, + chunkGraph + )}` + ); + } + const moduleId = this.moduleId({ + module, + chunkGraph, + request, + weak + }); + const optDeclaration = update ? "" : "var "; + + const exportsType = module.getExportsType( + chunkGraph.moduleGraph, + /** @type {BuildMeta} */ + (originModule.buildMeta).strictHarmonyModule + ); + runtimeRequirements.add(RuntimeGlobals.require); + + /** @type {string} */ + let importContent; + + const isModuleDeferred = + (dependency instanceof getHarmonyImportDependency() || + dependency instanceof getImportDependency()) && + ImportPhaseUtils.isDefer(dependency.phase) && + !(/** @type {BuildMeta} */ (module.buildMeta).async); + + if (isModuleDeferred) { + /** @type {Set} */ + const outgoingAsyncModules = getOutgoingAsyncModules(moduleGraph, module); + + importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule( + moduleId, + exportsType, + Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)), + runtimeRequirements + )};\n`; + + return [importContent, ""]; + } + importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`; + + if (exportsType === "dynamic") { + runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport); + return [ + importContent, + `/* harmony import */ ${optDeclaration}${importVar}_default = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${importVar});\n` + ]; + } + return [importContent, ""]; + } + + /** + * Export from import. + * @template GenerateContext + * @param {object} options options + * @param {ModuleGraph} options.moduleGraph the module graph + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {Module} options.module the module + * @param {string} options.request the request + * @param {string | string[]} options.exportName the export name + * @param {Module} options.originModule the origin module + * @param {boolean | undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted + * @param {boolean | undefined} options.isCall true, if expression will be called + * @param {boolean | null} options.callContext when false, call context will not be preserved + * @param {boolean} options.defaultInterop when true and accessing the default exports, interop code will be generated + * @param {string} options.importVar the identifier name of the import variable + * @param {InitFragment[]} options.initFragments init fragments will be added here + * @param {RuntimeSpec} options.runtime runtime for which this code will be generated + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @param {ModuleDependency} options.dependency module dependency + * @returns {string} expression + */ + exportFromImport({ + moduleGraph, + chunkGraph, + module, + request, + exportName, + originModule, + asiSafe, + isCall, + callContext, + defaultInterop, + importVar, + initFragments, + runtime, + runtimeRequirements, + dependency + }) { + if (!module) { + return this.missingModule({ + request + }); + } + if (!Array.isArray(exportName)) { + exportName = exportName ? [exportName] : []; + } + const exportsType = module.getExportsType( + moduleGraph, + /** @type {BuildMeta} */ + (originModule.buildMeta).strictHarmonyModule + ); + + const isModuleDeferred = + (dependency instanceof getHarmonyImportDependency() || + dependency instanceof getImportDependency()) && + ImportPhaseUtils.isDefer(dependency.phase) && + !(/** @type {BuildMeta} */ (module.buildMeta).async); + + if (defaultInterop) { + // when the defaultInterop is used (when a ESM imports a CJS module), + if (exportName.length > 0 && exportName[0] === "default") { + if (isModuleDeferred && exportsType !== "namespace") { + const exportsInfo = moduleGraph.getExportsInfo(module); + const name = exportName.slice(1); + const used = exportsInfo.getUsedName(name, runtime); + if (!used) { + const comment = Template.toNormalComment( + `unused export ${propertyAccess(exportName)}` + ); + return `${comment} undefined`; + } + const access = `${importVar}.a${propertyAccess(used)}`; + if (isCall || asiSafe === undefined) { + return access; + } + return asiSafe ? `(${access})` : `;(${access})`; + } + // accessing the .default property is same thing as `require()` the module. + + // For example: + // import mod from "cjs"; mod.default.x; + // is translated to + // var mod = require("cjs"); mod.x; + switch (exportsType) { + case "dynamic": + if (isCall) { + return `${importVar}_default()${propertyAccess(exportName, 1)}`; + } + return asiSafe + ? `(${importVar}_default()${propertyAccess(exportName, 1)})` + : asiSafe === false + ? `;(${importVar}_default()${propertyAccess(exportName, 1)})` + : `${importVar}_default.a${propertyAccess(exportName, 1)}`; + + case "default-only": + case "default-with-named": + exportName = exportName.slice(1); + break; + } + } else if (exportName.length > 0) { + // the property used is not .default. + // For example: + // import * as ns from "cjs"; cjs.prop; + if (exportsType === "default-only") { + // in the strictest case, it is a runtime error (e.g. NodeJS behavior of CJS-ESM interop). + return `/* non-default import from non-esm module */undefined${propertyAccess( + exportName, + 1 + )}`; + } else if ( + exportsType !== "namespace" && + exportName[0] === "__esModule" + ) { + return "/* __esModule */true"; + } + } else if (isModuleDeferred) { + // now exportName.length is 0 + // fall through to the end of this function, create the namespace there. + } else if ( + exportsType === "default-only" || + exportsType === "default-with-named" + ) { + // now exportName.length is 0, which means the namespace object is used in an unknown way + // for example: + // import * as ns from "cjs"; console.log(ns); + // we will need to createFakeNamespaceObject that simulates ES Module namespace object + runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject); + initFragments.push( + new InitFragment( + `var ${importVar}_namespace_cache;\n`, + InitFragment.STAGE_CONSTANTS, + -1, + `${importVar}_namespace_cache` + ) + ); + return `/*#__PURE__*/ ${ + asiSafe ? "" : asiSafe === false ? ";" : "Object" + }(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${ + RuntimeGlobals.createFakeNamespaceObject + }(${importVar}${exportsType === "default-only" ? "" : ", 2"})))`; + } + } + + if (exportName.length > 0) { + const exportsInfo = moduleGraph.getExportsInfo(module); + // in some case the exported item is renamed (get this by getUsedName). for example, + // x.default might be emitted as x.Z (default is renamed to Z) + const used = exportsInfo.getUsedName(exportName, runtime); + if (!used) { + const comment = Template.toNormalComment( + `unused export ${propertyAccess(exportName)}` + ); + return `${comment} undefined`; + } + const comment = equals(used, exportName) + ? "" + : `${Template.toNormalComment(propertyAccess(exportName))} `; + const access = `${importVar}${ + isModuleDeferred ? ".a" : "" + }${comment}${propertyAccess(used)}`; + if (isCall && callContext === false) { + return asiSafe + ? `(0,${access})` + : asiSafe === false + ? `;(0,${access})` + : `/*#__PURE__*/Object(${access})`; + } + return access; + } + if (isModuleDeferred) { + initFragments.push( + new InitFragment( + `var ${importVar}_deferred_namespace_cache;\n`, + InitFragment.STAGE_CONSTANTS, + -1, + `${importVar}_deferred_namespace_cache` + ) + ); + + runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject); + const id = chunkGraph.getModuleId(module); + const type = getMakeDeferredNamespaceModeFromExportsType(exportsType); + const init = `${ + RuntimeGlobals.makeDeferredNamespaceObject + }(${JSON.stringify(id)}, ${type})`; + + return `/*#__PURE__*/ ${ + asiSafe ? "" : asiSafe === false ? ";" : "Object" + }(${importVar}_deferred_namespace_cache || (${importVar}_deferred_namespace_cache = ${init}))`; + } + // if we hit here, the importVar is either + // - already a ES module namespace object + // - or imported by a way that does not need interop. + return importVar; + } + + /** + * Returns expression. + * @param {object} options options + * @param {AsyncDependenciesBlock | undefined} options.block the async block + * @param {string} options.message the message + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @returns {string} expression + */ + blockPromise({ block, message, chunkGraph, runtimeRequirements }) { + if (!block) { + const comment = this.comment({ + message + }); + return `Promise.resolve(${comment.trim()})`; + } + const chunkGroup = chunkGraph.getBlockChunkGroup(block); + if (!chunkGroup || chunkGroup.chunks.length === 0) { + const comment = this.comment({ + message + }); + return `Promise.resolve(${comment.trim()})`; + } + const chunks = chunkGroup.chunks.filter( + (chunk) => !chunk.hasRuntime() && chunk.id !== null + ); + const comment = this.comment({ + message, + chunkName: block.chunkName + }); + if (chunks.length === 1) { + const chunkId = JSON.stringify(chunks[0].id); + runtimeRequirements.add(RuntimeGlobals.ensureChunk); + + const fetchPriority = chunkGroup.options.fetchPriority; + + if (fetchPriority) { + runtimeRequirements.add(RuntimeGlobals.hasFetchPriority); + } + + return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId}${ + fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : "" + })`; + } else if (chunks.length > 0) { + runtimeRequirements.add(RuntimeGlobals.ensureChunk); + + const fetchPriority = chunkGroup.options.fetchPriority; + + if (fetchPriority) { + runtimeRequirements.add(RuntimeGlobals.hasFetchPriority); + } + + /** + * Returns require chunk id code. + * @param {Chunk} chunk chunk + * @returns {string} require chunk id code + */ + const requireChunkId = (chunk) => + `${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${ + fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : "" + })`; + return `Promise.all(${comment.trim()}[${chunks + .map(requireChunkId) + .join(", ")}])`; + } + return `Promise.resolve(${comment.trim()})`; + } + + /** + * Async module factory. + * @param {object} options options + * @param {AsyncDependenciesBlock} options.block the async block + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @param {string=} options.request request string used originally + * @returns {string} expression + */ + asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }) { + const dep = block.dependencies[0]; + const module = chunkGraph.moduleGraph.getModule(dep); + const ensureChunk = this.blockPromise({ + block, + message: "", + chunkGraph, + runtimeRequirements + }); + const factory = this.returningFunction( + this.moduleRaw({ + module, + chunkGraph, + request, + runtimeRequirements + }) + ); + return this.returningFunction( + ensureChunk.startsWith("Promise.resolve(") + ? `${factory}` + : `${ensureChunk}.then(${this.returningFunction(factory)})` + ); + } + + /** + * Sync module factory. + * @param {object} options options + * @param {Dependency} options.dependency the dependency + * @param {ChunkGraph} options.chunkGraph the chunk graph + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @param {string=} options.request request string used originally + * @returns {string} expression + */ + syncModuleFactory({ dependency, chunkGraph, runtimeRequirements, request }) { + const module = chunkGraph.moduleGraph.getModule(dependency); + const factory = this.returningFunction( + this.moduleRaw({ + module, + chunkGraph, + request, + runtimeRequirements + }) + ); + return this.returningFunction(factory); + } + + /** + * Define es module flag statement. + * @param {object} options options + * @param {string} options.exportsArgument the name of the exports object + * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements + * @returns {string} statement + */ + defineEsModuleFlagStatement({ exportsArgument, runtimeRequirements }) { + runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject); + runtimeRequirements.add(RuntimeGlobals.exports); + return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`; + } +} + +module.exports = RuntimeTemplate; Index: frontend/node_modules/webpack/lib/SelfModuleFactory.js =================================================================== --- frontend/node_modules/webpack/lib/SelfModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/SelfModuleFactory.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,35 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */ +/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ + +class SelfModuleFactory { + /** + * Creates an instance of SelfModuleFactory. + * @param {ModuleGraph} moduleGraph module graph + */ + constructor(moduleGraph) { + this.moduleGraph = moduleGraph; + } + + /** + * Processes the provided data. + * @param {ModuleFactoryCreateData} data data object + * @param {ModuleFactoryCallback} callback callback + * @returns {void} + */ + create(data, callback) { + const module = this.moduleGraph.getParentModule(data.dependencies[0]); + callback(null, { + module + }); + } +} + +module.exports = SelfModuleFactory; Index: frontend/node_modules/webpack/lib/SingleEntryPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/SingleEntryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/SingleEntryPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,8 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sean Larkin @thelarkinn +*/ + +"use strict"; + +module.exports = require("./EntryPlugin"); Index: frontend/node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,54 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin"); + +/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */ +/** @typedef {import("./Compilation")} Compilation */ + +const PLUGIN_NAME = "SourceMapDevToolModuleOptionsPlugin"; + +class SourceMapDevToolModuleOptionsPlugin { + /** + * Creates an instance of SourceMapDevToolModuleOptionsPlugin. + * @param {SourceMapDevToolPluginOptions=} options options + */ + constructor(options = {}) { + /** @type {SourceMapDevToolPluginOptions} */ + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compilation} compilation the compiler instance + * @returns {void} + */ + apply(compilation) { + const options = this.options; + if (options.module !== false) { + compilation.hooks.buildModule.tap(PLUGIN_NAME, (module) => { + module.useSourceMap = true; + }); + compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (module) => { + module.useSourceMap = true; + }); + } else { + compilation.hooks.buildModule.tap(PLUGIN_NAME, (module) => { + module.useSimpleSourceMap = true; + }); + compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (module) => { + module.useSimpleSourceMap = true; + }); + } + JavascriptModulesPlugin.getCompilationHooks(compilation).useSourceMap.tap( + PLUGIN_NAME, + () => true + ); + } +} + +module.exports = SourceMapDevToolModuleOptionsPlugin; Index: frontend/node_modules/webpack/lib/SourceMapDevToolPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/SourceMapDevToolPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/SourceMapDevToolPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,851 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const asyncLib = require("neo-async"); +const { ConcatSource, RawSource } = require("webpack-sources"); +const Compilation = require("./Compilation"); +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); +const ProgressPlugin = require("./ProgressPlugin"); +const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin"); +const createHash = require("./util/createHash"); +const { dirname, relative } = require("./util/fs"); +const generateDebugId = require("./util/generateDebugId"); +const { makePathsAbsolute } = require("./util/identifier"); + +/** @typedef {import("webpack-sources").MapOptions} MapOptions */ +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../declarations/WebpackOptions").DevtoolNamespace} DevtoolNamespace */ +/** @typedef {import("../declarations/WebpackOptions").DevtoolModuleFilenameTemplate} DevtoolModuleFilenameTemplate */ +/** @typedef {import("../declarations/WebpackOptions").DevtoolFallbackModuleFilenameTemplate} DevtoolFallbackModuleFilenameTemplate */ +/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */ +/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").Rules} Rules */ +/** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./Compilation").Asset} Asset */ +/** @typedef {import("./Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./NormalModule").RawSourceMap} RawSourceMap */ +/** @typedef {import("./TemplatedPathPlugin").TemplatePath} SourceMappingURLComment */ +/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */ + +/** + * Defines the source map task type used by this module. + * @typedef {object} SourceMapTask + * @property {Source} asset + * @property {AssetInfo} assetInfo + * @property {(string | Module)[]} modules + * @property {string} source + * @property {string} file + * @property {RawSourceMap} sourceMap + * @property {ItemCacheFacade} cacheItem cache item + */ + +const METACHARACTERS_REGEXP = /[-[\]\\/{}()*+?.^$|]/g; +const CONTENT_HASH_DETECT_REGEXP = /\[contenthash(?::\w+)?\]/; +const CSS_AND_JS_MODULE_EXTENSIONS_REGEXP = /\.((c|m)?js|css)($|\?)/i; +const CSS_EXTENSION_DETECT_REGEXP = /\.css(?:$|\?)/i; +const MAP_URL_COMMENT_REGEXP = /\[map\]/g; +const URL_COMMENT_REGEXP = /\[url\]/g; +const URL_FORMATTING_REGEXP = /^\n\/\/(.*)$/; + +/** + * Reset's .lastIndex of stateful Regular Expressions + * For when `test` or `exec` is called on them + * @param {RegExp} regexp Stateful Regular Expression to be reset + * @returns {void} + */ +const resetRegexpState = (regexp) => { + regexp.lastIndex = -1; +}; + +/** + * Escapes regular expression metacharacters + * @param {string} str String to quote + * @returns {string} Escaped string + */ +const quoteMeta = (str) => str.replace(METACHARACTERS_REGEXP, "\\$&"); + +/** + * Compilation-scoped registry of original asset sources for multi-plugin + * cooperation. The first SourceMapDevToolPlugin instance to see a file pins a + * reference to the asset's still-unwrapped {@link Source} object; later + * instances whose `asset.source.sourceAndMap()` would now return `null` (the + * earlier instance replaced the asset with a `RawSource`) can re-extract the + * map from this pinned reference. We keep the registry on a module-scoped + * `WeakMap` so the entries are reclaimed automatically when the compilation + * itself becomes unreachable; we never store anything on the compilation + * object directly. + * + * Stashing the `Source` object itself rather than an extracted map keeps the + * fast path free of cloning and source-map serialization work — the + * extraction only happens if a subsequent plugin actually needs the map. + * @type {WeakMap>} + */ +const originalSourceRegistry = new WeakMap(); + +/** + * Returns (creating if necessary) the per-compilation registry of original + * asset {@link Source} objects. + * @param {Compilation} compilation compilation + * @returns {Map} registry + */ +const getOriginalSourceRegistry = (compilation) => { + let registry = originalSourceRegistry.get(compilation); + if (registry === undefined) { + registry = new Map(); + originalSourceRegistry.set(compilation, registry); + } + return registry; +}; + +/** + * Extracts source and source map from a Source object, falling back to a + * registered original source for assets that another SourceMapDevToolPlugin + * instance has already wrapped (whose internal map is now `null`). + * + * The returned source is read from the asset as it currently stands — that way + * any `sourceMappingURL` comments appended by earlier plugin instances survive + * — while the map is taken from the pinned original Source when the current + * one no longer carries it. + * @param {string} file file name + * @param {Source} asset source object as currently held by the compilation + * @param {MapOptions} options map extraction options + * @param {Map} registry compilation-scoped original-source registry + * @returns {{ source: string, sourceMap: RawSourceMap } | undefined} extracted pair or `undefined` when no map is recoverable + */ +const extractSourceAndMap = (file, asset, options, registry) => { + /** @type {string | Buffer} */ + let source; + /** @type {null | RawSourceMap} */ + let sourceMap; + if (asset.sourceAndMap) { + const sourceAndMap = asset.sourceAndMap(options); + source = sourceAndMap.source; + sourceMap = sourceAndMap.map; + } else { + source = asset.source(); + sourceMap = asset.map(options); + } + // Bail before touching the registry if we can't return a usable string + // source — pinning a non-string-producing asset would only waste the slot. + if (typeof source !== "string") return; + if (sourceMap) { + // The current asset still owns the original map — pin a reference so + // that a later plugin instance (which will see a rewrapped asset + // without a map) can recover it on demand. + if (!registry.has(file)) registry.set(file, asset); + } else { + // The current asset (typically a `RawSource` left by an earlier + // SourceMapDevToolPlugin instance) has no internal map. Re-extract + // the map from the original Source we pinned earlier. We keep using + // `source` from the current asset so that any prior wrappers (e.g. + // appended sourceMappingURL comments) are preserved. + const original = registry.get(file); + if (!original) return; + sourceMap = original.sourceAndMap + ? original.sourceAndMap(options).map + : original.map(options); + if (!sourceMap) return; + } + return { source, sourceMap }; +}; + +/** + * Creating {@link SourceMapTask} for given file + * @param {string} file current compiled file + * @param {Source} asset the asset + * @param {AssetInfo} assetInfo the asset info + * @param {MapOptions} options source map options + * @param {Compilation} compilation compilation instance + * @param {ItemCacheFacade} cacheItem cache item + * @param {Map} registry compilation-scoped original-source registry + * @returns {SourceMapTask | undefined} created task instance or `undefined` + */ +const getTaskForFile = ( + file, + asset, + assetInfo, + options, + compilation, + cacheItem, + registry +) => { + const extracted = extractSourceAndMap(file, asset, options, registry); + if (!extracted) return; + const { source, sourceMap } = extracted; + const context = compilation.options.context; + const root = compilation.compiler.root; + const cachedAbsolutify = makePathsAbsolute.bindContextCache(context, root); + const modules = sourceMap.sources.map((source) => { + if (!source.startsWith("webpack://")) return source; + source = cachedAbsolutify(source.slice(10)); + const module = compilation.findModule(source); + return module || source; + }); + + return { + file, + asset, + source: /** @type {string} */ (source), + assetInfo, + sourceMap, + modules, + cacheItem + }; +}; + +const PLUGIN_NAME = "SourceMapDevToolPlugin"; + +/** + * Maps a configuration value (string, RegExp, function, nullish, or array of + * such) into a JSON-serializable form. Functions and RegExps are turned into + * their `.toString()` representation so that changes to inline callbacks + * invalidate caches; everything else is returned as-is so that the surrounding + * `JSON.stringify` does the escaping. + * + * The result is used through `JSON.stringify` to build cache identifiers, so + * we deliberately avoid any homemade `|` / `,` separators that could collide + * with characters appearing inside user-provided values such as `publicPath`, + * template strings, or `sourceRoot`. + * @param {EXPECTED_ANY} value option value + * @returns {EXPECTED_ANY} JSON-serializable representation + */ +const toCacheKeyValue = (value) => { + if (value === undefined || value === null) return value; + if (Array.isArray(value)) return value.map(toCacheKeyValue); + if (value instanceof RegExp || typeof value === "function") { + return value.toString(); + } + return value; +}; + +class SourceMapDevToolPlugin { + /** + * Creates an instance of SourceMapDevToolPlugin. + * @param {SourceMapDevToolPluginOptions=} options options object + * @throws {Error} throws error, if got more than 1 arguments + */ + constructor(options = {}) { + /** @type {undefined | null | false | string} */ + this.sourceMapFilename = options.filename; + /** @type {false | SourceMappingURLComment} */ + this.sourceMappingURLComment = + options.append === false + ? false + : // eslint-disable-next-line no-useless-concat + options.append || "\n//# source" + "MappingURL=[url]"; + /** @type {DevtoolModuleFilenameTemplate} */ + this.moduleFilenameTemplate = + options.moduleFilenameTemplate || "webpack://[namespace]/[resourcePath]"; + /** @type {DevtoolFallbackModuleFilenameTemplate} */ + this.fallbackModuleFilenameTemplate = + options.fallbackModuleFilenameTemplate || + "webpack://[namespace]/[resourcePath]?[hash]"; + /** @type {DevtoolNamespace} */ + this.namespace = options.namespace || ""; + /** @type {SourceMapDevToolPluginOptions} */ + this.options = options; + // Cache salt derived from output-affecting options, so that two + // SourceMapDevToolPlugin instances (or `devtool` + a plugin) operating + // on the same asset don't share a cache entry. We serialize via + // `JSON.stringify` rather than a homemade separator so that any + // special characters (e.g. `|` inside a publicPath or sourceRoot) + // can't accidentally make two different option sets collide. + /** @type {string} */ + this._cacheSalt = JSON.stringify([ + toCacheKeyValue(options.filename), + toCacheKeyValue(options.append), + toCacheKeyValue(this.moduleFilenameTemplate), + toCacheKeyValue(this.fallbackModuleFilenameTemplate), + toCacheKeyValue(this.namespace), + options.module !== false, + options.columns !== false, + Boolean(options.noSources), + Boolean(options.debugIds), + options.sourceRoot || "", + toCacheKeyValue(options.ignoreList), + options.publicPath || "", + options.fileContext || "" + ]); + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => require("../schemas/plugins/SourceMapDevToolPlugin.json"), + this.options, + { + name: "SourceMap DevTool Plugin", + baseDataPath: "options" + }, + (options) => + require("../schemas/plugins/SourceMapDevToolPlugin.check")(options) + ); + }); + + const outputFs = + /** @type {OutputFileSystem} */ + (compiler.outputFileSystem); + const sourceMapFilename = this.sourceMapFilename; + const sourceMappingURLComment = this.sourceMappingURLComment; + const moduleFilenameTemplate = this.moduleFilenameTemplate; + const namespace = this.namespace; + const fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate; + const requestShortener = compiler.requestShortener; + const options = this.options; + options.test = options.test || CSS_AND_JS_MODULE_EXTENSIONS_REGEXP; + + /** @type {(filename: string) => boolean} */ + const matchObject = ModuleFilenameHelpers.matchObject.bind( + undefined, + options + ); + + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation); + + // All SourceMapDevToolPlugin instances on the same compilation share + // a registry of pristine asset sources, so the second instance to + // run can still recover the original map after the first instance + // has replaced the asset with a `RawSource`. The registry lives on a + // module-scoped `WeakMap` keyed by compilation so it is released + // automatically and never pollutes the compilation object. + const originalSources = getOriginalSourceRegistry(compilation); + + compilation.hooks.processAssets.tapAsync( + { + name: PLUGIN_NAME, + stage: Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING, + additionalAssets: true + }, + (assets, callback) => { + const chunkGraph = compilation.chunkGraph; + const cache = compilation.getCache(PLUGIN_NAME); + /** @type {Map} */ + const moduleToSourceNameMapping = new Map(); + const reportProgress = + ProgressPlugin.getReporter(compilation.compiler) || (() => {}); + + /** @type {Map} */ + const fileToChunk = new Map(); + for (const chunk of compilation.chunks) { + for (const file of chunk.files) { + fileToChunk.set(file, chunk); + } + for (const file of chunk.auxiliaryFiles) { + fileToChunk.set(file, chunk); + } + } + + /** @type {string[]} */ + const files = []; + for (const file of Object.keys(assets)) { + if (matchObject(file)) { + files.push(file); + } + } + + reportProgress(0); + /** @type {SourceMapTask[]} */ + const tasks = []; + let fileIndex = 0; + + asyncLib.each( + files, + (file, callback) => { + const asset = + /** @type {Readonly} */ + (compilation.getAsset(file)); + + const chunk = fileToChunk.get(file); + const sourceMapNamespace = compilation.getPath(this.namespace, { + chunk + }); + + // The cache item identifier must include the per-instance + // salt so two SourceMapDevToolPlugin instances that target + // the same `file` don't collide in the persistent cache — + // they'd otherwise write different content to the same key + // and invalidate every pack on each build. We encode via + // `JSON.stringify` so that special characters (e.g. `|`) + // in an asset filename can't be spoofed to collide with the + // salt portion of the identifier. + const cacheItem = cache.getItemCache( + JSON.stringify([file, this._cacheSalt]), + cache.mergeEtags( + cache.getLazyHashedEtag(asset.source), + sourceMapNamespace + ) + ); + + cacheItem.get((err, cacheEntry) => { + if (err) { + return callback(err); + } + /** + * If presented in cache, reassigns assets. Cache assets already have source maps. + */ + if (cacheEntry) { + // Pin the still-unwrapped asset source in the registry + // before `compilation.updateAsset` replaces it. This is a + // pointer assignment — no source-map extraction work — and + // it lets a subsequent SourceMapDevToolPlugin instance + // extract the original map on demand even though the + // persistent cache hit lets us skip processing here. + if (!originalSources.has(file)) { + originalSources.set(file, asset.source); + } + + const { assets, assetsInfo } = cacheEntry; + for (const cachedFile of Object.keys(assets)) { + if (cachedFile === file) { + compilation.updateAsset( + cachedFile, + assets[cachedFile], + assetsInfo[cachedFile] + ); + } else { + compilation.emitAsset( + cachedFile, + assets[cachedFile], + assetsInfo[cachedFile] + ); + } + /** + * Add file to chunk, if not presented there + */ + if (cachedFile !== file && chunk !== undefined) { + chunk.auxiliaryFiles.add(cachedFile); + } + } + + reportProgress( + (0.5 * ++fileIndex) / files.length, + file, + "restored cached SourceMap" + ); + + return callback(); + } + + reportProgress( + (0.5 * fileIndex) / files.length, + file, + "generate SourceMap" + ); + + /** @type {SourceMapTask | undefined} */ + const task = getTaskForFile( + file, + asset.source, + asset.info, + { + module: options.module, + columns: options.columns + }, + compilation, + cacheItem, + originalSources + ); + + if (task) { + const modules = task.modules; + + for (let idx = 0; idx < modules.length; idx++) { + const module = modules[idx]; + + if ( + typeof module === "string" && + /^(?:data|https?):/.test(module) + ) { + moduleToSourceNameMapping.set(module, module); + continue; + } + + if (!moduleToSourceNameMapping.get(module)) { + moduleToSourceNameMapping.set( + module, + ModuleFilenameHelpers.createFilename( + module, + { + moduleFilenameTemplate, + namespace: sourceMapNamespace + }, + { + requestShortener, + chunkGraph, + hashFunction: compilation.outputOptions.hashFunction + } + ) + ); + } + } + + tasks.push(task); + } + + reportProgress( + (0.5 * ++fileIndex) / files.length, + file, + "generated SourceMap" + ); + + callback(); + }); + }, + (err) => { + if (err) { + return callback(err); + } + + reportProgress(0.5, "resolve sources"); + /** @type {Set} */ + const usedNamesSet = new Set(moduleToSourceNameMapping.values()); + /** @type {Set} */ + const conflictDetectionSet = new Set(); + + /** + * all modules in defined order (longest identifier first) + * @type {(string | Module)[]} + */ + const allModules = [...moduleToSourceNameMapping.keys()].sort( + (a, b) => { + const ai = typeof a === "string" ? a : a.identifier(); + const bi = typeof b === "string" ? b : b.identifier(); + return ai.length - bi.length; + } + ); + + // find modules with conflicting source names + for (let idx = 0; idx < allModules.length; idx++) { + const module = allModules[idx]; + let sourceName = + /** @type {string} */ + (moduleToSourceNameMapping.get(module)); + let hasName = conflictDetectionSet.has(sourceName); + if (!hasName) { + conflictDetectionSet.add(sourceName); + continue; + } + + // try the fallback name first + sourceName = ModuleFilenameHelpers.createFilename( + module, + { + moduleFilenameTemplate: fallbackModuleFilenameTemplate, + namespace + }, + { + requestShortener, + chunkGraph, + hashFunction: compilation.outputOptions.hashFunction + } + ); + hasName = usedNamesSet.has(sourceName); + if (!hasName) { + moduleToSourceNameMapping.set(module, sourceName); + usedNamesSet.add(sourceName); + continue; + } + + // otherwise just append stars until we have a valid name + while (hasName) { + sourceName += "*"; + hasName = usedNamesSet.has(sourceName); + } + moduleToSourceNameMapping.set(module, sourceName); + usedNamesSet.add(sourceName); + } + + let taskIndex = 0; + + asyncLib.each( + tasks, + (task, callback) => { + /** @type {Record} */ + const assets = Object.create(null); + /** @type {Record} */ + const assetsInfo = Object.create(null); + const file = task.file; + const chunk = fileToChunk.get(file); + const sourceMap = task.sourceMap; + const source = task.source; + const modules = task.modules; + + reportProgress( + 0.5 + (0.5 * taskIndex) / tasks.length, + file, + "attach SourceMap" + ); + + const moduleFilenames = + /** @type {string[]} */ + (modules.map((m) => moduleToSourceNameMapping.get(m))); + // We deliberately do NOT mutate `sourceMap` in place: the + // task's `sourceMap` reference may be shared with a + // `SourceMapSource` whose internal map cache is the same + // object (webpack-sources keeps it cached). A second + // `SourceMapDevToolPlugin` instance that reads the original + // source through the registry would otherwise see our + // rewrites. Instead we build a fresh `outputSourceMap` for + // the .map file and leave the original alone. + /** @type {number[] | undefined} */ + let ignoreList; + if (options.ignoreList) { + const list = moduleFilenames.reduce( + /** @type {(acc: number[], sourceName: string, idx: number) => number[]} */ ( + (acc, sourceName, idx) => { + const rule = /** @type {Rules} */ ( + options.ignoreList + ); + if ( + ModuleFilenameHelpers.matchPart(sourceName, rule) + ) { + acc.push(idx); + } + return acc; + } + ), + [] + ); + if (list.length > 0) ignoreList = list; + } + + const usesContentHash = + sourceMapFilename && + CONTENT_HASH_DETECT_REGEXP.test(sourceMapFilename); + + resetRegexpState(CONTENT_HASH_DETECT_REGEXP); + + let outputFile = file; + // If SourceMap and asset uses contenthash, avoid a circular dependency by hiding hash in `file` + if (usesContentHash && task.assetInfo.contenthash) { + const contenthash = task.assetInfo.contenthash; + const pattern = Array.isArray(contenthash) + ? contenthash.map(quoteMeta).join("|") + : quoteMeta(contenthash); + outputFile = outputFile.replace( + new RegExp(pattern, "g"), + (m) => "x".repeat(m.length) + ); + } + + /** @type {false | SourceMappingURLComment} */ + let currentSourceMappingURLComment = sourceMappingURLComment; + const cssExtensionDetected = + CSS_EXTENSION_DETECT_REGEXP.test(file); + resetRegexpState(CSS_EXTENSION_DETECT_REGEXP); + if ( + currentSourceMappingURLComment !== false && + typeof currentSourceMappingURLComment !== "function" && + cssExtensionDetected + ) { + currentSourceMappingURLComment = + currentSourceMappingURLComment.replace( + URL_FORMATTING_REGEXP, + "\n/*$1*/" + ); + } + + /** @type {string | undefined} */ + let debugIdValue; + if (options.debugIds) { + const debugId = generateDebugId(source, outputFile); + debugIdValue = debugId; + + const debugIdComment = `\n//# debugId=${debugId}`; + if (currentSourceMappingURLComment === false) { + currentSourceMappingURLComment = debugIdComment; + } else if ( + typeof currentSourceMappingURLComment === "function" + ) { + // Wrap the user's append function so the debug-id + // comment is prepended at call time. Template-string + // concatenation would coerce the function to a string + // and lose its dynamic behavior. + const wrappedFn = currentSourceMappingURLComment; + currentSourceMappingURLComment = (pathData, assetInfo) => + `${debugIdComment}${wrappedFn(pathData, assetInfo)}`; + } else { + currentSourceMappingURLComment = `${debugIdComment}${currentSourceMappingURLComment}`; + } + } + + /** @type {RawSourceMap} */ + const outputSourceMap = { + ...sourceMap, + sources: moduleFilenames, + sourceRoot: options.sourceRoot || "", + file: outputFile + }; + if (ignoreList !== undefined) { + outputSourceMap.ignoreList = ignoreList; + } + if (options.noSources) { + outputSourceMap.sourcesContent = undefined; + } + if (debugIdValue !== undefined) { + outputSourceMap.debugId = debugIdValue; + } + + const sourceMapString = JSON.stringify(outputSourceMap); + if (sourceMapFilename) { + const filename = file; + const sourceMapContentHash = usesContentHash + ? createHash(compilation.outputOptions.hashFunction) + .update(sourceMapString) + .digest("hex") + : undefined; + + const pathParams = { + chunk, + filename: options.fileContext + ? relative( + outputFs, + `/${options.fileContext}`, + `/${filename}` + ) + : filename, + contentHash: sourceMapContentHash + }; + const { path: sourceMapFile, info: sourceMapInfo } = + compilation.getPathWithInfo( + sourceMapFilename, + pathParams + ); + const sourceMapUrl = options.publicPath + ? options.publicPath + sourceMapFile + : relative( + outputFs, + dirname(outputFs, `/${file}`), + `/${sourceMapFile}` + ); + /** @type {Source} */ + let asset = new RawSource(source); + if (currentSourceMappingURLComment !== false) { + // Add source map url to compilation asset, if currentSourceMappingURLComment is set + asset = new ConcatSource( + asset, + compilation.getPath(currentSourceMappingURLComment, { + url: sourceMapUrl, + ...pathParams + }) + ); + } + // Preserve any existing related.sourceMap entries from + // earlier SourceMapDevToolPlugin runs on the same asset so + // that all generated maps remain discoverable via asset + // info (the schema allows string or string[]). + const existingSourceMap = + task.assetInfo.related && + task.assetInfo.related.sourceMap; + /** @type {string | string[]} */ + let relatedSourceMap; + if ( + existingSourceMap === undefined || + existingSourceMap === null + ) { + relatedSourceMap = sourceMapFile; + } else if (Array.isArray(existingSourceMap)) { + relatedSourceMap = existingSourceMap.includes( + sourceMapFile + ) + ? existingSourceMap + : [...existingSourceMap, sourceMapFile]; + } else { + relatedSourceMap = + existingSourceMap === sourceMapFile + ? existingSourceMap + : [existingSourceMap, sourceMapFile]; + } + const assetInfo = { + related: { sourceMap: relatedSourceMap } + }; + assets[file] = asset; + assetsInfo[file] = assetInfo; + compilation.updateAsset(file, asset, assetInfo); + // Add source map file to compilation assets and chunk files + const sourceMapAsset = new RawSource(sourceMapString); + const sourceMapAssetInfo = { + ...sourceMapInfo, + development: true + }; + assets[sourceMapFile] = sourceMapAsset; + assetsInfo[sourceMapFile] = sourceMapAssetInfo; + compilation.emitAsset( + sourceMapFile, + sourceMapAsset, + sourceMapAssetInfo + ); + if (chunk !== undefined) { + chunk.auxiliaryFiles.add(sourceMapFile); + } + } else { + if (currentSourceMappingURLComment === false) { + throw new Error( + `${PLUGIN_NAME}: append can't be false when no filename is provided` + ); + } + if (typeof currentSourceMappingURLComment === "function") { + throw new Error( + `${PLUGIN_NAME}: append can't be a function when no filename is provided` + ); + } + /** + * Add source map as data url to asset + */ + const asset = new ConcatSource( + new RawSource(source), + currentSourceMappingURLComment + .replace(MAP_URL_COMMENT_REGEXP, () => sourceMapString) + .replace( + URL_COMMENT_REGEXP, + () => + `data:application/json;charset=utf-8;base64,${Buffer.from( + sourceMapString, + "utf8" + ).toString("base64")}` + ) + ); + assets[file] = asset; + assetsInfo[file] = undefined; + compilation.updateAsset(file, asset); + } + + task.cacheItem.store({ assets, assetsInfo }, (err) => { + reportProgress( + 0.5 + (0.5 * ++taskIndex) / tasks.length, + task.file, + "attached SourceMap" + ); + + if (err) { + return callback(err); + } + callback(); + }); + }, + (err) => { + reportProgress(1); + callback(err); + } + ); + } + ); + } + ); + }); + } +} + +module.exports = SourceMapDevToolPlugin; Index: frontend/node_modules/webpack/lib/Stats.js =================================================================== --- frontend/node_modules/webpack/lib/Stats.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Stats.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,94 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */ +/** @typedef {import("../declarations/WebpackOptions").StatsValue} StatsValue */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */ + +class Stats { + /** + * Creates an instance of Stats. + * @param {Compilation} compilation webpack compilation + */ + constructor(compilation) { + this.compilation = compilation; + } + + get hash() { + return this.compilation.hash; + } + + get startTime() { + return this.compilation.startTime; + } + + get endTime() { + return this.compilation.endTime; + } + + /** + * Checks whether this stats has warnings. + * @returns {boolean} true if the compilation had a warning + */ + hasWarnings() { + return ( + this.compilation.getWarnings().length > 0 || + this.compilation.children.some((child) => child.getStats().hasWarnings()) + ); + } + + /** + * Checks whether this stats has errors. + * @returns {boolean} true if the compilation encountered an error + */ + hasErrors() { + return ( + this.compilation.errors.length > 0 || + this.compilation.children.some((child) => child.getStats().hasErrors()) + ); + } + + /** + * Returns json output. + * @param {StatsValue=} options stats options + * @returns {StatsCompilation} json output + */ + toJson(options) { + const normalizedOptions = this.compilation.createStatsOptions(options, { + forToString: false + }); + + const statsFactory = this.compilation.createStatsFactory(normalizedOptions); + + return statsFactory.create("compilation", this.compilation, { + compilation: this.compilation + }); + } + + /** + * Returns a string representation. + * @param {StatsValue=} options stats options + * @returns {string} string output + */ + toString(options) { + const normalizedOptions = this.compilation.createStatsOptions(options, { + forToString: true + }); + + const statsFactory = this.compilation.createStatsFactory(normalizedOptions); + const statsPrinter = this.compilation.createStatsPrinter(normalizedOptions); + + const data = statsFactory.create("compilation", this.compilation, { + compilation: this.compilation + }); + const result = statsPrinter.print("compilation", data); + return result === undefined ? "" : result; + } +} + +module.exports = Stats; Index: frontend/node_modules/webpack/lib/Template.js =================================================================== --- frontend/node_modules/webpack/lib/Template.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Template.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,447 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { ConcatSource, PrefixSource } = require("webpack-sources"); +const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants"); +const RuntimeGlobals = require("./RuntimeGlobals"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ +/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */ +/** @typedef {import("./Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("./Compilation").PathData} PathData */ +/** @typedef {import("./DependencyTemplates")} DependencyTemplates */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./ModuleTemplate")} ModuleTemplate */ +/** @typedef {import("./RuntimeModule")} RuntimeModule */ +/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */ +/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */ +/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */ + +const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0); +const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0); +const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1; +const NUMBER_OF_IDENTIFIER_START_CHARS = DELTA_A_TO_Z * 2 + 2; // a-z A-Z _ $ +const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS = + NUMBER_OF_IDENTIFIER_START_CHARS + 10; // a-z A-Z _ $ 0-9 +const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g; +const INDENT_MULTILINE_REGEX = /^\t/gm; +const LINE_SEPARATOR_REGEX = /\r?\n/g; +const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-z$_])/i; +const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-z0-9$]+/gi; +const COMMENT_END_REGEX = /\*\//g; +const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-z0-9_!§$()=\-^°]+/gi; +const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g; + +/** + * Defines the render manifest options type used by this module. + * @typedef {object} RenderManifestOptions + * @property {Chunk} chunk the chunk used to render + * @property {string} hash + * @property {string} fullHash + * @property {OutputOptions} outputOptions + * @property {CodeGenerationResults} codeGenerationResults + * @property {{ javascript: ModuleTemplate }} moduleTemplates + * @property {DependencyTemplates} dependencyTemplates + * @property {RuntimeTemplate} runtimeTemplate + * @property {ModuleGraph} moduleGraph + * @property {ChunkGraph} chunkGraph + */ + +/** @typedef {RenderManifestEntryTemplated | RenderManifestEntryStatic} RenderManifestEntry */ + +/** + * Defines the render manifest entry templated type used by this module. + * @typedef {object} RenderManifestEntryTemplated + * @property {() => Source} render + * @property {string | import("./TemplatedPathPlugin").TemplatePathFn} filenameTemplate + * @property {PathData=} pathOptions + * @property {AssetInfo=} info + * @property {string} identifier + * @property {string=} hash + * @property {boolean=} auxiliary + */ + +/** + * Defines the render manifest entry static type used by this module. + * @typedef {object} RenderManifestEntryStatic + * @property {() => Source} render + * @property {string} filename + * @property {AssetInfo} info + * @property {string} identifier + * @property {string=} hash + * @property {boolean=} auxiliary + */ + +/** + * Defines the module filter predicate type used by this module. + * @typedef {(module: Module) => boolean} ModuleFilterPredicate + */ + +/** + * Represents the template runtime component. + * @typedef {object} Stringable + * @property {() => string} toString + */ + +class Template { + /** + * Gets function content. + * @param {Stringable} fn a runtime function (.runtime.js) "template" + * @returns {string} the updated and normalized function string + */ + static getFunctionContent(fn) { + return fn + .toString() + .replace(FUNCTION_CONTENT_REGEX, "") + .replace(INDENT_MULTILINE_REGEX, "") + .replace(LINE_SEPARATOR_REGEX, "\n"); + } + + /** + * Returns created identifier. + * @param {string} str the string converted to identifier + * @returns {string} created identifier + */ + static toIdentifier(str) { + if (typeof str !== "string") return ""; + return str + .replace(IDENTIFIER_NAME_REPLACE_REGEX, "_$1") + .replace(IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX, "_"); + } + + /** + * Returns a commented version of string. + * @param {string} str string to be converted to commented in bundle code + * @returns {string} returns a commented version of string + */ + static toComment(str) { + if (!str) return ""; + return `/*! ${str.replace(COMMENT_END_REGEX, "* /")} */`; + } + + /** + * Returns a commented version of string. + * @param {string} str string to be converted to "normal comment" + * @returns {string} returns a commented version of string + */ + static toNormalComment(str) { + if (!str) return ""; + return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`; + } + + /** + * Returns normalized bundle-safe path. + * @param {string} str string path to be normalized + * @returns {string} normalized bundle-safe path + */ + static toPath(str) { + if (typeof str !== "string") return ""; + return str + .replace(PATH_NAME_NORMALIZE_REPLACE_REGEX, "-") + .replace(MATCH_PADDED_HYPHENS_REPLACE_REGEX, ""); + } + + // map number to a single character a-z, A-Z or multiple characters if number is too big + /** + * Number to identifier. + * @param {number} n number to convert to ident + * @returns {string} returns single character ident + */ + static numberToIdentifier(n) { + if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) { + // use multiple letters + return ( + Template.numberToIdentifier(n % NUMBER_OF_IDENTIFIER_START_CHARS) + + Template.numberToIdentifierContinuation( + Math.floor(n / NUMBER_OF_IDENTIFIER_START_CHARS) + ) + ); + } + + // lower case + if (n < DELTA_A_TO_Z) { + return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n); + } + n -= DELTA_A_TO_Z; + + // upper case + if (n < DELTA_A_TO_Z) { + return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n); + } + + if (n === DELTA_A_TO_Z) return "_"; + return "$"; + } + + /** + * Number to identifier continuation. + * @param {number} n number to convert to ident + * @returns {string} returns single character ident + */ + static numberToIdentifierContinuation(n) { + if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) { + // use multiple letters + return ( + Template.numberToIdentifierContinuation( + n % NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS + ) + + Template.numberToIdentifierContinuation( + Math.floor(n / NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) + ) + ); + } + + // lower case + if (n < DELTA_A_TO_Z) { + return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n); + } + n -= DELTA_A_TO_Z; + + // upper case + if (n < DELTA_A_TO_Z) { + return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n); + } + n -= DELTA_A_TO_Z; + + // numbers + if (n < 10) { + return `${n}`; + } + + if (n === 10) return "_"; + return "$"; + } + + /** + * Returns converted identity. + * @param {string | string[]} s string to convert to identity + * @returns {string} converted identity + */ + static indent(s) { + if (Array.isArray(s)) { + return s.map(Template.indent).join("\n"); + } + const str = s.trimEnd(); + if (!str) return ""; + const ind = str[0] === "\n" ? "" : "\t"; + return ind + str.replace(/\n([^\n])/g, "\n\t$1"); + } + + /** + * Returns new prefix string. + * @param {string | string[]} s string to create prefix for + * @param {string} prefix prefix to compose + * @returns {string} returns new prefix string + */ + static prefix(s, prefix) { + const str = Template.asString(s).trim(); + if (!str) return ""; + const ind = str[0] === "\n" ? "" : prefix; + return ind + str.replace(/\n([^\n])/g, `\n${prefix}$1`); + } + + /** + * Returns a single string from array. + * @param {string | string[]} str string or string collection + * @returns {string} returns a single string from array + */ + static asString(str) { + if (Array.isArray(str)) { + return str.join("\n"); + } + return str; + } + + /** + * Defines the with id type used by this module. + * @typedef {object} WithId + * @property {string | number} id + */ + + /** + * Gets modules array bounds. + * @param {WithId[]} modules a collection of modules to get array bounds for + * @returns {[number, number] | false} returns the upper and lower array bounds + * or false if not every module has a number based id + */ + static getModulesArrayBounds(modules) { + let maxId = -Infinity; + let minId = Infinity; + for (const module of modules) { + const moduleId = module.id; + if (typeof moduleId !== "number") return false; + if (maxId < moduleId) maxId = moduleId; + if (minId > moduleId) minId = moduleId; + } + if (minId < 16 + String(minId).length) { + // add minId x ',' instead of 'Array(minId).concat(…)' + minId = 0; + } + // start with -1 because the first module needs no comma + let objectOverhead = -1; + for (const module of modules) { + // module id + colon + comma + objectOverhead += `${module.id}`.length + 2; + } + // number of commas, or when starting non-zero the length of Array(minId).concat() + const arrayOverhead = minId === 0 ? maxId : 16 + `${minId}`.length + maxId; + return arrayOverhead < objectOverhead ? [minId, maxId] : false; + } + + /** + * Renders chunk modules. + * @param {ChunkRenderContext} renderContext render context + * @param {Module[]} modules modules to render (should be ordered by identifier) + * @param {(module: Module, renderInArray?: boolean) => Source | null} renderModule function to render a module + * @param {string=} prefix applying prefix strings + * @returns {Source | null} rendered chunk modules in a Source object or null if no modules + */ + static renderChunkModules(renderContext, modules, renderModule, prefix = "") { + const { chunkGraph } = renderContext; + const source = new ConcatSource(); + if (modules.length === 0) { + return null; + } + /** @type {{ id: ModuleId, module: Module }[]} */ + const modulesWithId = modules.map((m) => ({ + id: /** @type {ModuleId} */ (chunkGraph.getModuleId(m)), + module: m + })); + const bounds = Template.getModulesArrayBounds(modulesWithId); + const renderInObject = bounds === false; + + /** @type {{ id: ModuleId, source: Source | "false" }[]} */ + const allModules = modulesWithId.map(({ id, module }) => ({ + id, + source: renderModule(module, renderInObject) || "false" + })); + + if (bounds) { + // Render a spare array + const minId = bounds[0]; + const maxId = bounds[1]; + if (minId !== 0) { + source.add(`Array(${minId}).concat(`); + } + source.add("[\n"); + /** @type {Map} */ + const modules = new Map(); + for (const module of allModules) { + modules.set(module.id, module); + } + for (let idx = minId; idx <= maxId; idx++) { + const module = modules.get(idx); + if (idx !== minId) { + source.add(",\n"); + } + source.add(`/* ${idx} */`); + if (module) { + source.add("\n"); + source.add(module.source); + } + } + source.add(`\n${prefix}]`); + if (minId !== 0) { + source.add(")"); + } + } else { + // Render an object + source.add("{\n"); + for (let i = 0; i < allModules.length; i++) { + const module = allModules[i]; + if (i !== 0) { + source.add(",\n"); + } + source.add( + `\n/***/ ${JSON.stringify(module.id)}${renderContext.runtimeTemplate.supportsMethodShorthand() && module.source !== "false" ? "" : ":"}\n` + ); + source.add(module.source); + } + source.add(`\n\n${prefix}}`); + } + return source; + } + + /** + * Renders runtime modules. + * @param {RuntimeModule[]} runtimeModules array of runtime modules in order + * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context + * @returns {Source} rendered runtime modules in a Source object + */ + static renderRuntimeModules(runtimeModules, renderContext) { + const source = new ConcatSource(); + for (const module of runtimeModules) { + const codeGenerationResults = renderContext.codeGenerationResults; + /** @type {undefined | Source} */ + let runtimeSource; + if (codeGenerationResults) { + runtimeSource = codeGenerationResults.getSource( + module, + renderContext.chunk.runtime, + WEBPACK_MODULE_TYPE_RUNTIME + ); + } else { + const codeGenResult = module.codeGeneration({ + chunkGraph: renderContext.chunkGraph, + dependencyTemplates: renderContext.dependencyTemplates, + moduleGraph: renderContext.moduleGraph, + runtimeTemplate: renderContext.runtimeTemplate, + runtime: renderContext.chunk.runtime, + runtimes: [renderContext.chunk.runtime], + codeGenerationResults + }); + if (!codeGenResult) continue; + runtimeSource = codeGenResult.sources.get("runtime"); + } + if (runtimeSource) { + source.add(`${Template.toNormalComment(module.identifier())}\n`); + if (!module.shouldIsolate()) { + source.add(runtimeSource); + source.add("\n\n"); + } else if (renderContext.runtimeTemplate.supportsArrowFunction()) { + source.add("(() => {\n"); + source.add(new PrefixSource("\t", runtimeSource)); + source.add("\n})();\n\n"); + } else { + source.add("!function() {\n"); + source.add(new PrefixSource("\t", runtimeSource)); + source.add("\n}();\n\n"); + } + } + } + return source; + } + + /** + * Renders chunk runtime modules. + * @param {RuntimeModule[]} runtimeModules array of runtime modules in order + * @param {RenderContext} renderContext render context + * @returns {Source} rendered chunk runtime modules in a Source object + */ + static renderChunkRuntimeModules(runtimeModules, renderContext) { + return new PrefixSource( + "/******/ ", + new ConcatSource( + `function(${RuntimeGlobals.require}) { // webpackRuntimeModules\n`, + this.renderRuntimeModules(runtimeModules, renderContext), + "}\n" + ) + ); + } +} + +module.exports = Template; +module.exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS = + NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS; +module.exports.NUMBER_OF_IDENTIFIER_START_CHARS = + NUMBER_OF_IDENTIFIER_START_CHARS; Index: frontend/node_modules/webpack/lib/TemplatedPathPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/TemplatedPathPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/TemplatedPathPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,426 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Jason Anderson @diurnalist +*/ + +"use strict"; + +const { basename, extname } = require("path"); +const util = require("util"); +const Chunk = require("./Chunk"); +const Module = require("./Module"); +const { parseResource } = require("./util/identifier"); +const memoize = require("./util/memoize"); + +const getMimeTypes = memoize(() => require("./util/mimeTypes")); + +/** @typedef {import("./ChunkGraph")} ChunkGraph */ +/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */ +/** @typedef {import("./Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("./Compilation").PathData} PathData */ +/** @typedef {import("./Compilation").PathDataChunk} PathDataChunk */ +/** @typedef {import("./Compilation").PathDataModule} PathDataModule */ +/** @typedef {import("./Compiler")} Compiler */ + +const REGEXP = /\[\\*([\w:]+)\\*\]/g; + +/** @type {PathData["prepareId"]} */ +const prepareId = (id) => { + if (typeof id !== "string") return id; + + if (/^"\s\+*.*\+\s*"$/.test(id)) { + const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id); + + return `" + (${ + /** @type {string[]} */ (match)[1] + } + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`; + } + + return id.replace(/(^[.-]|[^a-z0-9_-])+/gi, "_"); +}; + +/** + * Defines the replacer function callback. + * @callback ReplacerFunction + * @param {string} match + * @param {string | undefined} arg + * @param {string} input + */ + +/** + * Returns hash replacer function. + * @param {ReplacerFunction} replacer replacer + * @param {((arg0: number) => string) | undefined} handler handler + * @param {AssetInfo | undefined} assetInfo asset info + * @param {string} hashName hash name + * @returns {Replacer} hash replacer function + */ +const hashLength = (replacer, handler, assetInfo, hashName) => { + /** @type {Replacer} */ + const fn = (match, arg, input) => { + /** @type {string} */ + let result; + const length = arg && Number.parseInt(arg, 10); + + if (length && handler) { + result = handler(length); + } else { + const hash = replacer(match, arg, input); + + result = length ? hash.slice(0, length) : hash; + } + if (assetInfo) { + assetInfo.immutable = true; + if (Array.isArray(assetInfo[hashName])) { + assetInfo[hashName] = [...assetInfo[hashName], result]; + } else if (assetInfo[hashName]) { + assetInfo[hashName] = [assetInfo[hashName], result]; + } else { + assetInfo[hashName] = result; + } + } + return result; + }; + + return fn; +}; + +/** @typedef {(match: string, arg: string | undefined, input: string) => string} Replacer */ + +/** + * Returns replacer. + * @param {string | number | null | undefined | (() => string | number | null | undefined)} value value + * @param {boolean=} allowEmpty allow empty + * @returns {Replacer} replacer + */ +const replacer = (value, allowEmpty) => { + /** @type {Replacer} */ + const fn = (match, arg, input) => { + if (typeof value === "function") { + value = value(); + } + if (value === null || value === undefined) { + if (!allowEmpty) { + throw new Error( + `Path variable ${match} not implemented in this context: ${input}` + ); + } + + return ""; + } + + return `${value}`; + }; + + return fn; +}; + +/** @type {Map EXPECTED_ANY>} */ +const deprecationCache = new Map(); +const deprecatedFunction = (() => () => {})(); +/** + * Returns function with deprecation output. + * @template {(...args: EXPECTED_ANY[]) => EXPECTED_ANY} T + * @param {T} fn function + * @param {string} message message + * @param {string} code code + * @returns {T} function with deprecation output + */ +const deprecated = (fn, message, code) => { + let d = deprecationCache.get(message); + if (d === undefined) { + d = util.deprecate(deprecatedFunction, message, code); + deprecationCache.set(message, d); + } + return /** @type {T} */ ( + (...args) => { + d(); + return fn(...args); + } + ); +}; + +/** + * Callback used to compute a path from contextual data. The type parameter + * narrows the `pathData` shape when the caller knows it operates in a chunk + * (`PathDataChunk`) or module (`PathDataModule`) context — defaults to the + * fully-optional `PathData` for backward compatibility. + * @template {PathData} [T=PathData] + * @typedef {(pathData: T, assetInfo?: AssetInfo) => string} TemplatePathFn + */ + +/** + * Either a raw template string (e.g. `"[name].[contenthash].js"`) or a + * generic `TemplatePathFn`. Method signatures that need to thread a narrowed + * `PathData` shape spell the function side out as `TemplatePathFn` + * directly — `TemplatePath` itself stays a plain alias so local JSDoc + * re-imports keep a single shared identity. + * @typedef {string | TemplatePathFn} TemplatePath + */ + +/** + * Returns the interpolated path. + * @template {PathData} [T=PathData] + * @param {string | TemplatePathFn} path the raw path + * @param {T} data context data + * @param {AssetInfo=} assetInfo extra info about the asset (will be written to) + * @returns {string} the interpolated path + */ +const interpolate = (path, data, assetInfo) => { + const chunkGraph = data.chunkGraph; + + /** @type {Map} */ + const replacements = new Map(); + + // Filename context + // + // Placeholders + // + // for /some/path/file.js?query#fragment: + // [file] - /some/path/file.js + // [query] - ?query + // [fragment] - #fragment + // [base] - file.js + // [path] - /some/path/ + // [name] - file + // [ext] - .js + if (typeof data.filename === "string") { + // check that filename is data uri + const match = data.filename.match(/^data:([^;,]+)/); + if (match) { + const ext = getMimeTypes().extension(match[1]); + const emptyReplacer = replacer("", true); + // "XXXX" used for `updateHash`, so we don't need it here + const contentHash = + data.contentHash && !/X+/.test(data.contentHash) + ? data.contentHash + : false; + const baseReplacer = contentHash ? replacer(contentHash) : emptyReplacer; + + replacements.set("file", emptyReplacer); + replacements.set("query", emptyReplacer); + replacements.set("fragment", emptyReplacer); + replacements.set("path", emptyReplacer); + replacements.set("base", baseReplacer); + replacements.set("name", baseReplacer); + replacements.set("ext", replacer(ext ? `.${ext}` : "", true)); + // Legacy + replacements.set( + "filebase", + deprecated( + baseReplacer, + "[filebase] is now [base]", + "DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME" + ) + ); + } else { + const { path: file, query, fragment } = parseResource(data.filename); + + const ext = extname(file); + const base = basename(file); + const name = base.slice(0, base.length - ext.length); + const path = file.slice(0, file.length - base.length); + + replacements.set("file", replacer(file)); + replacements.set("query", replacer(query, true)); + replacements.set("fragment", replacer(fragment, true)); + replacements.set("path", replacer(path, true)); + replacements.set("base", replacer(base)); + replacements.set("name", replacer(name)); + replacements.set("ext", replacer(ext, true)); + // Legacy + replacements.set( + "filebase", + deprecated( + replacer(base), + "[filebase] is now [base]", + "DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME" + ) + ); + } + } + + // Compilation context + // + // Placeholders + // + // [fullhash] - data.hash (3a4b5c6e7f) + // + // Legacy Placeholders + // + // [hash] - data.hash (3a4b5c6e7f) + if (data.hash) { + const hashReplacer = hashLength( + replacer(data.hash), + data.hashWithLength, + assetInfo, + "fullhash" + ); + + replacements.set("fullhash", hashReplacer); + + // Legacy + replacements.set( + "hash", + deprecated( + hashReplacer, + "[hash] is now [fullhash] (also consider using [chunkhash] or [contenthash], see documentation for details)", + "DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_HASH" + ) + ); + } + + // Chunk Context + // + // Placeholders + // + // [id] - chunk.id (0.js) + // [name] - chunk.name (app.js) + // [chunkhash] - chunk.hash (7823t4t4.js) + // [contenthash] - chunk.contentHash[type] (3256u3zg.js) + if (data.chunk) { + const chunk = data.chunk; + + const contentHashType = data.contentHashType; + + const idReplacer = replacer(chunk.id); + const nameReplacer = replacer(chunk.name || chunk.id); + const chunkhashReplacer = hashLength( + replacer(chunk instanceof Chunk ? chunk.renderedHash : chunk.hash), + "hashWithLength" in chunk ? chunk.hashWithLength : undefined, + assetInfo, + "chunkhash" + ); + const contenthashReplacer = hashLength( + replacer( + data.contentHash || + (contentHashType && + chunk.contentHash && + chunk.contentHash[contentHashType]) + ), + data.contentHashWithLength || + ("contentHashWithLength" in chunk && chunk.contentHashWithLength + ? chunk.contentHashWithLength[/** @type {string} */ (contentHashType)] + : undefined), + assetInfo, + "contenthash" + ); + + replacements.set("id", idReplacer); + replacements.set("name", nameReplacer); + replacements.set("chunkhash", chunkhashReplacer); + replacements.set("contenthash", contenthashReplacer); + } + + // Module Context + // + // Placeholders + // + // [id] - module.id (2.png) + // [hash] - module.hash (6237543873.png) + // + // Legacy Placeholders + // + // [moduleid] - module.id (2.png) + // [modulehash] - module.hash (6237543873.png) + if (data.module) { + const module = data.module; + + const idReplacer = replacer(() => + (data.prepareId || prepareId)( + module instanceof Module + ? /** @type {ModuleId} */ + (/** @type {ChunkGraph} */ (chunkGraph).getModuleId(module)) + : module.id + ) + ); + const moduleHashReplacer = hashLength( + replacer(() => + module instanceof Module + ? /** @type {ChunkGraph} */ + (chunkGraph).getRenderedModuleHash(module, data.runtime) + : module.hash + ), + "hashWithLength" in module ? module.hashWithLength : undefined, + assetInfo, + "modulehash" + ); + const contentHashReplacer = hashLength( + replacer(/** @type {string} */ (data.contentHash)), + undefined, + assetInfo, + "contenthash" + ); + + replacements.set("id", idReplacer); + replacements.set("modulehash", moduleHashReplacer); + replacements.set("contenthash", contentHashReplacer); + replacements.set( + "hash", + data.contentHash ? contentHashReplacer : moduleHashReplacer + ); + // Legacy + replacements.set( + "moduleid", + deprecated( + idReplacer, + "[moduleid] is now [id]", + "DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_MODULE_ID" + ) + ); + } + + // Other things + if (data.url) { + replacements.set("url", replacer(data.url)); + } + if (typeof data.runtime === "string") { + replacements.set( + "runtime", + replacer(() => + (data.prepareId || prepareId)(/** @type {string} */ (data.runtime)) + ) + ); + } else { + replacements.set("runtime", replacer("_")); + } + + if (typeof path === "function") { + path = path(data, assetInfo); + } + + path = path.replace(REGEXP, (match, content) => { + if (content.length + 2 === match.length) { + const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content); + if (!contentMatch) return match; + const [, kind, arg] = contentMatch; + const replacer = replacements.get(kind); + if (replacer !== undefined) { + return replacer(match, arg, /** @type {string} */ (path)); + } + } else if (match.startsWith("[\\") && match.endsWith("\\]")) { + return `[${match.slice(2, -2)}]`; + } + return match; + }); + + return path; +}; + +const plugin = "TemplatedPathPlugin"; + +class TemplatedPathPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(plugin, (compilation) => { + compilation.hooks.assetPath.tap(plugin, interpolate); + }); + } +} + +module.exports = TemplatedPathPlugin; +module.exports.interpolate = interpolate; Index: frontend/node_modules/webpack/lib/UseStrictPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/UseStrictPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/UseStrictPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,82 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const ConstDependency = require("./dependencies/ConstDependency"); + +/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./Module").BuildInfo} BuildInfo */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ + +const PLUGIN_NAME = "UseStrictPlugin"; + +class UseStrictPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + * @param {JavascriptParserOptions} parserOptions the javascript parser options + */ + const handler = (parser, parserOptions) => { + parser.hooks.program.tap(PLUGIN_NAME, (ast) => { + const firstNode = ast.body[0]; + if ( + firstNode && + firstNode.type === "ExpressionStatement" && + firstNode.expression.type === "Literal" && + firstNode.expression.value === "use strict" + ) { + // Remove "use strict" expression. It will be added later by the renderer again. + // This is necessary in order to not break the strict mode when webpack prepends code. + // @see https://github.com/webpack/webpack/issues/1970 + const dep = new ConstDependency( + "", + /** @type {Range} */ (firstNode.range) + ); + dep.loc = /** @type {DependencyLocation} */ (firstNode.loc); + parser.state.module.addPresentationalDependency(dep); + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).strict = true; + } + if (parserOptions.overrideStrict) { + /** @type {BuildInfo} */ + (parser.state.module.buildInfo).strict = + parserOptions.overrideStrict === "strict"; + } + }); + }; + + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } +} + +module.exports = UseStrictPlugin; Index: frontend/node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,132 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./NormalModule")} NormalModule */ + +const WebpackError = require("./errors/WebpackError"); + +/** + * Sorts the conflicting modules by identifier to keep warning output stable. + * @param {Module[]} modules the modules to be sorted + * @returns {Module[]} sorted version of original modules + */ +const sortModules = (modules) => + modules.sort((a, b) => { + const aIdent = a.identifier(); + const bIdent = b.identifier(); + /* istanbul ignore next */ + if (aIdent < bIdent) return -1; + /* istanbul ignore next */ + if (aIdent > bIdent) return 1; + /* istanbul ignore next */ + return 0; + }); + +/** + * Formats the conflicting modules and one representative incoming reason for + * each module into the warning body. + * @param {Module[]} modules each module from throw + * @param {ModuleGraph} moduleGraph the module graph + * @returns {string} each message from provided modules + */ +const createModulesListMessage = (modules, moduleGraph) => + modules + .map((m) => { + let message = `* ${m.identifier()}`; + const validReasons = [ + ...moduleGraph.getIncomingConnectionsByOriginModule(m).keys() + ].filter(Boolean); + + if (validReasons.length > 0) { + message += `\n Used by ${validReasons.length} module(s), i. e.`; + message += `\n ${ + /** @type {Module[]} */ (validReasons)[0].identifier() + }`; + } + return message; + }) + .join("\n"); + +/** + * Warning emitted when webpack finds modules whose identifiers differ only by + * letter casing, which can behave inconsistently across filesystems. + */ +class CaseSensitiveModulesWarning extends WebpackError { + /** + * Builds a warning message that lists the case-conflicting modules and + * representative importers that caused them to be included. + * @param {Iterable} modules modules that were detected + * @param {ModuleGraph} moduleGraph the module graph + */ + constructor(modules, moduleGraph) { + const sortedModules = sortModules([...modules]); + const modulesList = createModulesListMessage(sortedModules, moduleGraph); + super(`There are multiple modules with names that only differ in casing. +This can lead to unexpected behavior when compiling on a filesystem with other case-semantic. +Use equal casing. Compare these module identifiers: +${modulesList}`); + + /** @type {string} */ + this.name = "CaseSensitiveModulesWarning"; + this.module = sortedModules[0]; + } +} + +const PLUGIN_NAME = "WarnCaseSensitiveModulesPlugin"; + +class WarnCaseSensitiveModulesPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + compilation.hooks.seal.tap(PLUGIN_NAME, () => { + /** @type {Map>} */ + const moduleWithoutCase = new Map(); + for (const module of compilation.modules) { + const identifier = module.identifier(); + + // Ignore `data:` URLs, because it's not a real path + if ( + /** @type {NormalModule} */ + (module).resourceResolveData !== undefined && + /** @type {NormalModule} */ + (module).resourceResolveData.encodedContent !== undefined + ) { + continue; + } + + const lowerIdentifier = identifier.toLowerCase(); + let map = moduleWithoutCase.get(lowerIdentifier); + if (map === undefined) { + map = new Map(); + moduleWithoutCase.set(lowerIdentifier, map); + } + map.set(identifier, module); + } + for (const pair of moduleWithoutCase) { + const map = pair[1]; + if (map.size > 1) { + compilation.warnings.push( + new CaseSensitiveModulesWarning( + map.values(), + compilation.moduleGraph + ) + ); + } + } + }); + }); + } +} + +module.exports = WarnCaseSensitiveModulesPlugin; Index: frontend/node_modules/webpack/lib/WarnDeprecatedOptionPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/WarnDeprecatedOptionPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WarnDeprecatedOptionPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,60 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Florent Cailhol @ooflorent +*/ + +"use strict"; + +const WebpackError = require("./errors/WebpackError"); + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "WarnDeprecatedOptionPlugin"; + +class WarnDeprecatedOptionPlugin { + /** + * Create an instance of the plugin + * @param {string} option the target option + * @param {string | number} value the deprecated option value + * @param {string} suggestion the suggestion replacement + */ + constructor(option, value, suggestion) { + this.option = option; + this.value = value; + this.suggestion = suggestion; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => { + compilation.warnings.push( + new DeprecatedOptionWarning(this.option, this.value, this.suggestion) + ); + }); + } +} + +class DeprecatedOptionWarning extends WebpackError { + /** + * Create an instance deprecated option warning + * @param {string} option the target option + * @param {string | number} value the deprecated option value + * @param {string} suggestion the suggestion replacement + */ + constructor(option, value, suggestion) { + super(); + + /** @type {string} */ + this.name = "DeprecatedOptionWarning"; + this.message = + "configuration\n" + + `The value '${value}' for option '${option}' is deprecated. ` + + `Use '${suggestion}' instead.`; + } +} + +module.exports = WarnDeprecatedOptionPlugin; Index: frontend/node_modules/webpack/lib/WarnNoModeSetPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/WarnNoModeSetPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WarnNoModeSetPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const WebpackError = require("./errors/WebpackError"); + +class NoModeWarning extends WebpackError { + constructor() { + super(); + + /** @type {string} */ + this.name = "NoModeWarning"; + this.message = + "configuration\n" + + "The 'mode' option has not been set, webpack will fallback to 'production' for this value.\n" + + "Set 'mode' option to 'development' or 'production' to enable defaults for each environment.\n" + + "You can also set it to 'none' to disable any default behavior. " + + "Learn more: https://webpack.js.org/configuration/mode/"; + } +} + +/** @typedef {import("./Compiler")} Compiler */ + +const PLUGIN_NAME = "WarnNoModeSetPlugin"; + +class WarnNoModeSetPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => { + compilation.warnings.push(new NoModeWarning()); + }); + } +} + +module.exports = WarnNoModeSetPlugin; Index: frontend/node_modules/webpack/lib/WatchIgnorePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/WatchIgnorePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WatchIgnorePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,160 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { groupBy } = require("./util/ArrayHelpers"); + +/** @typedef {import("watchpack").TimeInfoEntries} TimeInfoEntries */ +/** @typedef {import("../declarations/plugins/WatchIgnorePlugin").WatchIgnorePluginOptions} WatchIgnorePluginOptions */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */ +/** @typedef {import("./util/fs").WatchMethod} WatchMethod */ +/** @typedef {import("./util/fs").Watcher} Watcher */ + +const IGNORE_TIME_ENTRY = "ignore"; + +class IgnoringWatchFileSystem { + /** + * Creates an instance of IgnoringWatchFileSystem. + * @param {WatchFileSystem} wfs original file system + * @param {WatchIgnorePluginOptions["paths"]} paths ignored paths + */ + constructor(wfs, paths) { + this.wfs = wfs; + this.paths = paths; + } + + /** @type {WatchMethod} */ + watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) { + files = [...files]; + dirs = [...dirs]; + /** + * Returns true, if path is ignored. + * @param {string} path path to check + * @returns {boolean} true, if path is ignored + */ + const ignored = (path) => + this.paths.some((p) => + p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0 + ); + + const [ignoredFiles, notIgnoredFiles] = groupBy( + /** @type {string[]} */ + (files), + ignored + ); + const [ignoredDirs, notIgnoredDirs] = groupBy( + /** @type {string[]} */ + (dirs), + ignored + ); + + const watcher = this.wfs.watch( + notIgnoredFiles, + notIgnoredDirs, + missing, + startTime, + options, + (err, fileTimestamps, dirTimestamps, changedFiles, removedFiles) => { + if (err) return callback(err); + for (const path of ignoredFiles) { + /** @type {TimeInfoEntries} */ + (fileTimestamps).set(path, IGNORE_TIME_ENTRY); + } + + for (const path of ignoredDirs) { + /** @type {TimeInfoEntries} */ + (dirTimestamps).set(path, IGNORE_TIME_ENTRY); + } + + callback( + null, + fileTimestamps, + dirTimestamps, + changedFiles, + removedFiles + ); + }, + callbackUndelayed + ); + + return { + close: () => watcher.close(), + pause: () => watcher.pause(), + getContextTimeInfoEntries: () => { + const dirTimestamps = watcher.getContextTimeInfoEntries(); + for (const path of ignoredDirs) { + dirTimestamps.set(path, IGNORE_TIME_ENTRY); + } + return dirTimestamps; + }, + getFileTimeInfoEntries: () => { + const fileTimestamps = watcher.getFileTimeInfoEntries(); + for (const path of ignoredFiles) { + fileTimestamps.set(path, IGNORE_TIME_ENTRY); + } + return fileTimestamps; + }, + getInfo: + watcher.getInfo && + (() => { + const info = + /** @type {NonNullable} */ + (watcher.getInfo)(); + const { fileTimeInfoEntries, contextTimeInfoEntries } = info; + for (const path of ignoredFiles) { + fileTimeInfoEntries.set(path, IGNORE_TIME_ENTRY); + } + for (const path of ignoredDirs) { + contextTimeInfoEntries.set(path, IGNORE_TIME_ENTRY); + } + return info; + }) + }; + } +} + +const PLUGIN_NAME = "WatchIgnorePlugin"; + +class WatchIgnorePlugin { + /** + * Creates an instance of WatchIgnorePlugin. + * @param {WatchIgnorePluginOptions} options options + */ + constructor(options) { + /** @type {WatchIgnorePluginOptions} */ + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.validate.tap(PLUGIN_NAME, () => { + compiler.validate( + () => require("../schemas/plugins/WatchIgnorePlugin.json"), + this.options, + { + name: "Watch Ignore Plugin", + baseDataPath: "options" + }, + (options) => + require("../schemas/plugins/WatchIgnorePlugin.check")(options) + ); + }); + compiler.hooks.afterEnvironment.tap(PLUGIN_NAME, () => { + compiler.watchFileSystem = new IgnoringWatchFileSystem( + /** @type {WatchFileSystem} */ + (compiler.watchFileSystem), + this.options.paths + ); + }); + } +} + +module.exports = WatchIgnorePlugin; Index: frontend/node_modules/webpack/lib/Watching.js =================================================================== --- frontend/node_modules/webpack/lib/Watching.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/Watching.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,544 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Stats = require("./Stats"); + +/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Compiler").ErrorCallback} ErrorCallback */ +/** @typedef {import("./logging/Logger").Logger} Logger */ +/** @typedef {import("./util/fs").TimeInfoEntries} TimeInfoEntries */ +/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */ +/** @typedef {import("./util/fs").Watcher} Watcher */ + +/** + * Defines the callback type used by this module. + * @template T + * @template [R=void] + * @typedef {import("./webpack").Callback} Callback + */ + +/** @typedef {Set} CollectedFiles */ + +class Watching { + /** + * Creates an instance of Watching. + * @param {Compiler} compiler the compiler + * @param {WatchOptions} watchOptions options + * @param {Callback} handler completion handler + */ + constructor(compiler, watchOptions, handler) { + /** @type {null | number} */ + this.startTime = null; + this.invalid = false; + /** @type {Callback} */ + this.handler = handler; + /** @type {ErrorCallback[]} */ + this.callbacks = []; + /** @type {ErrorCallback[] | undefined} */ + this._closeCallbacks = undefined; + this.closed = false; + this.suspended = false; + this.blocked = false; + this._isBlocked = () => false; + this._onChange = () => {}; + this._onInvalid = () => {}; + if (typeof watchOptions === "number") { + /** @type {WatchOptions} */ + this.watchOptions = { + aggregateTimeout: watchOptions + }; + } else if (watchOptions && typeof watchOptions === "object") { + /** @type {WatchOptions} */ + this.watchOptions = { ...watchOptions }; + } else { + /** @type {WatchOptions} */ + this.watchOptions = {}; + } + if (typeof this.watchOptions.aggregateTimeout !== "number") { + this.watchOptions.aggregateTimeout = 20; + } + this.compiler = compiler; + this.running = false; + this._initial = true; + this._invalidReported = true; + this._needRecords = true; + /** @type {undefined | null | Watcher} */ + this.watcher = undefined; + /** @type {undefined | null | Watcher} */ + this.pausedWatcher = undefined; + /** @type {CollectedFiles | undefined} */ + this._collectedChangedFiles = undefined; + /** @type {CollectedFiles | undefined} */ + this._collectedRemovedFiles = undefined; + this._done = this._done.bind(this); + process.nextTick(() => { + if (this._initial) this._invalidate(); + }); + } + + /** + * Merge with collected. + * @param {ReadonlySet | undefined | null} changedFiles changed files + * @param {ReadonlySet | undefined | null} removedFiles removed files + */ + _mergeWithCollected(changedFiles, removedFiles) { + if (!changedFiles) return; + if (!this._collectedChangedFiles) { + this._collectedChangedFiles = new Set(changedFiles); + this._collectedRemovedFiles = new Set(removedFiles); + } else { + for (const file of changedFiles) { + this._collectedChangedFiles.add(file); + /** @type {CollectedFiles} */ + (this._collectedRemovedFiles).delete(file); + } + for (const file of /** @type {ReadonlySet} */ (removedFiles)) { + this._collectedChangedFiles.delete(file); + /** @type {CollectedFiles} */ + (this._collectedRemovedFiles).add(file); + } + } + } + + /** + * Processes the provided file time info entries. + * @param {TimeInfoEntries=} fileTimeInfoEntries info for files + * @param {TimeInfoEntries=} contextTimeInfoEntries info for directories + * @param {ReadonlySet=} changedFiles changed files + * @param {ReadonlySet=} removedFiles removed files + * @returns {void} + */ + _go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) { + this._initial = false; + if (this.startTime === null) this.startTime = Date.now(); + this.running = true; + if (this.watcher) { + this.pausedWatcher = this.watcher; + this.lastWatcherStartTime = Date.now(); + this.watcher.pause(); + this.watcher = null; + } else if (!this.lastWatcherStartTime) { + this.lastWatcherStartTime = Date.now(); + } + this.compiler.fsStartTime = Date.now(); + if ( + changedFiles && + removedFiles && + fileTimeInfoEntries && + contextTimeInfoEntries + ) { + this._mergeWithCollected(changedFiles, removedFiles); + this.compiler.fileTimestamps = fileTimeInfoEntries; + this.compiler.contextTimestamps = contextTimeInfoEntries; + } else if (this.pausedWatcher) { + if (this.pausedWatcher.getInfo) { + const { + changes, + removals, + fileTimeInfoEntries, + contextTimeInfoEntries + } = this.pausedWatcher.getInfo(); + this._mergeWithCollected(changes, removals); + this.compiler.fileTimestamps = fileTimeInfoEntries; + this.compiler.contextTimestamps = contextTimeInfoEntries; + } else { + this._mergeWithCollected( + this.pausedWatcher.getAggregatedChanges && + this.pausedWatcher.getAggregatedChanges(), + this.pausedWatcher.getAggregatedRemovals && + this.pausedWatcher.getAggregatedRemovals() + ); + this.compiler.fileTimestamps = + this.pausedWatcher.getFileTimeInfoEntries(); + this.compiler.contextTimestamps = + this.pausedWatcher.getContextTimeInfoEntries(); + } + } + this.compiler.modifiedFiles = this._collectedChangedFiles; + this._collectedChangedFiles = undefined; + this.compiler.removedFiles = this._collectedRemovedFiles; + this._collectedRemovedFiles = undefined; + + const run = () => { + if (this.compiler.idle) { + return this.compiler.cache.endIdle((err) => { + if (err) return this._done(err); + this.compiler.idle = false; + run(); + }); + } + if (this._needRecords) { + return this.compiler.readRecords((err) => { + if (err) return this._done(err); + + this._needRecords = false; + run(); + }); + } + this.invalid = false; + this._invalidReported = false; + this.compiler.hooks.watchRun.callAsync(this.compiler, (err) => { + if (err) return this._done(err); + /** + * Processes the provided err. + * @param {Error | null} err error + * @param {Compilation=} _compilation compilation + * @returns {void} + */ + const onCompiled = (err, _compilation) => { + if (err) return this._done(err, _compilation); + + const compilation = /** @type {Compilation} */ (_compilation); + + if (this.compiler.hooks.shouldEmit.call(compilation) === false) { + return this._done(null, compilation); + } + + process.nextTick(() => { + const logger = compilation.getLogger("webpack.Compiler"); + logger.time("emitAssets"); + this.compiler.emitAssets(compilation, (err) => { + logger.timeEnd("emitAssets"); + if (err) return this._done(err, compilation); + if (this.invalid) return this._done(null, compilation); + + logger.time("emitRecords"); + this.compiler.emitRecords((err) => { + logger.timeEnd("emitRecords"); + if (err) return this._done(err, compilation); + + if (compilation.hooks.needAdditionalPass.call()) { + compilation.needAdditionalPass = true; + + compilation.startTime = /** @type {number} */ ( + this.startTime + ); + compilation.endTime = Date.now(); + logger.time("done hook"); + const stats = new Stats(compilation); + this.compiler.hooks.done.callAsync(stats, (err) => { + logger.timeEnd("done hook"); + if (err) return this._done(err, compilation); + + this.compiler.hooks.additionalPass.callAsync((err) => { + if (err) return this._done(err, compilation); + this.compiler.compile(onCompiled); + }); + }); + return; + } + return this._done(null, compilation); + }); + }); + }); + }; + this.compiler.compile(onCompiled); + }); + }; + + run(); + } + + /** + * Returns the compilation stats. + * @param {Compilation} compilation the compilation + * @returns {Stats} the compilation stats + */ + _getStats(compilation) { + const stats = new Stats(compilation); + return stats; + } + + /** + * Processes the provided err. + * @param {(Error | null)=} err an optional error + * @param {Compilation=} compilation the compilation + * @returns {void} + */ + _done(err, compilation) { + this.running = false; + + const logger = + /** @type {Logger} */ + (compilation && compilation.getLogger("webpack.Watching")); + + /** @type {Stats | undefined} */ + let stats; + + /** + * Processes the provided err. + * @param {Error} err error + * @param {ErrorCallback[]=} cbs callbacks + */ + const handleError = (err, cbs) => { + this.compiler.hooks.failed.call(err); + this.compiler.cache.beginIdle(); + this.compiler.idle = true; + this.handler(err, /** @type {Stats} */ (stats)); + if (!cbs) { + cbs = this.callbacks; + this.callbacks = []; + } + for (const cb of cbs) cb(err); + }; + + if ( + this.invalid && + !this.suspended && + !this.blocked && + !(this._isBlocked() && (this.blocked = true)) + ) { + if (compilation) { + logger.time("storeBuildDependencies"); + this.compiler.cache.storeBuildDependencies( + compilation.buildDependencies, + (err) => { + logger.timeEnd("storeBuildDependencies"); + if (err) return handleError(err); + this._go(); + } + ); + } else { + this._go(); + } + return; + } + + if (compilation) { + compilation.startTime = /** @type {number} */ (this.startTime); + compilation.endTime = Date.now(); + stats = new Stats(compilation); + } + this.startTime = null; + if (err) return handleError(err); + + const cbs = this.callbacks; + this.callbacks = []; + logger.time("done hook"); + this.compiler.hooks.done.callAsync(/** @type {Stats} */ (stats), (err) => { + logger.timeEnd("done hook"); + if (err) return handleError(err, cbs); + this.handler(null, stats); + logger.time("storeBuildDependencies"); + this.compiler.cache.storeBuildDependencies( + /** @type {Compilation} */ + (compilation).buildDependencies, + (err) => { + logger.timeEnd("storeBuildDependencies"); + if (err) return handleError(err, cbs); + logger.time("beginIdle"); + this.compiler.cache.beginIdle(); + this.compiler.idle = true; + logger.timeEnd("beginIdle"); + process.nextTick(() => { + if (!this.closed) { + this.watch( + /** @type {Compilation} */ + (compilation).fileDependencies, + /** @type {Compilation} */ + (compilation).contextDependencies, + /** @type {Compilation} */ + (compilation).missingDependencies + ); + } + }); + for (const cb of cbs) cb(null); + this.compiler.hooks.afterDone.call(/** @type {Stats} */ (stats)); + } + ); + }); + } + + /** + * Processes the provided file. + * @param {Iterable} files watched files + * @param {Iterable} dirs watched directories + * @param {Iterable} missing watched existence entries + * @returns {void} + */ + watch(files, dirs, missing) { + this.pausedWatcher = null; + this.watcher = + /** @type {WatchFileSystem} */ + (this.compiler.watchFileSystem).watch( + files, + dirs, + missing, + /** @type {number} */ (this.lastWatcherStartTime), + this.watchOptions, + ( + err, + fileTimeInfoEntries, + contextTimeInfoEntries, + changedFiles, + removedFiles + ) => { + if (err) { + this.compiler.modifiedFiles = undefined; + this.compiler.removedFiles = undefined; + this.compiler.fileTimestamps = undefined; + this.compiler.contextTimestamps = undefined; + this.compiler.fsStartTime = undefined; + return this.handler(err); + } + this._invalidate( + fileTimeInfoEntries, + contextTimeInfoEntries, + changedFiles, + removedFiles + ); + this._onChange(); + }, + (fileName, changeTime) => { + if (!this._invalidReported) { + this._invalidReported = true; + this.compiler.hooks.invalid.call(fileName, changeTime); + } + this._onInvalid(); + } + ); + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback=} callback signals when the build has completed again + * @returns {void} + */ + invalidate(callback) { + if (callback) { + this.callbacks.push(callback); + } + if (!this._invalidReported) { + this._invalidReported = true; + this.compiler.hooks.invalid.call(null, Date.now()); + } + this._onChange(); + this._invalidate(); + } + + /** + * Processes the provided file time info entries. + * @param {TimeInfoEntries=} fileTimeInfoEntries info for files + * @param {TimeInfoEntries=} contextTimeInfoEntries info for directories + * @param {ReadonlySet=} changedFiles changed files + * @param {ReadonlySet=} removedFiles removed files + * @returns {void} + */ + _invalidate( + fileTimeInfoEntries, + contextTimeInfoEntries, + changedFiles, + removedFiles + ) { + if (this.suspended || (this._isBlocked() && (this.blocked = true))) { + this._mergeWithCollected(changedFiles, removedFiles); + return; + } + + if (this.running) { + this._mergeWithCollected(changedFiles, removedFiles); + this.invalid = true; + } else { + this._go( + fileTimeInfoEntries, + contextTimeInfoEntries, + changedFiles, + removedFiles + ); + } + } + + suspend() { + this.suspended = true; + } + + resume() { + if (this.suspended) { + this.suspended = false; + this._invalidate(); + } + } + + /** + * Processes the provided error callback. + * @param {ErrorCallback} callback signals when the watcher is closed + * @returns {void} + */ + close(callback) { + if (this._closeCallbacks) { + if (callback) { + this._closeCallbacks.push(callback); + } + return; + } + /** + * Processes the provided err. + * @param {Error | null} err error if any + * @param {Compilation=} compilation compilation if any + */ + const finalCallback = (err, compilation) => { + this.running = false; + this.compiler.running = false; + this.compiler.watching = undefined; + this.compiler.watchMode = false; + this.compiler.modifiedFiles = undefined; + this.compiler.removedFiles = undefined; + this.compiler.fileTimestamps = undefined; + this.compiler.contextTimestamps = undefined; + this.compiler.fsStartTime = undefined; + /** + * Processes the provided err. + * @param {Error | null} err error if any + */ + const shutdown = (err) => { + this.compiler.hooks.watchClose.call(); + const closeCallbacks = + /** @type {ErrorCallback[]} */ + (this._closeCallbacks); + this._closeCallbacks = undefined; + for (const cb of closeCallbacks) cb(err); + }; + if (compilation) { + const logger = compilation.getLogger("webpack.Watching"); + logger.time("storeBuildDependencies"); + this.compiler.cache.storeBuildDependencies( + compilation.buildDependencies, + (err2) => { + logger.timeEnd("storeBuildDependencies"); + shutdown(err || err2); + } + ); + } else { + shutdown(err); + } + }; + + this.closed = true; + if (this.watcher) { + this.watcher.close(); + this.watcher = null; + } + if (this.pausedWatcher) { + this.pausedWatcher.close(); + this.pausedWatcher = null; + } + this._closeCallbacks = []; + if (callback) { + this._closeCallbacks.push(callback); + } + if (this.running) { + this.invalid = true; + this._done = finalCallback; + } else { + finalCallback(null); + } + } +} + +module.exports = Watching; Index: frontend/node_modules/webpack/lib/WebpackError.js =================================================================== --- frontend/node_modules/webpack/lib/WebpackError.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WebpackError.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,10 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Jarid Margolin @jaridmargolin +*/ + +"use strict"; + +// TODO remove in webpack 6 +// Some old plugins use `require("webpack/lib/WebpackError")`, in webpack@6 developer should migrate to `compiler.webpack.WebpackError` +module.exports = require("./errors/WebpackError"); Index: frontend/node_modules/webpack/lib/WebpackIsIncludedPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/WebpackIsIncludedPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WebpackIsIncludedPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,95 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +const { + JAVASCRIPT_MODULE_TYPE_AUTO, + JAVASCRIPT_MODULE_TYPE_DYNAMIC, + JAVASCRIPT_MODULE_TYPE_ESM +} = require("./ModuleTypeConstants"); +const WebpackIsIncludedDependency = require("./dependencies/WebpackIsIncludedDependency"); +const IgnoreErrorModuleFactory = require("./errors/IgnoreErrorModuleFactory"); +const { + toConstantDependency +} = require("./javascript/JavascriptParserHelpers"); + +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */ +/** @typedef {import("./javascript/JavascriptParser").Range} Range */ + +const PLUGIN_NAME = "WebpackIsIncludedPlugin"; + +class WebpackIsIncludedPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + compilation.dependencyFactories.set( + WebpackIsIncludedDependency, + new IgnoreErrorModuleFactory(normalModuleFactory) + ); + compilation.dependencyTemplates.set( + WebpackIsIncludedDependency, + new WebpackIsIncludedDependency.Template() + ); + + /** + * Handles the hook callback for this code path. + * @param {JavascriptParser} parser the parser + * @returns {void} + */ + const handler = (parser) => { + parser.hooks.call + .for("__webpack_is_included__") + .tap(PLUGIN_NAME, (expr) => { + if ( + expr.type !== "CallExpression" || + expr.arguments.length !== 1 || + expr.arguments[0].type === "SpreadElement" + ) { + return; + } + + const request = parser.evaluateExpression(expr.arguments[0]); + + if (!request.isString()) return; + + const dep = new WebpackIsIncludedDependency( + /** @type {string} */ (request.string), + /** @type {Range} */ (expr.range) + ); + dep.loc = /** @type {DependencyLocation} */ (expr.loc); + parser.state.module.addDependency(dep); + return true; + }); + parser.hooks.typeof + .for("__webpack_is_included__") + .tap( + PLUGIN_NAME, + toConstantDependency(parser, JSON.stringify("function")) + ); + }; + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_AUTO) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC) + .tap(PLUGIN_NAME, handler); + normalModuleFactory.hooks.parser + .for(JAVASCRIPT_MODULE_TYPE_ESM) + .tap(PLUGIN_NAME, handler); + } + ); + } +} + +module.exports = WebpackIsIncludedPlugin; Index: frontend/node_modules/webpack/lib/WebpackOptionsApply.js =================================================================== --- frontend/node_modules/webpack/lib/WebpackOptionsApply.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WebpackOptionsApply.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,954 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const APIPlugin = require("./APIPlugin"); + +const CompatibilityPlugin = require("./CompatibilityPlugin"); + +const ConstPlugin = require("./ConstPlugin"); + +const EntryOptionPlugin = require("./EntryOptionPlugin"); + +const ExportsInfoApiPlugin = require("./ExportsInfoApiPlugin"); +const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin"); + +const JavascriptMetaInfoPlugin = require("./JavascriptMetaInfoPlugin"); + +const NodeStuffPlugin = require("./NodeStuffPlugin"); +const OptionsApply = require("./OptionsApply"); + +const RecordIdsPlugin = require("./RecordIdsPlugin"); + +const RuntimePlugin = require("./RuntimePlugin"); + +const TemplatedPathPlugin = require("./TemplatedPathPlugin"); + +const UseStrictPlugin = require("./UseStrictPlugin"); + +const WarnCaseSensitiveModulesPlugin = require("./WarnCaseSensitiveModulesPlugin"); + +const WebpackIsIncludedPlugin = require("./WebpackIsIncludedPlugin"); + +const AssetModulesPlugin = require("./asset/AssetModulesPlugin"); + +const InferAsyncModulesPlugin = require("./async-modules/InferAsyncModulesPlugin"); + +const ResolverCachePlugin = require("./cache/ResolverCachePlugin"); + +const CommonJsPlugin = require("./dependencies/CommonJsPlugin"); + +const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin"); + +const ImportMetaContextPlugin = require("./dependencies/ImportMetaContextPlugin"); +const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin"); + +const ImportPlugin = require("./dependencies/ImportPlugin"); +const LoaderPlugin = require("./dependencies/LoaderPlugin"); + +const RequireContextPlugin = require("./dependencies/RequireContextPlugin"); +const RequireEnsurePlugin = require("./dependencies/RequireEnsurePlugin"); +const RequireIncludePlugin = require("./dependencies/RequireIncludePlugin"); + +const SystemPlugin = require("./dependencies/SystemPlugin"); + +const URLPlugin = require("./dependencies/URLPlugin"); + +const WorkerPlugin = require("./dependencies/WorkerPlugin"); + +const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin"); +const JavascriptParser = require("./javascript/JavascriptParser"); + +const JsonModulesPlugin = require("./json/JsonModulesPlugin"); + +const ChunkPrefetchPreloadPlugin = require("./prefetch/ChunkPrefetchPreloadPlugin"); + +const DataUriPlugin = require("./schemes/DataUriPlugin"); +const FileUriPlugin = require("./schemes/FileUriPlugin"); + +const DefaultStatsFactoryPlugin = require("./stats/DefaultStatsFactoryPlugin"); +const DefaultStatsPresetPlugin = require("./stats/DefaultStatsPresetPlugin"); +const DefaultStatsPrinterPlugin = require("./stats/DefaultStatsPrinterPlugin"); + +const { cleverMerge } = require("./util/cleverMerge"); + +/** @typedef {import("./webpack").WebpackPluginFunction} WebpackPluginFunction */ +/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("./config/normalization").WebpackOptionsInterception} WebpackOptionsInterception */ +/** @typedef {import("./Compiler")} Compiler */ +/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */ +/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */ + +const CLASS_NAME = "WebpackOptionsApply"; + +class WebpackOptionsApply extends OptionsApply { + constructor() { + super(); + } + + /** + * Returns options object. + * @param {WebpackOptions} options options object + * @param {Compiler} compiler compiler object + * @param {WebpackOptionsInterception=} interception intercepted options + * @returns {WebpackOptions} options object + */ + process(options, compiler, interception) { + compiler.outputPath = options.output.path; + compiler.recordsInputPath = options.recordsInputPath || null; + compiler.recordsOutputPath = options.recordsOutputPath || null; + compiler.name = options.name; + + if (options.externals) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ExternalsPlugin = require("./ExternalsPlugin"); + + new ExternalsPlugin(options.externalsType, options.externals).apply( + compiler + ); + } + + if (options.externalsPresets.node) { + const NodeTargetPlugin = require("./node/NodeTargetPlugin"); + + // Some older versions of Node.js don't support all built-in modules via import, only via `require`, + // but it seems like there shouldn't be a warning here since these versions are rarely used in real applications + new NodeTargetPlugin( + options.output.module ? "module-import" : "node-commonjs" + ).apply(compiler); + + // Handle external CSS `@import` and `url()` + if (options.experiments.css) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ExternalsPlugin = require("./ExternalsPlugin"); + + new ExternalsPlugin( + "module", + ({ request, dependencyType, contextInfo }, callback) => { + if ( + /\.css(?:\?|$)/.test(contextInfo.issuer) && + /^(?:\/\/|https?:\/\/|#)/.test(request) + ) { + if (dependencyType === "url") { + return callback(null, `asset ${request}`); + } else if ( + (dependencyType === "css-import" || + dependencyType === "css-import-local-module" || + dependencyType === "css-import-global-module") && + options.experiments.css + ) { + return callback(null, `css-import ${request}`); + } + } + + callback(); + } + ).apply(compiler); + } + } + if (options.externalsPresets.webAsync || options.externalsPresets.web) { + const type = options.externalsPresets.webAsync ? "import" : "module"; + + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ExternalsPlugin = require("./ExternalsPlugin"); + + new ExternalsPlugin(type, ({ request, dependencyType }, callback) => { + if (/^(?:\/\/|https?:\/\/|#|std:|jsr:|npm:)/.test(request)) { + if (dependencyType === "url") { + return callback(null, `asset ${request}`); + } else if ( + (dependencyType === "css-import" || + dependencyType === "css-import-local-module" || + dependencyType === "css-import-global-module") && + options.experiments.css + ) { + return callback(null, `css-import ${request}`); + } else if (/^(?:\/\/|https?:\/\/|std:|jsr:|npm:)/.test(request)) { + return callback(null, `${type} ${request}`); + } + } + + callback(); + }).apply(compiler); + } + if (options.externalsPresets.electron) { + if (options.externalsPresets.electronMain) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin"); + + new ElectronTargetPlugin("main").apply(compiler); + } + if (options.externalsPresets.electronPreload) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin"); + + new ElectronTargetPlugin("preload").apply(compiler); + } + if (options.externalsPresets.electronRenderer) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin"); + + new ElectronTargetPlugin("renderer").apply(compiler); + } + if ( + !options.externalsPresets.electronMain && + !options.externalsPresets.electronPreload && + !options.externalsPresets.electronRenderer + ) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin"); + + new ElectronTargetPlugin().apply(compiler); + } + } + if (options.externalsPresets.nwjs) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const ExternalsPlugin = require("./ExternalsPlugin"); + + new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler); + } + + new ChunkPrefetchPreloadPlugin().apply(compiler); + + if (typeof options.output.chunkFormat === "string") { + switch (options.output.chunkFormat) { + case "array-push": { + const ArrayPushCallbackChunkFormatPlugin = require("./javascript/ArrayPushCallbackChunkFormatPlugin"); + + new ArrayPushCallbackChunkFormatPlugin().apply(compiler); + break; + } + case "commonjs": { + const CommonJsChunkFormatPlugin = require("./javascript/CommonJsChunkFormatPlugin"); + + new CommonJsChunkFormatPlugin().apply(compiler); + break; + } + case "module": { + const ModuleChunkFormatPlugin = require("./esm/ModuleChunkFormatPlugin"); + + new ModuleChunkFormatPlugin().apply(compiler); + break; + } + default: + throw new Error( + `Unsupported chunk format '${options.output.chunkFormat}'.` + ); + } + } + + const enabledChunkLoadingTypes = + /** @type {NonNullable} */ + (options.output.enabledChunkLoadingTypes); + + if (enabledChunkLoadingTypes.length > 0) { + for (const type of enabledChunkLoadingTypes) { + const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin"); + + new EnableChunkLoadingPlugin(type).apply(compiler); + } + } + + const enabledWasmLoadingTypes = + /** @type {NonNullable} */ + (options.output.enabledWasmLoadingTypes); + + if (enabledWasmLoadingTypes.length > 0) { + for (const type of enabledWasmLoadingTypes) { + const EnableWasmLoadingPlugin = require("./wasm/EnableWasmLoadingPlugin"); + + new EnableWasmLoadingPlugin(type).apply(compiler); + } + } + + const enabledLibraryTypes = + /** @type {NonNullable} */ + (options.output.enabledLibraryTypes); + + if (enabledLibraryTypes.length > 0) { + let once = true; + for (const type of enabledLibraryTypes) { + const EnableLibraryPlugin = require("./library/EnableLibraryPlugin"); + + new EnableLibraryPlugin(type, { + // eslint-disable-next-line no-loop-func + additionalApply: () => { + if (!once) return; + once = false; + // We rely on `exportInfo` to generate the `export statement` in certain library bundles. + // Therefore, we ignore the disabling of `optimization.providedExport` and continue to apply `FlagDependencyExportsPlugin`. + if ( + ["module", "commonjs-static", "modern-module"].includes(type) && + !options.optimization.providedExports + ) { + new FlagDependencyExportsPlugin().apply(compiler); + } + } + }).apply(compiler); + } + } + + if (options.output.pathinfo) { + const ModuleInfoHeaderPlugin = require("./ModuleInfoHeaderPlugin"); + + new ModuleInfoHeaderPlugin(options.output.pathinfo !== true).apply( + compiler + ); + } + + if (options.output.clean) { + const CleanPlugin = require("./CleanPlugin"); + + new CleanPlugin( + options.output.clean === true ? {} : options.output.clean + ).apply(compiler); + } + + if (options.dotenv) { + const DotenvPlugin = require("./DotenvPlugin"); + + new DotenvPlugin( + typeof options.dotenv === "boolean" ? {} : options.dotenv + ).apply(compiler); + } + + let devtool = + interception === undefined ? options.devtool : interception.devtool; + devtool = Array.isArray(devtool) + ? devtool + : typeof devtool === "string" + ? [{ type: "all", use: devtool }] + : []; + + for (const item of devtool) { + const { type, use } = item; + + if (use) { + if (use.includes("source-map")) { + const hidden = use.includes("hidden"); + const inline = use.includes("inline"); + const evalWrapped = use.includes("eval"); + const cheap = use.includes("cheap"); + const moduleMaps = use.includes("module"); + const noSources = use.includes("nosources"); + const debugIds = use.includes("debugids"); + const Plugin = evalWrapped + ? require("./EvalSourceMapDevToolPlugin") + : require("./SourceMapDevToolPlugin"); + const assetExt = + type === "javascript" + ? /\.((c|m)?js)($|\?)/i + : type === "css" + ? /\.(css)($|\?)/i + : /\.((c|m)?js|css)($|\?)/i; + + new Plugin({ + test: evalWrapped ? undefined : assetExt, + filename: inline ? null : options.output.sourceMapFilename, + moduleFilenameTemplate: + options.output.devtoolModuleFilenameTemplate, + fallbackModuleFilenameTemplate: + options.output.devtoolFallbackModuleFilenameTemplate, + append: hidden ? false : undefined, + module: moduleMaps ? true : !cheap, + columns: !cheap, + noSources, + namespace: options.output.devtoolNamespace, + debugIds + }).apply(compiler); + } else if (use.includes("eval")) { + const EvalDevToolModulePlugin = require("./EvalDevToolModulePlugin"); + + new EvalDevToolModulePlugin({ + moduleFilenameTemplate: + options.output.devtoolModuleFilenameTemplate, + namespace: options.output.devtoolNamespace + }).apply(compiler); + } + } + } + + new JavascriptModulesPlugin().apply(compiler); + new JsonModulesPlugin().apply(compiler); + new AssetModulesPlugin({ + sideEffectFree: options.experiments.futureDefaults + }).apply(compiler); + + if (!options.experiments.outputModule) { + if (options.output.module) { + throw new Error( + "'output.module: true' is only allowed when 'experiments.outputModule' is enabled" + ); + } + if (options.output.enabledLibraryTypes.includes("module")) { + throw new Error( + "library type \"module\" is only allowed when 'experiments.outputModule' is enabled" + ); + } + if (options.output.enabledLibraryTypes.includes("modern-module")) { + throw new Error( + "library type \"modern-module\" is only allowed when 'experiments.outputModule' is enabled" + ); + } + if ( + options.externalsType === "module" || + options.externalsType === "module-import" + ) { + throw new Error( + "'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled" + ); + } + } + + if (options.experiments.syncWebAssembly) { + const WebAssemblyModulesPlugin = require("./wasm-sync/WebAssemblyModulesPlugin"); + + new WebAssemblyModulesPlugin({ + mangleImports: options.optimization.mangleWasmImports + }).apply(compiler); + } + + if (options.experiments.asyncWebAssembly) { + const AsyncWebAssemblyModulesPlugin = require("./wasm-async/AsyncWebAssemblyModulesPlugin"); + + new AsyncWebAssemblyModulesPlugin({ + mangleImports: options.optimization.mangleWasmImports + }).apply(compiler); + } + + if (options.experiments.css) { + const CssModulesPlugin = require("./css/CssModulesPlugin"); + + new CssModulesPlugin().apply(compiler); + } + + if (options.experiments.html) { + const HtmlModulesPlugin = require("./html/HtmlModulesPlugin"); + + new HtmlModulesPlugin().apply(compiler); + } + + if (options.experiments.typescript) { + const TypeScriptPlugin = require("./typescript/TypeScriptPlugin"); + + new TypeScriptPlugin().apply(compiler); + } + + if (options.experiments.lazyCompilation) { + const LazyCompilationPlugin = require("./hmr/LazyCompilationPlugin"); + + const lazyOptions = + typeof options.experiments.lazyCompilation === "object" + ? options.experiments.lazyCompilation + : {}; + const isUniversalTarget = + options.output.module && + compiler.platform.node === null && + compiler.platform.web === null; + + if (isUniversalTarget) { + const emitter = require.resolve("../hot/emitter-event-target.js"); + + const NormalModuleReplacementPlugin = require("./NormalModuleReplacementPlugin"); + + // Override emitter that using `EventEmitter` to `EventTarget` + // TODO webpack 6 - migrate to `EventTarget` by default + new NormalModuleReplacementPlugin(/emitter(\.js)?$/, (result) => { + if ( + /webpack[/\\]hot|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test( + result.context + ) + ) { + result.request = emitter; + } + + return result; + }).apply(compiler); + } + + const backend = require.resolve( + isUniversalTarget + ? "../hot/lazy-compilation-universal.js" + : `../hot/lazy-compilation-${ + options.externalsPresets.node ? "node" : "web" + }.js` + ); + + new LazyCompilationPlugin({ + backend: + typeof lazyOptions.backend === "function" + ? lazyOptions.backend + : require("./hmr/lazyCompilationBackend")({ + ...lazyOptions.backend, + client: + (lazyOptions.backend && lazyOptions.backend.client) || backend + }), + entries: !lazyOptions || lazyOptions.entries !== false, + imports: !lazyOptions || lazyOptions.imports !== false, + test: (lazyOptions && lazyOptions.test) || undefined + }).apply(compiler); + } + + if (options.experiments.buildHttp) { + const HttpUriPlugin = require("./schemes/HttpUriPlugin"); + + const httpOptions = options.experiments.buildHttp; + new HttpUriPlugin(httpOptions).apply(compiler); + } + + if ( + !( + /** @type {typeof JavascriptParser & { __importPhasesExtended?: true }} */ + (JavascriptParser).__importPhasesExtended + ) && + (options.experiments.deferImport || options.experiments.sourceImport) + ) { + const importPhases = require("acorn-import-phases"); + + JavascriptParser.extend(importPhases({ source: true, defer: true })); + /** @type {typeof JavascriptParser & { __importPhasesExtended?: true }} */ + (JavascriptParser).__importPhasesExtended = true; + } + + new EntryOptionPlugin().apply(compiler); + compiler.hooks.entryOption.call(options.context, options.entry); + + new RuntimePlugin().apply(compiler); + + new InferAsyncModulesPlugin().apply(compiler); + + new DataUriPlugin().apply(compiler); + new FileUriPlugin().apply(compiler); + + new CompatibilityPlugin().apply(compiler); + new HarmonyModulesPlugin({ + deferImport: options.experiments.deferImport + }).apply(compiler); + if (options.amd !== false) { + const AMDPlugin = require("./dependencies/AMDPlugin"); + const RequireJsStuffPlugin = require("./dependencies/RequireJsStuffPlugin"); + + new AMDPlugin(options.amd || {}).apply(compiler); + new RequireJsStuffPlugin().apply(compiler); + } + new CommonJsPlugin().apply(compiler); + new LoaderPlugin().apply(compiler); + new NodeStuffPlugin({ + global: options.node ? options.node.global : false, + __dirname: options.node ? options.node.__dirname : false, + __filename: options.node ? options.node.__filename : false + }).apply(compiler); + new APIPlugin().apply(compiler); + new ExportsInfoApiPlugin().apply(compiler); + new WebpackIsIncludedPlugin().apply(compiler); + new ConstPlugin().apply(compiler); + new UseStrictPlugin().apply(compiler); + new RequireIncludePlugin().apply(compiler); + new RequireEnsurePlugin().apply(compiler); + new RequireContextPlugin().apply(compiler); + new ImportPlugin().apply(compiler); + new ImportMetaContextPlugin().apply(compiler); + new SystemPlugin().apply(compiler); + new ImportMetaPlugin().apply(compiler); + new URLPlugin().apply(compiler); + new WorkerPlugin( + options.output.workerChunkLoading, + options.output.workerWasmLoading, + options.output.module, + options.output.workerPublicPath + ).apply(compiler); + + new DefaultStatsFactoryPlugin().apply(compiler); + new DefaultStatsPresetPlugin().apply(compiler); + new DefaultStatsPrinterPlugin().apply(compiler); + + new JavascriptMetaInfoPlugin().apply(compiler); + + if (typeof options.mode !== "string") { + const WarnNoModeSetPlugin = require("./WarnNoModeSetPlugin"); + + new WarnNoModeSetPlugin().apply(compiler); + } + + const EnsureChunkConditionsPlugin = require("./optimize/EnsureChunkConditionsPlugin"); + + new EnsureChunkConditionsPlugin().apply(compiler); + if (options.optimization.removeAvailableModules) { + const RemoveParentModulesPlugin = require("./optimize/RemoveParentModulesPlugin"); + + new RemoveParentModulesPlugin().apply(compiler); + } + if (options.optimization.removeEmptyChunks) { + const RemoveEmptyChunksPlugin = require("./optimize/RemoveEmptyChunksPlugin"); + + new RemoveEmptyChunksPlugin().apply(compiler); + } + if (options.optimization.mergeDuplicateChunks) { + const MergeDuplicateChunksPlugin = require("./optimize/MergeDuplicateChunksPlugin"); + + new MergeDuplicateChunksPlugin().apply(compiler); + } + if (options.optimization.flagIncludedChunks) { + const FlagIncludedChunksPlugin = require("./optimize/FlagIncludedChunksPlugin"); + + new FlagIncludedChunksPlugin().apply(compiler); + } + if (options.optimization.sideEffects) { + const SideEffectsFlagPlugin = require("./optimize/SideEffectsFlagPlugin"); + + new SideEffectsFlagPlugin( + options.optimization.sideEffects === true + ).apply(compiler); + } + if (options.optimization.providedExports) { + new FlagDependencyExportsPlugin().apply(compiler); + } + if (options.optimization.usedExports) { + const FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin"); + + new FlagDependencyUsagePlugin( + options.optimization.usedExports === "global" + ).apply(compiler); + } + if (options.optimization.innerGraph) { + const InnerGraphPlugin = require("./optimize/InnerGraphPlugin"); + + new InnerGraphPlugin().apply(compiler); + } + if (options.optimization.mangleExports) { + const MangleExportsPlugin = require("./optimize/MangleExportsPlugin"); + + new MangleExportsPlugin( + options.optimization.mangleExports !== "size" + ).apply(compiler); + } + if (options.optimization.concatenateModules) { + const ModuleConcatenationPlugin = require("./optimize/ModuleConcatenationPlugin"); + + new ModuleConcatenationPlugin().apply(compiler); + } + if (options.optimization.splitChunks) { + const SplitChunksPlugin = require("./optimize/SplitChunksPlugin"); + + new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler); + } + if (options.optimization.runtimeChunk) { + const RuntimeChunkPlugin = require("./optimize/RuntimeChunkPlugin"); + + new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler); + } + if (!options.optimization.emitOnErrors) { + const NoEmitOnErrorsPlugin = require("./NoEmitOnErrorsPlugin"); + + new NoEmitOnErrorsPlugin().apply(compiler); + } + if (options.optimization.realContentHash) { + const RealContentHashPlugin = require("./optimize/RealContentHashPlugin"); + + new RealContentHashPlugin({ + hashFunction: + /** @type {NonNullable} */ + (options.output.hashFunction), + hashDigest: + /** @type {NonNullable} */ + (options.output.hashDigest) + }).apply(compiler); + } + if (options.optimization.checkWasmTypes) { + const WasmFinalizeExportsPlugin = require("./wasm-sync/WasmFinalizeExportsPlugin"); + + new WasmFinalizeExportsPlugin().apply(compiler); + } + const moduleIds = options.optimization.moduleIds; + if (moduleIds) { + switch (moduleIds) { + case "natural": { + const NaturalModuleIdsPlugin = require("./ids/NaturalModuleIdsPlugin"); + + new NaturalModuleIdsPlugin().apply(compiler); + break; + } + case "named": { + const NamedModuleIdsPlugin = require("./ids/NamedModuleIdsPlugin"); + + new NamedModuleIdsPlugin().apply(compiler); + break; + } + case "hashed": { + const WarnDeprecatedOptionPlugin = require("./WarnDeprecatedOptionPlugin"); + const HashedModuleIdsPlugin = require("./ids/HashedModuleIdsPlugin"); + + new WarnDeprecatedOptionPlugin( + "optimization.moduleIds", + "hashed", + "deterministic" + ).apply(compiler); + new HashedModuleIdsPlugin({ + hashFunction: options.output.hashFunction + }).apply(compiler); + break; + } + case "deterministic": { + const DeterministicModuleIdsPlugin = require("./ids/DeterministicModuleIdsPlugin"); + + new DeterministicModuleIdsPlugin().apply(compiler); + break; + } + case "size": { + const OccurrenceModuleIdsPlugin = require("./ids/OccurrenceModuleIdsPlugin"); + + new OccurrenceModuleIdsPlugin({ + prioritiseInitial: true + }).apply(compiler); + break; + } + default: + throw new Error( + `webpack bug: moduleIds: ${moduleIds} is not implemented` + ); + } + } + const chunkIds = options.optimization.chunkIds; + if (chunkIds) { + switch (chunkIds) { + case "natural": { + const NaturalChunkIdsPlugin = require("./ids/NaturalChunkIdsPlugin"); + + new NaturalChunkIdsPlugin().apply(compiler); + break; + } + case "named": { + const NamedChunkIdsPlugin = require("./ids/NamedChunkIdsPlugin"); + + new NamedChunkIdsPlugin().apply(compiler); + break; + } + case "deterministic": { + const DeterministicChunkIdsPlugin = require("./ids/DeterministicChunkIdsPlugin"); + + new DeterministicChunkIdsPlugin().apply(compiler); + break; + } + case "size": { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin"); + + new OccurrenceChunkIdsPlugin({ + prioritiseInitial: true + }).apply(compiler); + break; + } + case "total-size": { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin"); + + new OccurrenceChunkIdsPlugin({ + prioritiseInitial: false + }).apply(compiler); + break; + } + default: + throw new Error( + `webpack bug: chunkIds: ${chunkIds} is not implemented` + ); + } + } + if (options.optimization.nodeEnv) { + const DefinePlugin = require("./DefinePlugin"); + + const defValue = JSON.stringify(options.optimization.nodeEnv); + + new DefinePlugin({ + "process.env.NODE_ENV": defValue, + "import.meta.env.NODE_ENV": defValue + }).apply(compiler); + } + if (options.optimization.minimize) { + for (const minimizer of options.optimization.minimizer) { + if (typeof minimizer === "function") { + /** @type {WebpackPluginFunction} */ + (minimizer).call(compiler, compiler); + } else if (minimizer !== "..." && minimizer) { + minimizer.apply(compiler); + } + } + } + + if (options.performance) { + const SizeLimitsPlugin = require("./performance/SizeLimitsPlugin"); + + new SizeLimitsPlugin(options.performance).apply(compiler); + } + + new TemplatedPathPlugin().apply(compiler); + + new RecordIdsPlugin({ + portableIds: options.optimization.portableRecords + }).apply(compiler); + + new WarnCaseSensitiveModulesPlugin().apply(compiler); + + const AddManagedPathsPlugin = require("./cache/AddManagedPathsPlugin"); + + new AddManagedPathsPlugin( + /** @type {NonNullable} */ + (options.snapshot.managedPaths), + /** @type {NonNullable} */ + (options.snapshot.immutablePaths), + /** @type {NonNullable} */ + (options.snapshot.unmanagedPaths) + ).apply(compiler); + + if (options.cache && typeof options.cache === "object") { + const cacheOptions = options.cache; + switch (cacheOptions.type) { + case "memory": { + if (Number.isFinite(cacheOptions.maxGenerations)) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin"); + + new MemoryWithGcCachePlugin({ + maxGenerations: + /** @type {number} */ + (cacheOptions.maxGenerations) + }).apply(compiler); + } else { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const MemoryCachePlugin = require("./cache/MemoryCachePlugin"); + + new MemoryCachePlugin().apply(compiler); + } + if (cacheOptions.cacheUnaffected) { + if (!options.experiments.cacheUnaffected) { + throw new Error( + "'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled" + ); + } + compiler.moduleMemCaches = new Map(); + } + break; + } + case "filesystem": { + const AddBuildDependenciesPlugin = require("./cache/AddBuildDependenciesPlugin"); + + for (const key in cacheOptions.buildDependencies) { + const list = cacheOptions.buildDependencies[key]; + new AddBuildDependenciesPlugin(list).apply(compiler); + } + if (!Number.isFinite(cacheOptions.maxMemoryGenerations)) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const MemoryCachePlugin = require("./cache/MemoryCachePlugin"); + + new MemoryCachePlugin().apply(compiler); + } else if (cacheOptions.maxMemoryGenerations !== 0) { + // @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697 + const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin"); + + new MemoryWithGcCachePlugin({ + maxGenerations: + /** @type {number} */ + (cacheOptions.maxMemoryGenerations) + }).apply(compiler); + } + if (cacheOptions.memoryCacheUnaffected) { + if (!options.experiments.cacheUnaffected) { + throw new Error( + "'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled" + ); + } + compiler.moduleMemCaches = new Map(); + } + switch (cacheOptions.store) { + case "pack": { + const IdleFileCachePlugin = require("./cache/IdleFileCachePlugin"); + const PackFileCacheStrategy = require("./cache/PackFileCacheStrategy"); + + new IdleFileCachePlugin( + new PackFileCacheStrategy({ + compiler, + fs: + /** @type {IntermediateFileSystem} */ + (compiler.intermediateFileSystem), + context: options.context, + cacheLocation: + /** @type {string} */ + (cacheOptions.cacheLocation), + version: /** @type {string} */ (cacheOptions.version), + logger: compiler.getInfrastructureLogger( + "webpack.cache.PackFileCacheStrategy" + ), + snapshot: options.snapshot, + maxAge: /** @type {number} */ (cacheOptions.maxAge), + profile: cacheOptions.profile, + allowCollectingMemory: cacheOptions.allowCollectingMemory, + compression: cacheOptions.compression, + readonly: cacheOptions.readonly + }), + /** @type {number} */ + (cacheOptions.idleTimeout), + /** @type {number} */ + (cacheOptions.idleTimeoutForInitialStore), + /** @type {number} */ + (cacheOptions.idleTimeoutAfterLargeChanges) + ).apply(compiler); + break; + } + default: + throw new Error("Unhandled value for cache.store"); + } + break; + } + default: + // @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339) + throw new Error(`Unknown cache type ${cacheOptions.type}`); + } + } + new ResolverCachePlugin().apply(compiler); + + if (options.ignoreWarnings && options.ignoreWarnings.length > 0) { + const IgnoreWarningsPlugin = require("./IgnoreWarningsPlugin"); + + new IgnoreWarningsPlugin(options.ignoreWarnings).apply(compiler); + } + + compiler.hooks.afterPlugins.call(compiler); + if (!compiler.inputFileSystem) { + throw new Error("No input filesystem provided"); + } + compiler.resolverFactory.hooks.resolveOptions + .for("normal") + .tap(CLASS_NAME, (resolveOptions) => { + resolveOptions = cleverMerge(options.resolve, resolveOptions); + resolveOptions.fileSystem = + /** @type {InputFileSystem} */ + (compiler.inputFileSystem); + return resolveOptions; + }); + compiler.resolverFactory.hooks.resolveOptions + .for("context") + .tap(CLASS_NAME, (resolveOptions) => { + resolveOptions = cleverMerge(options.resolve, resolveOptions); + resolveOptions.fileSystem = + /** @type {InputFileSystem} */ + (compiler.inputFileSystem); + resolveOptions.resolveToContext = true; + return resolveOptions; + }); + compiler.resolverFactory.hooks.resolveOptions + .for("loader") + .tap(CLASS_NAME, (resolveOptions) => { + resolveOptions = cleverMerge(options.resolveLoader, resolveOptions); + resolveOptions.fileSystem = + /** @type {InputFileSystem} */ + (compiler.inputFileSystem); + return resolveOptions; + }); + compiler.hooks.afterResolvers.call(compiler); + return options; + } +} + +module.exports = WebpackOptionsApply; Index: frontend/node_modules/webpack/lib/WebpackOptionsDefaulter.js =================================================================== --- frontend/node_modules/webpack/lib/WebpackOptionsDefaulter.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/WebpackOptionsDefaulter.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { applyWebpackOptionsDefaults } = require("./config/defaults"); +const { getNormalizedWebpackOptions } = require("./config/normalization"); + +/** @typedef {import("./config/normalization").WebpackOptions} WebpackOptions */ +/** @typedef {import("./config/normalization").WebpackOptionsNormalized} WebpackOptionsNormalized */ + +class WebpackOptionsDefaulter { + /** + * Returns normalized webpack options. + * @param {WebpackOptions} options webpack options + * @returns {WebpackOptionsNormalized} normalized webpack options + */ + process(options) { + const normalizedOptions = getNormalizedWebpackOptions(options); + applyWebpackOptionsDefaults(normalizedOptions); + return normalizedOptions; + } +} + +module.exports = WebpackOptionsDefaulter; Index: frontend/node_modules/webpack/lib/asset/AssetBytesGenerator.js =================================================================== --- frontend/node_modules/webpack/lib/asset/AssetBytesGenerator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/AssetBytesGenerator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,182 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Alexander Akait @alexander-akait +*/ + +"use strict"; + +const { RawSource } = require("webpack-sources"); +const ConcatenationScope = require("../ConcatenationScope"); +const Generator = require("../Generator"); +const { + ASSET_URL_TYPE, + ASSET_URL_TYPES, + CSS_TYPE, + HTML_TYPE, + JAVASCRIPT_AND_ASSET_URL_TYPES, + JAVASCRIPT_TYPE, + JAVASCRIPT_TYPES, + NO_TYPES +} = require("../ModuleSourceTypeConstants"); +const RuntimeGlobals = require("../RuntimeGlobals"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../Generator").GenerateContext} GenerateContext */ +/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */ +/** @typedef {import("../Module").SourceType} SourceType */ +/** @typedef {import("../Module").SourceTypes} SourceTypes */ +/** @typedef {import("../ModuleGraph")} ModuleGraph */ +/** @typedef {import("../NormalModule")} NormalModule */ + +class AssetSourceGenerator extends Generator { + /** + * Creates an instance of AssetSourceGenerator. + * @param {ModuleGraph} moduleGraph the module graph + */ + constructor(moduleGraph) { + super(); + + this._moduleGraph = moduleGraph; + } + + /** + * Generates generated code for this runtime module. + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generate( + module, + { type, concatenationScope, getData, runtimeTemplate, runtimeRequirements } + ) { + const originalSource = module.originalSource(); + const data = getData ? getData() : undefined; + + switch (type) { + case JAVASCRIPT_TYPE: { + if (!originalSource) { + return new RawSource(""); + } + + const encodedSource = originalSource.buffer().toString("base64"); + + runtimeRequirements.add(RuntimeGlobals.requireScope); + runtimeRequirements.add(RuntimeGlobals.toBinary); + + /** @type {string} */ + let sourceContent; + if (concatenationScope) { + concatenationScope.registerNamespaceExport( + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + ); + sourceContent = `${runtimeTemplate.renderConst()} ${ + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + } = ${RuntimeGlobals.toBinary}(${JSON.stringify(encodedSource)});`; + } else { + runtimeRequirements.add(RuntimeGlobals.module); + sourceContent = `${module.moduleArgument}.exports = ${RuntimeGlobals.toBinary}(${JSON.stringify( + encodedSource + )});`; + } + return new RawSource(sourceContent); + } + case ASSET_URL_TYPE: { + if (!originalSource) { + return null; + } + + const encodedSource = originalSource.buffer().toString("base64"); + + if (data) { + data.set("url", { + [type]: `data:application/octet-stream;base64,${encodedSource}` + }); + } + return null; + } + default: + return null; + } + } + + /** + * Generates fallback output for the provided error condition. + * @param {Error} error the error + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generateError(error, module, generateContext) { + switch (generateContext.type) { + case JAVASCRIPT_TYPE: { + return new RawSource( + `throw new Error(${JSON.stringify(error.message)});` + ); + } + default: + return null; + } + } + + /** + * Returns the reason this module cannot be concatenated, when one exists. + * @param {NormalModule} module module for which the bailout reason should be determined + * @param {ConcatenationBailoutReasonContext} context context + * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated + */ + getConcatenationBailoutReason(module, context) { + return undefined; + } + + /** + * Returns the source types available for this module. + * @param {NormalModule} module fresh module + * @returns {SourceTypes} available types (do not mutate) + */ + getTypes(module) { + /** @type {Set} */ + const sourceTypes = new Set(); + const connections = this._moduleGraph.getIncomingConnections(module); + + for (const connection of connections) { + if (!connection.originModule) { + continue; + } + + sourceTypes.add(connection.originModule.type.split("/")[0]); + } + + if (sourceTypes.size > 0) { + if ( + sourceTypes.has(JAVASCRIPT_TYPE) && + (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) + ) { + return JAVASCRIPT_AND_ASSET_URL_TYPES; + } else if (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) { + return ASSET_URL_TYPES; + } + return JAVASCRIPT_TYPES; + } + + return NO_TYPES; + } + + /** + * Returns the estimated size for the requested source type. + * @param {NormalModule} module the module + * @param {SourceType=} type source type + * @returns {number} estimate size of the module + */ + getSize(module, type) { + const originalSource = module.originalSource(); + + if (!originalSource) { + return 0; + } + + // Example: m.exports="abcd" + return originalSource.size() + 12; + } +} + +module.exports = AssetSourceGenerator; Index: frontend/node_modules/webpack/lib/asset/AssetBytesParser.js =================================================================== --- frontend/node_modules/webpack/lib/asset/AssetBytesParser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/AssetBytesParser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,38 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Alexander Akait @alexander-akait +*/ + +"use strict"; + +const Parser = require("../Parser"); + +/** @typedef {import("../Module").BuildInfo} BuildInfo */ +/** @typedef {import("../Module").BuildMeta} BuildMeta */ +/** @typedef {import("../Parser").ParserState} ParserState */ +/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */ + +class AssetBytesParser extends Parser { + /** + * Parses the provided source and updates the parser state. + * @param {string | Buffer | PreparsedAst} source the source to parse + * @param {ParserState} state the parser state + * @returns {ParserState} the parser state + */ + parse(source, state) { + if (typeof source === "object" && !Buffer.isBuffer(source)) { + throw new Error("AssetBytesParser doesn't accept preparsed AST"); + } + const { module } = state; + /** @type {BuildInfo} */ + (module.buildInfo).strict = true; + /** @type {BuildMeta} */ + (module.buildMeta).exportsType = "default"; + /** @type {BuildMeta} */ + (state.module.buildMeta).defaultObject = false; + + return state; + } +} + +module.exports = AssetBytesParser; Index: frontend/node_modules/webpack/lib/asset/AssetGenerator.js =================================================================== --- frontend/node_modules/webpack/lib/asset/AssetGenerator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/AssetGenerator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,848 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sergey Melyukov @smelukov +*/ + +"use strict"; + +const path = require("path"); +const { RawSource } = require("webpack-sources"); +const ConcatenationScope = require("../ConcatenationScope"); +const Generator = require("../Generator"); +const { + ASSET_AND_ASSET_URL_TYPES, + ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES, + ASSET_AND_JAVASCRIPT_TYPES, + ASSET_TYPES, + ASSET_URL_TYPE, + ASSET_URL_TYPES, + CSS_TYPE, + HTML_TYPE, + JAVASCRIPT_AND_ASSET_URL_TYPES, + JAVASCRIPT_TYPE, + JAVASCRIPT_TYPES, + NO_TYPES +} = require("../ModuleSourceTypeConstants"); +const { ASSET_MODULE_TYPE } = require("../ModuleTypeConstants"); +const RuntimeGlobals = require("../RuntimeGlobals"); +const CssUrlDependency = require("../dependencies/CssUrlDependency"); +const createHash = require("../util/createHash"); +const { makePathsRelative } = require("../util/identifier"); +const memoize = require("../util/memoize"); +const nonNumericOnlyHash = require("../util/nonNumericOnlyHash"); +const { updateHashFromSource } = require("../util/source"); + +const getMimeTypes = memoize(() => require("../util/mimeTypes")); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorDataUrlOptions} AssetGeneratorDataUrlOptions */ +/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */ +/** @typedef {import("../../declarations/WebpackOptions").AssetModuleFilename} AssetModuleFilename */ +/** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */ +/** @typedef {import("../../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */ +/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */ +/** @typedef {import("../ChunkGraph")} ChunkGraph */ +/** @typedef {import("../Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("../Generator").GenerateContext} GenerateContext */ +/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("../Module")} Module */ +/** @typedef {import("../Module").NameForCondition} NameForCondition */ +/** @typedef {import("../Module").BuildInfo} BuildInfo */ +/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */ +/** @typedef {import("../Module").SourceType} SourceType */ +/** @typedef {import("../Module").SourceTypes} SourceTypes */ +/** @typedef {import("../ModuleGraph")} ModuleGraph */ +/** @typedef {import("../NormalModule")} NormalModule */ +/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */ +/** @typedef {import("../util/Hash")} Hash */ +/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */ + +/** @typedef {(source: string | Buffer, context: { filename: string, module: Module }) => string} DataUrlFunction */ + +/** + * Merges maybe arrays. + * @template T + * @template U + * @param {null | string | T[] | Set | undefined} a a + * @param {null | string | U[] | Set | undefined} b b + * @returns {T[] & U[]} array + */ +const mergeMaybeArrays = (a, b) => { + /** @type {Set | Set>} */ + const set = new Set(); + if (Array.isArray(a)) for (const item of a) set.add(item); + else set.add(a); + if (Array.isArray(b)) for (const item of b) set.add(item); + else set.add(b); + return /** @type {T[] & U[]} */ ([.../** @type {Set} */ (set)]); +}; + +/** + * Merges the provided values into a single result. + * @param {AssetInfo} a a + * @param {AssetInfo} b b + * @returns {AssetInfo} object + */ +const mergeAssetInfo = (a, b) => { + /** @type {AssetInfo} */ + const result = { ...a, ...b }; + for (const key of Object.keys(a)) { + if (key in b) { + if (a[key] === b[key]) continue; + switch (key) { + case "fullhash": + case "chunkhash": + case "modulehash": + case "contenthash": + result[key] = mergeMaybeArrays(a[key], b[key]); + break; + case "immutable": + case "development": + case "hotModuleReplacement": + case "javascriptModule": + result[key] = a[key] || b[key]; + break; + case "related": + result[key] = mergeRelatedInfo( + /** @type {NonNullable} */ + (a[key]), + /** @type {NonNullable} */ + (b[key]) + ); + break; + default: + throw new Error(`Can't handle conflicting asset info for ${key}`); + } + } + } + return result; +}; + +/** + * Merges related info. + * @param {NonNullable} a a + * @param {NonNullable} b b + * @returns {NonNullable} object + */ +const mergeRelatedInfo = (a, b) => { + const result = { ...a, ...b }; + for (const key of Object.keys(a)) { + if (key in b) { + if (a[key] === b[key]) continue; + result[key] = mergeMaybeArrays(a[key], b[key]); + } + } + return result; +}; + +/** + * Encodes the provided encoding. + * @param {"base64" | false} encoding encoding + * @param {Source} source source + * @returns {string} encoded data + */ +const encodeDataUri = (encoding, source) => { + /** @type {string | undefined} */ + let encodedContent; + + switch (encoding) { + case "base64": { + encodedContent = source.buffer().toString("base64"); + break; + } + case false: { + const content = source.source(); + + if (typeof content !== "string") { + encodedContent = content.toString("utf8"); + } + + encodedContent = encodeURIComponent( + /** @type {string} */ + (encodedContent) + ).replace( + /[!'()*]/g, + (character) => + `%${/** @type {number} */ (character.codePointAt(0)).toString(16)}` + ); + break; + } + default: + throw new Error(`Unsupported encoding '${encoding}'`); + } + + return encodedContent; +}; + +/** + * Decodes data uri content. + * @param {"base64" | false} encoding encoding + * @param {string} content content + * @returns {Buffer} decoded content + */ +const decodeDataUriContent = (encoding, content) => { + const isBase64 = encoding === "base64"; + + if (isBase64) { + return Buffer.from(content, "base64"); + } + + // If we can't decode return the original body + try { + return Buffer.from(decodeURIComponent(content), "ascii"); + } catch (_) { + return Buffer.from(content, "ascii"); + } +}; + +const DEFAULT_ENCODING = "base64"; + +class AssetGenerator extends Generator { + /** + * Creates an instance of AssetGenerator. + * @param {ModuleGraph} moduleGraph the module graph + * @param {AssetGeneratorOptions["dataUrl"]=} dataUrlOptions the options for the data url + * @param {AssetModuleFilename=} filename override for output.assetModuleFilename + * @param {RawPublicPath=} publicPath override for output.assetModulePublicPath + * @param {AssetModuleOutputPath=} outputPath the output path for the emitted file which is not included in the runtime import + * @param {boolean=} emit generate output asset + */ + constructor( + moduleGraph, + dataUrlOptions, + filename, + publicPath, + outputPath, + emit + ) { + super(); + /** @type {AssetGeneratorOptions["dataUrl"] | undefined} */ + this.dataUrlOptions = dataUrlOptions; + /** @type {AssetModuleFilename | undefined} */ + this.filename = filename; + /** @type {RawPublicPath | undefined} */ + this.publicPath = publicPath; + /** @type {AssetModuleOutputPath | undefined} */ + this.outputPath = outputPath; + /** @type {boolean | undefined} */ + this.emit = emit; + /** @type {ModuleGraph} */ + this._moduleGraph = moduleGraph; + } + + /** + * Gets source file name. + * @param {NormalModule} module module + * @param {RuntimeTemplate} runtimeTemplate runtime template + * @returns {string} source file name + */ + static getSourceFileName(module, runtimeTemplate) { + return makePathsRelative( + runtimeTemplate.compilation.compiler.context, + /** @type {string} */ + (module.getResource()), + runtimeTemplate.compilation.compiler.root + ).replace(/^\.\//, ""); + } + + /** + * Gets full content hash. + * @param {NormalModule} module module + * @param {RuntimeTemplate} runtimeTemplate runtime template + * @returns {[string, string]} return full hash and non-numeric full hash + */ + static getFullContentHash(module, runtimeTemplate) { + const hash = createHash(runtimeTemplate.outputOptions.hashFunction); + + if (runtimeTemplate.outputOptions.hashSalt) { + hash.update(runtimeTemplate.outputOptions.hashSalt); + } + + const source = module.originalSource(); + + if (source) { + updateHashFromSource(hash, source); + } + + if (module.error) { + hash.update(module.error.toString()); + } + + const fullContentHash = hash.digest( + runtimeTemplate.outputOptions.hashDigest + ); + + const contentHash = nonNumericOnlyHash( + fullContentHash, + runtimeTemplate.outputOptions.hashDigestLength + ); + + return [fullContentHash, contentHash]; + } + + /** + * Gets filename with info. + * @param {NormalModule} module module for which the code should be generated + * @param {Pick} generatorOptions generator options + * @param {{ runtime: RuntimeSpec, runtimeTemplate: RuntimeTemplate, chunkGraph: ChunkGraph }} generateContext context for generate + * @param {string} contentHash the content hash + * @returns {{ filename: string, originalFilename: string, assetInfo: AssetInfo }} info + */ + static getFilenameWithInfo( + module, + generatorOptions, + { runtime, runtimeTemplate, chunkGraph }, + contentHash + ) { + const assetModuleFilename = + generatorOptions.filename || + runtimeTemplate.outputOptions.assetModuleFilename; + + const sourceFilename = AssetGenerator.getSourceFileName( + module, + runtimeTemplate + ); + let { path: filename, info: assetInfo } = + runtimeTemplate.compilation.getAssetPathWithInfo(assetModuleFilename, { + module, + runtime, + filename: sourceFilename, + chunkGraph, + contentHash + }); + + const originalFilename = filename; + + if (generatorOptions.outputPath) { + const { path: outputPath, info } = + runtimeTemplate.compilation.getAssetPathWithInfo( + generatorOptions.outputPath, + { + module, + runtime, + filename: sourceFilename, + chunkGraph, + contentHash + } + ); + filename = path.posix.join(outputPath, filename); + assetInfo = mergeAssetInfo(assetInfo, info); + } + + return { originalFilename, filename, assetInfo }; + } + + /** + * Gets asset path with info. + * @param {NormalModule} module module for which the code should be generated + * @param {Pick} generatorOptions generator options + * @param {GenerateContext} generateContext context for generate + * @param {string} filename the filename + * @param {AssetInfo} assetInfo the asset info + * @param {string} contentHash the content hash + * @returns {{ assetPath: string, assetInfo: AssetInfo }} asset path and info + */ + static getAssetPathWithInfo( + module, + generatorOptions, + { runtime, runtimeTemplate, type, chunkGraph, runtimeRequirements }, + filename, + assetInfo, + contentHash + ) { + const sourceFilename = AssetGenerator.getSourceFileName( + module, + runtimeTemplate + ); + + /** @type {undefined | string} */ + let assetPath; + + if (generatorOptions.publicPath !== undefined && type === JAVASCRIPT_TYPE) { + const { path, info } = runtimeTemplate.compilation.getAssetPathWithInfo( + generatorOptions.publicPath, + { + module, + runtime, + filename: sourceFilename, + chunkGraph, + contentHash + } + ); + assetInfo = mergeAssetInfo(assetInfo, info); + assetPath = JSON.stringify(path + filename); + } else if ( + generatorOptions.publicPath !== undefined && + type === ASSET_URL_TYPE + ) { + const { path, info } = runtimeTemplate.compilation.getAssetPathWithInfo( + generatorOptions.publicPath, + { + module, + runtime, + filename: sourceFilename, + chunkGraph, + contentHash + } + ); + assetInfo = mergeAssetInfo(assetInfo, info); + assetPath = path + filename; + } else if (type === JAVASCRIPT_TYPE) { + // add __webpack_require__.p + runtimeRequirements.add(RuntimeGlobals.publicPath); + assetPath = runtimeTemplate.concatenation( + { expr: RuntimeGlobals.publicPath }, + filename + ); + } else if (type === ASSET_URL_TYPE) { + const compilation = runtimeTemplate.compilation; + const path = + compilation.outputOptions.publicPath === "auto" + ? CssUrlDependency.PUBLIC_PATH_AUTO + : compilation.getAssetPath(compilation.outputOptions.publicPath, { + hash: + compilation.hash || + `${CssUrlDependency.PUBLIC_PATH_FULL_HASH}0__`, + hashWithLength: (length) => + compilation.hash + ? compilation.hash.slice(0, length) + : `${CssUrlDependency.PUBLIC_PATH_FULL_HASH}${length}__` + }); + + assetPath = path + filename; + } + + return { + assetPath: /** @type {string} */ (assetPath), + assetInfo: { sourceFilename, ...assetInfo } + }; + } + + /** + * Returns the reason this module cannot be concatenated, when one exists. + * @param {NormalModule} module module for which the bailout reason should be determined + * @param {ConcatenationBailoutReasonContext} context context + * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated + */ + getConcatenationBailoutReason(module, context) { + return undefined; + } + + /** + * Returns mime type. + * @param {NormalModule} module module + * @returns {string} mime type + */ + getMimeType(module) { + if (typeof this.dataUrlOptions === "function") { + throw new Error( + "This method must not be called when dataUrlOptions is a function" + ); + } + + /** @type {string | undefined} */ + let mimeType = + /** @type {AssetGeneratorDataUrlOptions} */ + (this.dataUrlOptions).mimetype; + if (mimeType === undefined) { + const ext = path.extname( + /** @type {NameForCondition} */ + (module.nameForCondition()) + ); + if ( + module.resourceResolveData && + module.resourceResolveData.mimetype !== undefined + ) { + mimeType = + module.resourceResolveData.mimetype + + module.resourceResolveData.parameters; + } else if (ext) { + mimeType = getMimeTypes().lookup(ext); + + if (typeof mimeType !== "string") { + throw new Error( + "DataUrl can't be generated automatically, " + + `because there is no mimetype for "${ext}" in mimetype database. ` + + 'Either pass a mimetype via "generator.mimetype" or ' + + 'use type: "asset/resource" to create a resource file instead of a DataUrl' + ); + } + } + } + + if (typeof mimeType !== "string") { + throw new Error( + "DataUrl can't be generated automatically. " + + 'Either pass a mimetype via "generator.mimetype" or ' + + 'use type: "asset/resource" to create a resource file instead of a DataUrl' + ); + } + + return /** @type {string} */ (mimeType); + } + + /** + * Generates data uri. + * @param {NormalModule} module module for which the code should be generated + * @returns {string} DataURI + */ + generateDataUri(module) { + const source = /** @type {Source} */ (module.originalSource()); + + /** @type {string} */ + let encodedSource; + + if (typeof this.dataUrlOptions === "function") { + encodedSource = this.dataUrlOptions.call(null, source.source(), { + filename: /** @type {string} */ (module.getResource()), + module + }); + } else { + let encoding = + /** @type {AssetGeneratorDataUrlOptions} */ + (this.dataUrlOptions).encoding; + if ( + encoding === undefined && + module.resourceResolveData && + module.resourceResolveData.encoding !== undefined + ) { + encoding = module.resourceResolveData.encoding; + } + if (encoding === undefined) { + encoding = DEFAULT_ENCODING; + } + const mimeType = this.getMimeType(module); + + /** @type {string} */ + let encodedContent; + + if ( + module.resourceResolveData && + module.resourceResolveData.encoding === encoding && + decodeDataUriContent( + module.resourceResolveData.encoding, + /** @type {string} */ (module.resourceResolveData.encodedContent) + ).equals(source.buffer()) + ) { + encodedContent = + /** @type {string} */ + (module.resourceResolveData.encodedContent); + } else { + encodedContent = encodeDataUri( + /** @type {"base64" | false} */ (encoding), + source + ); + } + + encodedSource = `data:${mimeType}${ + encoding ? `;${encoding}` : "" + },${encodedContent}`; + } + + return encodedSource; + } + + /** + * Generates generated code for this runtime module. + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generate(module, generateContext) { + const { + type, + getData, + runtimeTemplate, + runtimeRequirements, + concatenationScope + } = generateContext; + + /** @type {string} */ + let content; + + const needContent = type === JAVASCRIPT_TYPE || type === ASSET_URL_TYPE; + const data = getData ? getData() : undefined; + + if ( + /** @type {BuildInfo} */ + (module.buildInfo).dataUrl && + needContent + ) { + const encodedSource = this.generateDataUri(module); + content = + type === JAVASCRIPT_TYPE + ? JSON.stringify(encodedSource) + : encodedSource; + + if (data) { + data.set("url", { ...data.get("url"), [type]: content }); + } + } else { + const [fullContentHash, contentHash] = AssetGenerator.getFullContentHash( + module, + runtimeTemplate + ); + + if (data) { + data.set("fullContentHash", fullContentHash); + data.set("contentHash", contentHash); + } + + /** @type {BuildInfo} */ + (module.buildInfo).fullContentHash = fullContentHash; + + const { originalFilename, filename, assetInfo } = + AssetGenerator.getFilenameWithInfo( + module, + { filename: this.filename, outputPath: this.outputPath }, + generateContext, + contentHash + ); + + if (data) { + data.set("filename", filename); + } + + let { assetPath, assetInfo: newAssetInfo } = + AssetGenerator.getAssetPathWithInfo( + module, + { publicPath: this.publicPath }, + generateContext, + originalFilename, + assetInfo, + contentHash + ); + + if (data && (type === JAVASCRIPT_TYPE || type === ASSET_URL_TYPE)) { + data.set("url", { ...data.get("url"), [type]: assetPath }); + } + + if (data) { + const oldAssetInfo = data.get("assetInfo"); + + if (oldAssetInfo) { + newAssetInfo = mergeAssetInfo(oldAssetInfo, newAssetInfo); + } + } + + if (data) { + data.set("assetInfo", newAssetInfo); + } + + // Due to code generation caching module.buildInfo.XXX can't used to store such information + // It need to be stored in the code generation results instead, where it's cached too + // TODO webpack 6 For back-compat reasons we also store in on module.buildInfo + /** @type {BuildInfo} */ + (module.buildInfo).filename = filename; + + /** @type {BuildInfo} */ + (module.buildInfo).assetInfo = newAssetInfo; + + content = assetPath; + } + + if (type === JAVASCRIPT_TYPE) { + if (concatenationScope) { + concatenationScope.registerNamespaceExport( + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + ); + + return new RawSource( + `${runtimeTemplate.renderConst()} ${ + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + } = ${content};` + ); + } + + runtimeRequirements.add(RuntimeGlobals.module); + + return new RawSource(`${module.moduleArgument}.exports = ${content};`); + } else if (type === ASSET_URL_TYPE) { + return null; + } + + return /** @type {Source} */ (module.originalSource()); + } + + /** + * Generates fallback output for the provided error condition. + * @param {Error} error the error + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generateError(error, module, generateContext) { + switch (generateContext.type) { + case "asset": { + return new RawSource(error.message); + } + case JAVASCRIPT_TYPE: { + return new RawSource( + `throw new Error(${JSON.stringify(error.message)});` + ); + } + default: + return null; + } + } + + /** + * Returns the source types available for this module. + * @param {NormalModule} module fresh module + * @returns {SourceTypes} available types (do not mutate) + */ + getTypes(module) { + /** @type {Set} */ + const sourceTypes = new Set(); + const connections = this._moduleGraph.getIncomingConnections(module); + + for (const connection of connections) { + if (!connection.originModule) { + continue; + } + + sourceTypes.add(connection.originModule.type.split("/")[0]); + } + + if ((module.buildInfo && module.buildInfo.dataUrl) || this.emit === false) { + if (sourceTypes.size > 0) { + if ( + sourceTypes.has(JAVASCRIPT_TYPE) && + (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) + ) { + return JAVASCRIPT_AND_ASSET_URL_TYPES; + } else if (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) { + return ASSET_URL_TYPES; + } + return JAVASCRIPT_TYPES; + } + + return NO_TYPES; + } + + if (sourceTypes.size > 0) { + if ( + sourceTypes.has(JAVASCRIPT_TYPE) && + (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) + ) { + return ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES; + } else if (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) { + return ASSET_AND_ASSET_URL_TYPES; + } + return ASSET_AND_JAVASCRIPT_TYPES; + } + + return ASSET_TYPES; + } + + /** + * Returns the estimated size for the requested source type. + * @param {NormalModule} module the module + * @param {SourceType=} type source type + * @returns {number} estimate size of the module + */ + getSize(module, type) { + switch (type) { + case ASSET_MODULE_TYPE: { + const originalSource = module.originalSource(); + + if (!originalSource) { + return 0; + } + + return originalSource.size(); + } + default: + if (module.buildInfo && module.buildInfo.dataUrl) { + const originalSource = module.originalSource(); + + if (!originalSource) { + return 0; + } + + // roughly for data url + // Example: m.exports="data:image/png;base64,ag82/f+2==" + // 4/3 = base64 encoding + // 34 = ~ data url header + footer + rounding + return originalSource.size() * 1.34 + 36; + } + // it's only estimated so this number is probably fine + // Example: m.exports=r.p+"0123456789012345678901.ext" + return 42; + } + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash hash that will be modified + * @param {UpdateHashContext} updateHashContext context for updating hash + */ + updateHash(hash, updateHashContext) { + const { module } = updateHashContext; + + if ( + /** @type {BuildInfo} */ + (module.buildInfo).dataUrl + ) { + hash.update("data-url"); + // this.dataUrlOptions as function should be pure and only depend on input source and filename + // therefore it doesn't need to be hashed + if (typeof this.dataUrlOptions === "function") { + const ident = /** @type {{ ident?: string }} */ (this.dataUrlOptions) + .ident; + if (ident) hash.update(ident); + } else { + const dataUrlOptions = + /** @type {AssetGeneratorDataUrlOptions} */ + (this.dataUrlOptions); + if ( + dataUrlOptions.encoding && + dataUrlOptions.encoding !== DEFAULT_ENCODING + ) { + hash.update(dataUrlOptions.encoding); + } + if (dataUrlOptions.mimetype) hash.update(dataUrlOptions.mimetype); + // computed mimetype depends only on module filename which is already part of the hash + } + } else { + hash.update("resource"); + + const { module, chunkGraph, runtime } = updateHashContext; + const runtimeTemplate = + /** @type {NonNullable} */ + (updateHashContext.runtimeTemplate); + + const pathData = { + module, + runtime, + filename: AssetGenerator.getSourceFileName(module, runtimeTemplate), + chunkGraph, + contentHash: runtimeTemplate.contentHashReplacement + }; + + if (typeof this.publicPath === "function") { + hash.update("path"); + const assetInfo = {}; + hash.update(this.publicPath(pathData, assetInfo)); + hash.update(JSON.stringify(assetInfo)); + } else if (this.publicPath) { + hash.update("path"); + hash.update(this.publicPath); + } else { + hash.update("no-path"); + } + + const assetModuleFilename = + this.filename || runtimeTemplate.outputOptions.assetModuleFilename; + const { path: filename, info } = + runtimeTemplate.compilation.getAssetPathWithInfo( + assetModuleFilename, + pathData + ); + hash.update(filename); + hash.update(JSON.stringify(info)); + } + } +} + +module.exports = AssetGenerator; Index: frontend/node_modules/webpack/lib/asset/AssetModulesPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/asset/AssetModulesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/AssetModulesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,380 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Yuta Hiroto @hiroppy +*/ + +"use strict"; + +const { + ASSET_MODULE_TYPE, + ASSET_MODULE_TYPE_BYTES, + ASSET_MODULE_TYPE_INLINE, + ASSET_MODULE_TYPE_RESOURCE, + ASSET_MODULE_TYPE_SOURCE +} = require("../ModuleTypeConstants"); +const { compareModulesByFullName } = require("../util/comparators"); +const memoize = require("../util/memoize"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("schema-utils").Schema} Schema */ +/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorDataUrl} AssetGeneratorDataUrl */ +/** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */ +/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */ +/** @typedef {import("../../declarations/WebpackOptions").AssetModuleFilename} AssetModuleFilename */ +/** @typedef {import("../Compilation").AssetInfo} AssetInfo */ +/** @typedef {import("../Compiler")} Compiler */ +/** @typedef {import("../Module").BuildInfo} BuildInfo */ +/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("../NormalModule")} NormalModule */ + +/** + * Returns definition. + * @param {string} name name of definitions + * @returns {Schema} definition + */ +const getSchema = (name) => { + const { definitions } = + /** @type {EXPECTED_ANY} */ + (require("../../schemas/WebpackOptions.json")); + + return { + definitions, + oneOf: [{ $ref: `#/definitions/${name}` }] + }; +}; + +const generatorValidationOptions = { + name: "Asset Modules Plugin", + baseDataPath: "generator" +}; + +const getAssetGenerator = memoize(() => require("./AssetGenerator")); +const getAssetParser = memoize(() => require("./AssetParser")); +const getAssetSourceParser = memoize(() => require("./AssetSourceParser")); +const getAssetBytesParser = memoize(() => require("./AssetBytesParser")); +const getAssetSourceGenerator = memoize(() => + require("./AssetSourceGenerator") +); +const getAssetBytesGenerator = memoize(() => require("./AssetBytesGenerator")); +const getNormalModule = memoize(() => require("../NormalModule")); + +const type = ASSET_MODULE_TYPE; +const PLUGIN_NAME = "AssetModulesPlugin"; + +/** + * Represents the asset modules plugin runtime component. + * @typedef {object} AssetModulesPluginOptions + * @property {boolean=} sideEffectFree + */ + +class AssetModulesPlugin { + /** + * Creates an instance of AssetModulesPlugin. + * @param {AssetModulesPluginOptions} options options + */ + constructor(options) { + this.options = options; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap( + PLUGIN_NAME, + (compilation, { normalModuleFactory }) => { + const NormalModule = getNormalModule(); + for (const type of [ + ASSET_MODULE_TYPE, + ASSET_MODULE_TYPE_BYTES, + ASSET_MODULE_TYPE_INLINE, + ASSET_MODULE_TYPE_RESOURCE, + ASSET_MODULE_TYPE_SOURCE + ]) { + normalModuleFactory.hooks.createModuleClass + .for(type) + .tap(PLUGIN_NAME, (createData, _resolveData) => { + // TODO create the module via new AssetModule with its own properties + const module = new NormalModule(createData); + if (this.options.sideEffectFree) { + module.factoryMeta = { sideEffectFree: true }; + } + + return module; + }); + } + + normalModuleFactory.hooks.createParser + .for(ASSET_MODULE_TYPE) + .tap(PLUGIN_NAME, (parserOptions) => { + compiler.validate( + () => getSchema("AssetParserOptions"), + parserOptions, + { + name: "Asset Modules Plugin", + baseDataPath: "parser" + }, + (options) => + require("../../schemas/plugins/asset/AssetParserOptions.check")( + options + ) + ); + + let dataUrlCondition = parserOptions.dataUrlCondition; + if (!dataUrlCondition || typeof dataUrlCondition === "object") { + dataUrlCondition = { + maxSize: 8096, + ...dataUrlCondition + }; + } + + const AssetParser = getAssetParser(); + + return new AssetParser(dataUrlCondition); + }); + normalModuleFactory.hooks.createParser + .for(ASSET_MODULE_TYPE_INLINE) + .tap(PLUGIN_NAME, (_parserOptions) => { + const AssetParser = getAssetParser(); + + return new AssetParser(true); + }); + normalModuleFactory.hooks.createParser + .for(ASSET_MODULE_TYPE_RESOURCE) + .tap(PLUGIN_NAME, (_parserOptions) => { + const AssetParser = getAssetParser(); + + return new AssetParser(false); + }); + normalModuleFactory.hooks.createParser + .for(ASSET_MODULE_TYPE_SOURCE) + .tap(PLUGIN_NAME, (_parserOptions) => { + const AssetSourceParser = getAssetSourceParser(); + + return new AssetSourceParser(); + }); + normalModuleFactory.hooks.createParser + .for(ASSET_MODULE_TYPE_BYTES) + .tap(PLUGIN_NAME, (_parserOptions) => { + const AssetBytesParser = getAssetBytesParser(); + + return new AssetBytesParser(); + }); + + for (const type of [ + ASSET_MODULE_TYPE, + ASSET_MODULE_TYPE_INLINE, + ASSET_MODULE_TYPE_RESOURCE + ]) { + normalModuleFactory.hooks.createGenerator + .for(type) + .tap(PLUGIN_NAME, (generatorOptions) => { + switch (type) { + case ASSET_MODULE_TYPE: { + compiler.validate( + () => getSchema("AssetGeneratorOptions"), + generatorOptions, + generatorValidationOptions, + (options) => + require("../../schemas/plugins/asset/AssetGeneratorOptions.check")( + options + ) + ); + break; + } + case ASSET_MODULE_TYPE_RESOURCE: { + compiler.validate( + () => getSchema("AssetResourceGeneratorOptions"), + generatorOptions, + generatorValidationOptions, + (options) => + require("../../schemas/plugins/asset/AssetResourceGeneratorOptions.check")( + options + ) + ); + break; + } + case ASSET_MODULE_TYPE_INLINE: { + compiler.validate( + () => getSchema("AssetInlineGeneratorOptions"), + generatorOptions, + generatorValidationOptions, + (options) => + require("../../schemas/plugins/asset/AssetInlineGeneratorOptions.check")( + options + ) + ); + break; + } + } + + /** @type {undefined | AssetGeneratorDataUrl} */ + let dataUrl; + if (type !== ASSET_MODULE_TYPE_RESOURCE) { + dataUrl = generatorOptions.dataUrl; + if (!dataUrl || typeof dataUrl === "object") { + dataUrl = { + encoding: undefined, + mimetype: undefined, + ...dataUrl + }; + } + } + + /** @type {undefined | AssetModuleFilename} */ + let filename; + /** @type {undefined | RawPublicPath} */ + let publicPath; + /** @type {undefined | AssetModuleOutputPath} */ + let outputPath; + if (type !== ASSET_MODULE_TYPE_INLINE) { + filename = generatorOptions.filename; + publicPath = generatorOptions.publicPath; + outputPath = generatorOptions.outputPath; + } + + const AssetGenerator = getAssetGenerator(); + + return new AssetGenerator( + compilation.moduleGraph, + dataUrl, + filename, + publicPath, + outputPath, + generatorOptions.emit !== false + ); + }); + } + normalModuleFactory.hooks.createGenerator + .for(ASSET_MODULE_TYPE_SOURCE) + .tap(PLUGIN_NAME, () => { + const AssetSourceGenerator = getAssetSourceGenerator(); + + return new AssetSourceGenerator(compilation.moduleGraph); + }); + + normalModuleFactory.hooks.createGenerator + .for(ASSET_MODULE_TYPE_BYTES) + .tap(PLUGIN_NAME, () => { + const AssetBytesGenerator = getAssetBytesGenerator(); + + return new AssetBytesGenerator(compilation.moduleGraph); + }); + + compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => { + const { chunkGraph } = compilation; + const { chunk, codeGenerationResults, runtimeTemplate } = options; + + const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType( + chunk, + ASSET_MODULE_TYPE, + compareModulesByFullName(compilation.compiler) + ); + if (modules) { + for (const module of modules) { + try { + const codeGenResult = codeGenerationResults.get( + module, + chunk.runtime + ); + const buildInfo = /** @type {BuildInfo} */ (module.buildInfo); + const data = + /** @type {NonNullable} */ + (codeGenResult.data); + const errored = module.getNumberOfErrors() > 0; + + /** @type {string} */ + let entryFilename; + /** @type {AssetInfo} */ + let entryInfo; + /** @type {string} */ + let entryHash; + + if (errored) { + const erroredModule = /** @type {NormalModule} */ (module); + const AssetGenerator = getAssetGenerator(); + const [fullContentHash, contentHash] = + AssetGenerator.getFullContentHash( + erroredModule, + runtimeTemplate + ); + const { filename, assetInfo } = + AssetGenerator.getFilenameWithInfo( + erroredModule, + { + filename: + erroredModule.generatorOptions && + erroredModule.generatorOptions.filename, + outputPath: + erroredModule.generatorOptions && + erroredModule.generatorOptions.outputPath + }, + { + runtime: chunk.runtime, + runtimeTemplate, + chunkGraph + }, + contentHash + ); + entryFilename = filename; + entryInfo = assetInfo; + entryHash = fullContentHash; + } else { + entryFilename = + /** @type {string} */ + (buildInfo.filename || data.get("filename")); + entryInfo = + /** @type {AssetInfo} */ + (buildInfo.assetInfo || data.get("assetInfo")); + entryHash = + /** @type {string} */ + (buildInfo.fullContentHash || data.get("fullContentHash")); + } + + result.push({ + render: () => + /** @type {Source} */ (codeGenResult.sources.get(type)), + filename: entryFilename, + info: entryInfo, + auxiliary: true, + identifier: `assetModule${chunkGraph.getModuleId(module)}`, + hash: entryHash + }); + } catch (err) { + /** @type {Error} */ (err).message += + `\nduring rendering of asset ${module.identifier()}`; + throw err; + } + } + } + + return result; + }); + + compilation.hooks.prepareModuleExecution.tap( + PLUGIN_NAME, + (options, context) => { + const { codeGenerationResult } = options; + const source = codeGenerationResult.sources.get(ASSET_MODULE_TYPE); + if (source === undefined) return; + const data = + /** @type {NonNullable} */ + (codeGenerationResult.data); + context.assets.set( + /** @type {string} */ + (data.get("filename")), + { + source, + info: data.get("assetInfo") + } + ); + } + ); + } + ); + } +} + +module.exports = AssetModulesPlugin; Index: frontend/node_modules/webpack/lib/asset/AssetParser.js =================================================================== --- frontend/node_modules/webpack/lib/asset/AssetParser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/AssetParser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,75 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Yuta Hiroto @hiroppy +*/ + +"use strict"; + +const Parser = require("../Parser"); + +/** @typedef {import("../../declarations/WebpackOptions").AssetParserDataUrlOptions} AssetParserDataUrlOptions */ +/** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */ +/** @typedef {import("../Module")} Module */ +/** @typedef {import("../Module").BuildInfo} BuildInfo */ +/** @typedef {import("../Module").BuildMeta} BuildMeta */ +/** @typedef {import("../Parser").ParserState} ParserState */ +/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */ + +/** @typedef {((source: string | Buffer, context: { filename: string, module: Module }) => boolean)} AssetParserDataUrlFunction */ + +class AssetParser extends Parser { + /** + * Creates an instance of AssetParser. + * @param {AssetParserOptions["dataUrlCondition"] | boolean} dataUrlCondition condition for inlining as DataUrl + */ + constructor(dataUrlCondition) { + super(); + /** @type {AssetParserOptions["dataUrlCondition"] | boolean} */ + this.dataUrlCondition = dataUrlCondition; + } + + /** + * Parses the provided source and updates the parser state. + * @param {string | Buffer | PreparsedAst} source the source to parse + * @param {ParserState} state the parser state + * @returns {ParserState} the parser state + */ + parse(source, state) { + if (typeof source === "object" && !Buffer.isBuffer(source)) { + throw new Error("AssetParser doesn't accept preparsed AST"); + } + + const buildInfo = + /** @type {BuildInfo} */ + (state.module.buildInfo); + buildInfo.strict = true; + const buildMeta = + /** @type {BuildMeta} */ + (state.module.buildMeta); + buildMeta.exportsType = "default"; + buildMeta.defaultObject = false; + + if (typeof this.dataUrlCondition === "function") { + buildInfo.dataUrl = this.dataUrlCondition(source, { + filename: /** @type {string} */ (state.module.getResource()), + module: state.module + }); + } else if (typeof this.dataUrlCondition === "boolean") { + buildInfo.dataUrl = this.dataUrlCondition; + } else if ( + this.dataUrlCondition && + typeof this.dataUrlCondition === "object" + ) { + buildInfo.dataUrl = + Buffer.byteLength(source) <= + /** @type {NonNullable} */ + (this.dataUrlCondition.maxSize); + } else { + throw new Error("Unexpected dataUrlCondition type"); + } + + return state; + } +} + +module.exports = AssetParser; Index: frontend/node_modules/webpack/lib/asset/AssetSourceGenerator.js =================================================================== --- frontend/node_modules/webpack/lib/asset/AssetSourceGenerator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/AssetSourceGenerator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,181 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sergey Melyukov @smelukov +*/ + +"use strict"; + +const { RawSource } = require("webpack-sources"); +const ConcatenationScope = require("../ConcatenationScope"); +const Generator = require("../Generator"); +const { + ASSET_URL_TYPE, + ASSET_URL_TYPES, + CSS_TYPE, + HTML_TYPE, + JAVASCRIPT_AND_ASSET_URL_TYPES, + JAVASCRIPT_TYPE, + JAVASCRIPT_TYPES, + NO_TYPES +} = require("../ModuleSourceTypeConstants"); +const RuntimeGlobals = require("../RuntimeGlobals"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../Generator").GenerateContext} GenerateContext */ +/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */ +/** @typedef {import("../Module").SourceType} SourceType */ +/** @typedef {import("../Module").SourceTypes} SourceTypes */ +/** @typedef {import("../ModuleGraph")} ModuleGraph */ +/** @typedef {import("../NormalModule")} NormalModule */ + +class AssetSourceGenerator extends Generator { + /** + * Creates an instance of AssetSourceGenerator. + * @param {ModuleGraph} moduleGraph the module graph + */ + constructor(moduleGraph) { + super(); + + this._moduleGraph = moduleGraph; + } + + /** + * Generates generated code for this runtime module. + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generate( + module, + { type, concatenationScope, getData, runtimeTemplate, runtimeRequirements } + ) { + const originalSource = module.originalSource(); + const data = getData ? getData() : undefined; + + switch (type) { + case JAVASCRIPT_TYPE: { + if (!originalSource) { + return new RawSource(""); + } + + const content = originalSource.source(); + const encodedSource = + typeof content === "string" ? content : content.toString("utf8"); + + /** @type {string} */ + let sourceContent; + if (concatenationScope) { + concatenationScope.registerNamespaceExport( + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + ); + sourceContent = `${runtimeTemplate.renderConst()} ${ + ConcatenationScope.NAMESPACE_OBJECT_EXPORT + } = ${JSON.stringify(encodedSource)};`; + } else { + runtimeRequirements.add(RuntimeGlobals.module); + sourceContent = `${module.moduleArgument}.exports = ${JSON.stringify( + encodedSource + )};`; + } + return new RawSource(sourceContent); + } + case ASSET_URL_TYPE: { + if (!originalSource) { + return null; + } + + const content = originalSource.source(); + const encodedSource = + typeof content === "string" ? content : content.toString("utf8"); + + if (data) { + data.set("url", { [type]: encodedSource }); + } + return null; + } + default: + return null; + } + } + + /** + * Generates fallback output for the provided error condition. + * @param {Error} error the error + * @param {NormalModule} module module for which the code should be generated + * @param {GenerateContext} generateContext context for generate + * @returns {Source | null} generated code + */ + generateError(error, module, generateContext) { + switch (generateContext.type) { + case JAVASCRIPT_TYPE: { + return new RawSource( + `throw new Error(${JSON.stringify(error.message)});` + ); + } + default: + return null; + } + } + + /** + * Returns the reason this module cannot be concatenated, when one exists. + * @param {NormalModule} module module for which the bailout reason should be determined + * @param {ConcatenationBailoutReasonContext} context context + * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated + */ + getConcatenationBailoutReason(module, context) { + return undefined; + } + + /** + * Returns the source types available for this module. + * @param {NormalModule} module fresh module + * @returns {SourceTypes} available types (do not mutate) + */ + getTypes(module) { + /** @type {Set} */ + const sourceTypes = new Set(); + const connections = this._moduleGraph.getIncomingConnections(module); + + for (const connection of connections) { + if (!connection.originModule) { + continue; + } + + sourceTypes.add(connection.originModule.type.split("/")[0]); + } + + if (sourceTypes.size > 0) { + if ( + sourceTypes.has(JAVASCRIPT_TYPE) && + (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) + ) { + return JAVASCRIPT_AND_ASSET_URL_TYPES; + } else if (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) { + return ASSET_URL_TYPES; + } + return JAVASCRIPT_TYPES; + } + + return NO_TYPES; + } + + /** + * Returns the estimated size for the requested source type. + * @param {NormalModule} module the module + * @param {SourceType=} type source type + * @returns {number} estimate size of the module + */ + getSize(module, type) { + const originalSource = module.originalSource(); + + if (!originalSource) { + return 0; + } + + // Example: m.exports="abcd" + return originalSource.size() + 12; + } +} + +module.exports = AssetSourceGenerator; Index: frontend/node_modules/webpack/lib/asset/AssetSourceParser.js =================================================================== --- frontend/node_modules/webpack/lib/asset/AssetSourceParser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/AssetSourceParser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,38 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Yuta Hiroto @hiroppy +*/ + +"use strict"; + +const Parser = require("../Parser"); + +/** @typedef {import("../Module").BuildInfo} BuildInfo */ +/** @typedef {import("../Module").BuildMeta} BuildMeta */ +/** @typedef {import("../Parser").ParserState} ParserState */ +/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */ + +class AssetSourceParser extends Parser { + /** + * Parses the provided source and updates the parser state. + * @param {string | Buffer | PreparsedAst} source the source to parse + * @param {ParserState} state the parser state + * @returns {ParserState} the parser state + */ + parse(source, state) { + if (typeof source === "object" && !Buffer.isBuffer(source)) { + throw new Error("AssetSourceParser doesn't accept preparsed AST"); + } + const { module } = state; + /** @type {BuildInfo} */ + (module.buildInfo).strict = true; + /** @type {BuildMeta} */ + (module.buildMeta).exportsType = "default"; + /** @type {BuildMeta} */ + (state.module.buildMeta).defaultObject = false; + + return state; + } +} + +module.exports = AssetSourceParser; Index: frontend/node_modules/webpack/lib/asset/RawDataUrlModule.js =================================================================== --- frontend/node_modules/webpack/lib/asset/RawDataUrlModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/asset/RawDataUrlModule.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,190 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { RawSource } = require("webpack-sources"); +const Module = require("../Module"); +const { + JAVASCRIPT_TYPE, + JAVASCRIPT_TYPES +} = require("../ModuleSourceTypeConstants"); +const { ASSET_MODULE_TYPE_RAW_DATA_URL } = require("../ModuleTypeConstants"); +const RuntimeGlobals = require("../RuntimeGlobals"); +const makeSerializable = require("../util/makeSerializable"); + +/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */ +/** @typedef {import("../Compilation")} Compilation */ +/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */ +/** @typedef {import("../Module").BuildCallback} BuildCallback */ +/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */ +/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */ +/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */ +/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */ +/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */ +/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */ +/** @typedef {import("../Module").Sources} Sources */ +/** @typedef {import("../Module").SourceTypes} SourceTypes */ +/** @typedef {import("../RequestShortener")} RequestShortener */ +/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("../util/Hash")} Hash */ +/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */ + +class RawDataUrlModule extends Module { + /** + * Creates an instance of RawDataUrlModule. + * @param {string} url raw url + * @param {string} identifier unique identifier + * @param {string=} readableIdentifier readable identifier + */ + constructor(url, identifier, readableIdentifier) { + super(ASSET_MODULE_TYPE_RAW_DATA_URL, null); + /** @type {string} */ + this.url = url; + /** @type {Buffer | undefined} */ + this.urlBuffer = url ? Buffer.from(url) : undefined; + /** @type {string} */ + this.identifierStr = identifier; + /** @type {string} */ + this.readableIdentifierStr = readableIdentifier || this.identifierStr; + } + + /** + * Returns the source types this module can generate. + * @returns {SourceTypes} types available (do not mutate) + */ + getSourceTypes() { + return JAVASCRIPT_TYPES; + } + + /** + * Returns the unique identifier used to reference this module. + * @returns {string} a unique identifier of the module + */ + identifier() { + return this.identifierStr; + } + + /** + * Returns the estimated size for the requested source type. + * @param {string=} type the source type for which the size should be estimated + * @returns {number} the estimated size of the module (must be non-zero) + */ + size(type) { + if (this.url === undefined) { + this.url = /** @type {Buffer} */ (this.urlBuffer).toString(); + } + return Math.max(1, this.url.length); + } + + /** + * Returns a human-readable identifier for this module. + * @param {RequestShortener} requestShortener the request shortener + * @returns {string} a user readable identifier of the module + */ + readableIdentifier(requestShortener) { + return /** @type {string} */ ( + requestShortener.shorten(this.readableIdentifierStr) + ); + } + + /** + * Checks whether the module needs to be rebuilt for the current build state. + * @param {NeedBuildContext} context context info + * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild + * @returns {void} + */ + needBuild(context, callback) { + return callback(null, !this.buildMeta); + } + + /** + * Builds the module using the provided compilation context. + * @param {WebpackOptions} options webpack options + * @param {Compilation} compilation the compilation + * @param {ResolverWithOptions} resolver the resolver + * @param {InputFileSystem} fs the file system + * @param {BuildCallback} callback callback function + * @returns {void} + */ + build(options, compilation, resolver, fs, callback) { + this.buildMeta = {}; + this.buildInfo = { + cacheable: true + }; + callback(); + } + + /** + * Generates code and runtime requirements for this module. + * @param {CodeGenerationContext} context context for code generation + * @returns {CodeGenerationResult} result + */ + codeGeneration(context) { + if (this.url === undefined) { + this.url = /** @type {Buffer} */ (this.urlBuffer).toString(); + } + /** @type {Sources} */ + const sources = new Map(); + sources.set( + JAVASCRIPT_TYPE, + new RawSource(`module.exports = ${JSON.stringify(this.url)};`) + ); + /** @type {CodeGenerationResultData} */ + const data = new Map(); + data.set("url", { + javascript: this.url + }); + /** @type {RuntimeRequirements} */ + const runtimeRequirements = new Set(); + runtimeRequirements.add(RuntimeGlobals.module); + return { sources, runtimeRequirements, data }; + } + + /** + * Updates the hash with the data contributed by this instance. + * @param {Hash} hash the hash used to track dependencies + * @param {UpdateHashContext} context context + * @returns {void} + */ + updateHash(hash, context) { + hash.update(/** @type {Buffer} */ (this.urlBuffer)); + super.updateHash(hash, context); + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + + write(this.urlBuffer); + write(this.identifierStr); + write(this.readableIdentifierStr); + + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + + this.urlBuffer = read(); + this.identifierStr = read(); + this.readableIdentifierStr = read(); + + super.deserialize(context); + } +} + +makeSerializable(RawDataUrlModule, "webpack/lib/asset/RawDataUrlModule"); + +module.exports = RawDataUrlModule; Index: frontend/node_modules/webpack/lib/async-modules/AsyncModuleHelpers.js =================================================================== --- frontend/node_modules/webpack/lib/async-modules/AsyncModuleHelpers.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/async-modules/AsyncModuleHelpers.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,53 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Haijie Xie @hai-x +*/ + +"use strict"; + +const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency"); + +/** @typedef {import("../ModuleGraph")} ModuleGraph */ +/** @typedef {import("../Module")} Module */ + +/** @typedef {Set} Modules */ + +/** + * Gets outgoing async modules. + * @param {ModuleGraph} moduleGraph module graph + * @param {Module} module module + * @returns {Modules} set of modules + */ +const getOutgoingAsyncModules = (moduleGraph, module) => { + /** @type {Modules} */ + const set = new Set(); + /** @type {Modules} */ + const seen = new Set(); + (function g(module) { + if (!moduleGraph.isAsync(module) || seen.has(module)) return; + seen.add(module); + if (module.buildMeta && module.buildMeta.async) { + set.add(module); + } else { + const outgoingConnectionMap = + moduleGraph.getOutgoingConnectionsByModule(module); + if (outgoingConnectionMap) { + for (const [module, connections] of outgoingConnectionMap) { + if ( + connections.some( + (c) => + c.dependency instanceof HarmonyImportDependency && + c.isTargetActive(undefined) + ) && + module + ) { + g(module); + } + } + } + } + })(module); + return set; +}; + +module.exports.getOutgoingAsyncModules = getOutgoingAsyncModules; Index: frontend/node_modules/webpack/lib/async-modules/AwaitDependenciesInitFragment.js =================================================================== --- frontend/node_modules/webpack/lib/async-modules/AwaitDependenciesInitFragment.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/async-modules/AwaitDependenciesInitFragment.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,94 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const InitFragment = require("../InitFragment"); +const RuntimeGlobals = require("../RuntimeGlobals"); +const Template = require("../Template"); + +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("../Generator").GenerateContext} GenerateContext */ + +/** @typedef {Map} Dependencies */ + +/** + * Represents AwaitDependenciesInitFragment. + * @extends {InitFragment} + */ +class AwaitDependenciesInitFragment extends InitFragment { + /** + * Creates an instance of AwaitDependenciesInitFragment. + * @param {Dependencies} dependencies maps an import var to an async module that needs to be awaited + */ + constructor(dependencies) { + super( + undefined, + InitFragment.STAGE_ASYNC_DEPENDENCIES, + 0, + "await-dependencies" + ); + /** @type {Dependencies} */ + this.dependencies = dependencies; + } + + /** + * Merges another await-dependencies fragment into this fragment. + * @param {AwaitDependenciesInitFragment} other other AwaitDependenciesInitFragment + * @returns {AwaitDependenciesInitFragment} AwaitDependenciesInitFragment + */ + merge(other) { + const dependencies = new Map(other.dependencies); + for (const [key, value] of this.dependencies) { + dependencies.set(key, value); + } + return new AwaitDependenciesInitFragment(dependencies); + } + + /** + * Returns the source code that will be included as initialization code. + * @param {GenerateContext} context context + * @returns {string | Source | undefined} the source code that will be included as initialization code + */ + getContent({ runtimeRequirements, runtimeTemplate }) { + runtimeRequirements.add(RuntimeGlobals.module); + if (this.dependencies.size === 0) { + return ""; + } + + const importVars = [...this.dependencies.keys()]; + const asyncModuleValues = [...this.dependencies.values()].join(", "); + + const templateInput = [ + `var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${asyncModuleValues}]);` + ]; + + if ( + this.dependencies.size === 1 || + !runtimeTemplate.supportsDestructuring() + ) { + templateInput.push( + "var __webpack_async_dependencies_result__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);" + ); + for (const [index, importVar] of importVars.entries()) { + templateInput.push( + `${importVar} = __webpack_async_dependencies_result__[${index}];` + ); + } + } else { + const importVarsStr = importVars.join(", "); + + templateInput.push( + `([${importVarsStr}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);` + ); + } + + templateInput.push(""); + + return Template.asString(templateInput); + } +} + +module.exports = AwaitDependenciesInitFragment; Index: frontend/node_modules/webpack/lib/async-modules/InferAsyncModulesPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/async-modules/InferAsyncModulesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/async-modules/InferAsyncModulesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,54 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency"); + +/** @typedef {import("../Compiler")} Compiler */ +/** @typedef {import("../Module")} Module */ + +const PLUGIN_NAME = "InferAsyncModulesPlugin"; + +class InferAsyncModulesPlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + const { moduleGraph } = compilation; + compilation.hooks.finishModules.tap(PLUGIN_NAME, (modules) => { + /** @type {Set} */ + const queue = new Set(); + for (const module of modules) { + if (module.buildMeta && module.buildMeta.async) { + queue.add(module); + } + } + for (const module of queue) { + moduleGraph.setAsync(module); + for (const [ + originModule, + connections + ] of moduleGraph.getIncomingConnectionsByOriginModule(module)) { + if ( + connections.some( + (c) => + c.dependency instanceof HarmonyImportDependency && + c.isTargetActive(undefined) + ) + ) { + queue.add(/** @type {Module} */ (originModule)); + } + } + } + }); + }); + } +} + +module.exports = InferAsyncModulesPlugin; Index: frontend/node_modules/webpack/lib/buildChunkGraph.js =================================================================== --- frontend/node_modules/webpack/lib/buildChunkGraph.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/buildChunkGraph.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1405 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const ModuleGraphConnection = require("./ModuleGraphConnection"); +const AsyncDependencyToInitialChunkError = require("./errors/AsyncDependencyToInitialChunkError"); +const { getEntryRuntime, mergeRuntime } = require("./util/runtime"); + +/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */ +/** @typedef {import("./Chunk")} Chunk */ +/** @typedef {import("./ChunkGroup")} ChunkGroup */ +/** @typedef {import("./Compilation")} Compilation */ +/** @typedef {import("./DependenciesBlock")} DependenciesBlock */ +/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */ +/** @typedef {import("./Entrypoint")} Entrypoint */ +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ModuleGraph")} ModuleGraph */ +/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */ +/** @typedef {import("./logging/Logger").Logger} Logger */ +/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */ + +/** + * Defines the queue item type used by this module. + * @typedef {object} QueueItem + * @property {number} action + * @property {DependenciesBlock} block + * @property {Module} module + * @property {Chunk} chunk + * @property {ChunkGroup} chunkGroup + * @property {ChunkGroupInfo} chunkGroupInfo + */ + +/** + * Defines the chunk group info type used by this module. + * @typedef {object} ChunkGroupInfo + * @property {ChunkGroup} chunkGroup the chunk group + * @property {RuntimeSpec} runtime the runtimes + * @property {boolean} initialized is this chunk group initialized + * @property {bigint | undefined} minAvailableModules current minimal set of modules available at this point + * @property {bigint[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules + * @property {Set=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking) + * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime + * @property {bigint | undefined} resultingAvailableModules set of modules available including modules from this chunk group + * @property {Set | undefined} children set of children chunk groups, that will be revisited when availableModules shrink + * @property {Set | undefined} availableSources set of chunk groups that are the source for minAvailableModules + * @property {Set | undefined} availableChildren set of chunk groups which depend on the this chunk group as availableSource + * @property {number} preOrderIndex next pre order index + * @property {number} postOrderIndex next post order index + * @property {boolean} chunkLoading has a chunk loading mechanism + * @property {boolean} asyncChunks create async chunks + * @property {Module | null} depModule the module that is the dependency of the block + * @property {boolean} circular Whether to deduplicate to avoid circular references + */ + +/** + * Defines the block chunk group connection type used by this module. + * @typedef {object} BlockChunkGroupConnection + * @property {ChunkGroupInfo} originChunkGroupInfo origin chunk group + * @property {ChunkGroup} chunkGroup referenced chunk group + */ + +/** @typedef {(Module | ConnectionState | ModuleGraphConnection)[]} BlockModulesInTuples */ +/** @typedef {(Module | ConnectionState | ModuleGraphConnection[])[]} BlockModulesInFlattenTuples */ +/** @typedef {Map} BlockModulesMap */ +/** @typedef {Map} MaskByChunk */ +/** @typedef {Set} BlocksWithNestedBlocks */ +/** @typedef {Map} BlockConnections */ +/** @typedef {Map} ChunkGroupInfoMap */ +/** @typedef {Set} AllCreatedChunkGroups */ +/** @typedef {Map} InputEntrypointsAndModules */ + +const ZERO_BIGINT = BigInt(0); +const ONE_BIGINT = BigInt(1); + +/** + * Checks whether this object is ordinal set in mask. + * @param {bigint} mask The mask to test + * @param {number} ordinal The ordinal of the bit to test + * @returns {boolean} If the ordinal-th bit is set in the mask + */ +const isOrdinalSetInMask = (mask, ordinal) => + BigInt.asUintN(1, mask >> BigInt(ordinal)) !== ZERO_BIGINT; + +/** + * Gets active state of connections. + * @param {ModuleGraphConnection[]} connections list of connections + * @param {RuntimeSpec} runtime for which runtime + * @returns {ConnectionState} connection state + */ +const getActiveStateOfConnections = (connections, runtime) => { + let merged = connections[0].getActiveState(runtime); + if (merged === true) return true; + for (let i = 1; i < connections.length; i++) { + const c = connections[i]; + merged = ModuleGraphConnection.addConnectionStates( + merged, + c.getActiveState(runtime) + ); + if (merged === true) return true; + } + return merged; +}; + +/** + * Extract block modules. + * @param {Module} module module + * @param {ModuleGraph} moduleGraph module graph + * @param {RuntimeSpec} runtime runtime + * @param {BlockModulesMap} blockModulesMap block modules map + */ +const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => { + /** @type {DependenciesBlock | undefined} */ + let blockCache; + /** @type {BlockModulesInTuples | undefined} */ + let modules; + + /** @type {BlockModulesInTuples[]} */ + const arrays = []; + + /** @type {DependenciesBlock[]} */ + const queue = [module]; + while (queue.length > 0) { + const block = /** @type {DependenciesBlock} */ (queue.pop()); + /** @type {Module[]} */ + const arr = []; + arrays.push(arr); + blockModulesMap.set(block, arr); + for (const b of block.blocks) { + queue.push(b); + } + } + + for (const connection of moduleGraph.getOutgoingConnections(module)) { + const d = connection.dependency; + // We skip connections without dependency + if (!d) continue; + const m = connection.module; + // We skip connections without Module pointer + if (!m) continue; + // We skip weak connections + if (connection.weak) continue; + + const block = moduleGraph.getParentBlock(d); + let index = moduleGraph.getParentBlockIndex(d); + + // deprecated fallback + if (index < 0) { + index = /** @type {DependenciesBlock} */ (block).dependencies.indexOf(d); + } + + if (blockCache !== block) { + modules = + /** @type {BlockModulesInTuples} */ + ( + blockModulesMap.get( + (blockCache = /** @type {DependenciesBlock} */ (block)) + ) + ); + } + + const i = index * 3; + /** @type {BlockModulesInTuples} */ + (modules)[i] = m; + /** @type {BlockModulesInTuples} */ + (modules)[i + 1] = connection.getActiveState(runtime); + /** @type {BlockModulesInTuples} */ + (modules)[i + 2] = connection; + } + + for (const modules of arrays) { + if (modules.length === 0) continue; + /** @type {undefined | Map} */ + let indexMap; + let length = 0; + outer: for (let j = 0; j < modules.length; j += 3) { + const m = modules[j]; + if (m === undefined) continue; + const state = /** @type {ConnectionState} */ (modules[j + 1]); + const connection = /** @type {ModuleGraphConnection} */ (modules[j + 2]); + if (indexMap === undefined) { + let i = 0; + for (; i < length; i += 3) { + if (modules[i] === m) { + const merged = /** @type {ConnectionState} */ (modules[i + 1]); + /** @type {ModuleGraphConnection[]} */ + (/** @type {unknown} */ (modules[i + 2])).push(connection); + if (merged === true) continue outer; + modules[i + 1] = ModuleGraphConnection.addConnectionStates( + merged, + state + ); + continue outer; + } + } + modules[length] = m; + length++; + modules[length] = state; + length++; + /** @type {ModuleGraphConnection[]} */ + (/** @type {unknown} */ (modules[length])) = [connection]; + length++; + if (length > 30) { + // To avoid worse case performance, we will use an index map for + // linear cost access, which allows to maintain O(n) complexity + // while keeping allocations down to a minimum + indexMap = new Map(); + for (let i = 0; i < length; i += 3) { + indexMap.set(modules[i], i + 1); + } + } + } else { + const idx = indexMap.get(m); + if (idx !== undefined) { + const merged = /** @type {ConnectionState} */ (modules[idx]); + /** @type {ModuleGraphConnection[]} */ + (/** @type {unknown} */ (modules[idx + 1])).push(connection); + if (merged === true) continue; + modules[idx] = ModuleGraphConnection.addConnectionStates( + merged, + state + ); + } else { + modules[length] = m; + length++; + modules[length] = state; + indexMap.set(m, length); + length++; + /** @type {ModuleGraphConnection[]} */ + ( + /** @type {unknown} */ + (modules[length]) + ) = [connection]; + length++; + } + } + } + modules.length = length; + } +}; + +/** + * Processes the provided logger. + * @param {Logger} logger a logger + * @param {Compilation} compilation the compilation + * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules + * @param {ChunkGroupInfoMap} chunkGroupInfoMap mapping from chunk group to available modules + * @param {BlockConnections} blockConnections connection for blocks + * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks + * @param {AllCreatedChunkGroups} allCreatedChunkGroups filled with all chunk groups that are created here + * @param {MaskByChunk} maskByChunk module content mask by chunk + */ +const visitModules = ( + logger, + compilation, + inputEntrypointsAndModules, + chunkGroupInfoMap, + blockConnections, + blocksWithNestedBlocks, + allCreatedChunkGroups, + maskByChunk +) => { + const { moduleGraph, chunkGraph, moduleMemCaches } = compilation; + + /** @type {Map} */ + const blockModulesRuntimeMap = new Map(); + + /** @type {BlockModulesMap | undefined} */ + let blockModulesMap; + + /** @type {Map} */ + const ordinalByModule = new Map(); + + /** + * Gets module ordinal. + * @param {Module} module The module to look up + * @returns {number} The ordinal of the module in masks + */ + const getModuleOrdinal = (module) => { + let ordinal = ordinalByModule.get(module); + if (ordinal === undefined) { + ordinal = ordinalByModule.size; + ordinalByModule.set(module, ordinal); + } + return ordinal; + }; + + for (const chunk of compilation.chunks) { + let mask = ZERO_BIGINT; + for (const m of chunkGraph.getChunkModulesIterable(chunk)) { + mask |= ONE_BIGINT << BigInt(getModuleOrdinal(m)); + } + maskByChunk.set(chunk, mask); + } + + /** + * Gets block modules. + * @param {DependenciesBlock} block block + * @param {RuntimeSpec} runtime runtime + * @returns {BlockModulesInFlattenTuples | undefined} block modules in flatten tuples + */ + const getBlockModules = (block, runtime) => { + blockModulesMap = blockModulesRuntimeMap.get(runtime); + if (blockModulesMap === undefined) { + /** @type {BlockModulesMap} */ + blockModulesMap = new Map(); + blockModulesRuntimeMap.set(runtime, blockModulesMap); + } + let blockModules = blockModulesMap.get(block); + if (blockModules !== undefined) return blockModules; + const module = /** @type {Module} */ (block.getRootBlock()); + const memCache = moduleMemCaches && moduleMemCaches.get(module); + if (memCache !== undefined) { + /** @type {BlockModulesMap} */ + const map = memCache.provide( + "bundleChunkGraph.blockModules", + runtime, + () => { + logger.time("visitModules: prepare"); + const map = new Map(); + extractBlockModules(module, moduleGraph, runtime, map); + logger.timeAggregate("visitModules: prepare"); + return map; + } + ); + for (const [block, blockModules] of map) { + blockModulesMap.set(block, blockModules); + } + return map.get(block); + } + logger.time("visitModules: prepare"); + extractBlockModules(module, moduleGraph, runtime, blockModulesMap); + blockModules = + /** @type {BlockModulesInFlattenTuples} */ + (blockModulesMap.get(block)); + logger.timeAggregate("visitModules: prepare"); + return blockModules; + }; + + let statProcessedQueueItems = 0; + let statProcessedBlocks = 0; + let statConnectedChunkGroups = 0; + let statProcessedChunkGroupsForMerging = 0; + let statMergedAvailableModuleSets = 0; + const statForkedAvailableModules = 0; + const statForkedAvailableModulesCount = 0; + const statForkedAvailableModulesCountPlus = 0; + const statForkedMergedModulesCount = 0; + const statForkedMergedModulesCountPlus = 0; + const statForkedResultModulesCount = 0; + let statChunkGroupInfoUpdated = 0; + let statChildChunkGroupsReconnected = 0; + + let nextChunkGroupIndex = 0; + let nextFreeModulePreOrderIndex = 0; + let nextFreeModulePostOrderIndex = 0; + + /** @type {Map} */ + const blockChunkGroups = new Map(); + + /** @type {Map>} */ + const blocksByChunkGroups = new Map(); + + /** @typedef {Map} NamedChunkGroup */ + + /** @type {NamedChunkGroup} */ + const namedChunkGroups = new Map(); + + /** @type {NamedChunkGroup} */ + const namedAsyncEntrypoints = new Map(); + + /** @type {Map} */ + const depModuleAsyncEntrypoints = new Map(); + + /** @type {Set} */ + const outdatedOrderIndexChunkGroups = new Set(); + + const ADD_AND_ENTER_ENTRY_MODULE = 0; + const ADD_AND_ENTER_MODULE = 1; + const ENTER_MODULE = 2; + const PROCESS_BLOCK = 3; + const PROCESS_ENTRY_BLOCK = 4; + const LEAVE_MODULE = 5; + + /** @type {QueueItem[]} */ + let queue = []; + + /** @typedef {Set<[ChunkGroupInfo, QueueItem | null]>} ConnectList */ + /** @type {Map} */ + const queueConnect = new Map(); + /** @type {Set} */ + const chunkGroupsForCombining = new Set(); + + // Fill queue with entrypoint modules + // Create ChunkGroupInfo for entrypoints + for (const [chunkGroup, modules] of inputEntrypointsAndModules) { + const runtime = getEntryRuntime( + compilation, + /** @type {string} */ (chunkGroup.name), + chunkGroup.options + ); + /** @type {ChunkGroupInfo} */ + const chunkGroupInfo = { + depModule: null, + circular: false, + initialized: false, + chunkGroup, + runtime, + minAvailableModules: undefined, + availableModulesToBeMerged: [], + skippedItems: undefined, + resultingAvailableModules: undefined, + children: undefined, + availableSources: undefined, + availableChildren: undefined, + preOrderIndex: 0, + postOrderIndex: 0, + chunkLoading: + chunkGroup.options.chunkLoading !== undefined + ? chunkGroup.options.chunkLoading !== false + : compilation.outputOptions.chunkLoading !== false, + asyncChunks: + chunkGroup.options.asyncChunks !== undefined + ? chunkGroup.options.asyncChunks + : compilation.outputOptions.asyncChunks !== false + }; + chunkGroup.index = nextChunkGroupIndex++; + if (chunkGroup.getNumberOfParents() > 0) { + // minAvailableModules for child entrypoints are unknown yet, set to undefined. + // This means no module is added until other sets are merged into + // this minAvailableModules (by the parent entrypoints) + const skippedItems = new Set(modules); + chunkGroupInfo.skippedItems = skippedItems; + chunkGroupsForCombining.add(chunkGroupInfo); + } else { + // The application may start here: We start with an empty list of available modules + chunkGroupInfo.minAvailableModules = ZERO_BIGINT; + const chunk = chunkGroup.getEntrypointChunk(); + for (const module of modules) { + queue.push({ + action: ADD_AND_ENTER_MODULE, + block: module, + module, + chunk, + chunkGroup, + chunkGroupInfo + }); + } + } + chunkGroupInfoMap.set(chunkGroup, chunkGroupInfo); + if (chunkGroup.name) { + namedChunkGroups.set(chunkGroup.name, chunkGroupInfo); + } + } + // Fill availableSources with parent-child dependencies between entrypoints + for (const chunkGroupInfo of chunkGroupsForCombining) { + const { chunkGroup } = chunkGroupInfo; + chunkGroupInfo.availableSources = new Set(); + for (const parent of chunkGroup.parentsIterable) { + const parentChunkGroupInfo = + /** @type {ChunkGroupInfo} */ + (chunkGroupInfoMap.get(parent)); + chunkGroupInfo.availableSources.add(parentChunkGroupInfo); + if (parentChunkGroupInfo.availableChildren === undefined) { + parentChunkGroupInfo.availableChildren = new Set(); + } + parentChunkGroupInfo.availableChildren.add(chunkGroupInfo); + } + } + // pop() is used to read from the queue + // so it need to be reversed to be iterated in + // correct order + queue.reverse(); + + /** @type {Set} */ + const outdatedChunkGroupInfo = new Set(); + /** @type {Set<[ChunkGroupInfo, QueueItem | null]>} */ + const chunkGroupsForMerging = new Set(); + /** @type {QueueItem[]} */ + let queueDelayed = []; + + /** @type {[Module, ModuleGraphConnection[]][]} */ + const skipConnectionBuffer = []; + /** @type {Module[]} */ + const skipBuffer = []; + /** @type {QueueItem[]} */ + const queueBuffer = []; + + /** @type {Module} */ + let module; + /** @type {Chunk} */ + let chunk; + /** @type {ChunkGroup} */ + let chunkGroup; + /** @type {DependenciesBlock} */ + let block; + /** @type {ChunkGroupInfo} */ + let chunkGroupInfo; + + // For each async Block in graph + /** + * Processes the provided b. + * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock + * @returns {void} + */ + const iteratorBlock = (b) => { + // 1. We create a chunk group with single chunk in it for this Block + // but only once (blockChunkGroups map) + /** @type {ChunkGroupInfo | undefined} */ + let cgi = blockChunkGroups.get(b); + /** @type {ChunkGroup | undefined} */ + let c; + /** @type {Entrypoint | undefined} */ + let entrypoint; + /** @type {Module | null} */ + const depModule = moduleGraph.getModule(b.dependencies[0]); + const entryOptions = b.groupOptions && b.groupOptions.entryOptions; + if (cgi === undefined) { + const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName; + if (entryOptions) { + cgi = namedAsyncEntrypoints.get(/** @type {string} */ (chunkName)); + if (!cgi && !b.circular && depModule) { + cgi = depModuleAsyncEntrypoints.get(depModule); + } + if (!cgi) { + entrypoint = compilation.addAsyncEntrypoint( + entryOptions, + module, + /** @type {DependencyLocation} */ (b.loc), + /** @type {string} */ (b.request) + ); + maskByChunk.set(entrypoint.chunks[0], ZERO_BIGINT); + entrypoint.index = nextChunkGroupIndex++; + cgi = { + depModule, + circular: b.circular, + chunkGroup: entrypoint, + initialized: false, + runtime: + entrypoint.options.runtime || + /** @type {string | undefined} */ (entrypoint.name), + minAvailableModules: ZERO_BIGINT, + availableModulesToBeMerged: [], + skippedItems: undefined, + resultingAvailableModules: undefined, + children: undefined, + availableSources: undefined, + availableChildren: undefined, + preOrderIndex: 0, + postOrderIndex: 0, + chunkLoading: + entryOptions.chunkLoading !== undefined + ? entryOptions.chunkLoading !== false + : chunkGroupInfo.chunkLoading, + asyncChunks: + entryOptions.asyncChunks !== undefined + ? entryOptions.asyncChunks + : chunkGroupInfo.asyncChunks + }; + chunkGroupInfoMap.set( + entrypoint, + /** @type {ChunkGroupInfo} */ + (cgi) + ); + + chunkGraph.connectBlockAndChunkGroup(b, entrypoint); + if (chunkName) { + namedAsyncEntrypoints.set( + chunkName, + /** @type {ChunkGroupInfo} */ + (cgi) + ); + } + if (!b.circular && depModule) { + depModuleAsyncEntrypoints.set( + depModule, + /** @type {ChunkGroupInfo} */ (cgi) + ); + } + } else { + entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup); + // TODO merge entryOptions + entrypoint.addOrigin( + module, + /** @type {DependencyLocation} */ (b.loc), + /** @type {string} */ (b.request) + ); + chunkGraph.connectBlockAndChunkGroup(b, entrypoint); + } + + // 2. We enqueue the DependenciesBlock for traversal + queueDelayed.push({ + action: PROCESS_ENTRY_BLOCK, + block: b, + module, + chunk: entrypoint.chunks[0], + chunkGroup: entrypoint, + chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi) + }); + } else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) { + // Just queue the block into the current chunk group + queue.push({ + action: PROCESS_BLOCK, + block: b, + module, + chunk, + chunkGroup, + chunkGroupInfo + }); + } else { + cgi = chunkName ? namedChunkGroups.get(chunkName) : undefined; + if (!cgi) { + c = compilation.addChunkInGroup( + b.groupOptions || b.chunkName, + module, + /** @type {DependencyLocation} */ (b.loc), + /** @type {string} */ (b.request) + ); + maskByChunk.set(c.chunks[0], ZERO_BIGINT); + c.index = nextChunkGroupIndex++; + cgi = { + depModule, + circular: b.circular, + initialized: false, + chunkGroup: c, + runtime: chunkGroupInfo.runtime, + minAvailableModules: undefined, + availableModulesToBeMerged: [], + skippedItems: undefined, + resultingAvailableModules: undefined, + children: undefined, + availableSources: undefined, + availableChildren: undefined, + preOrderIndex: 0, + postOrderIndex: 0, + chunkLoading: chunkGroupInfo.chunkLoading, + asyncChunks: chunkGroupInfo.asyncChunks + }; + allCreatedChunkGroups.add(c); + chunkGroupInfoMap.set(c, cgi); + if (chunkName) { + namedChunkGroups.set(chunkName, cgi); + } + } else { + c = cgi.chunkGroup; + if (c.isInitial()) { + compilation.errors.push( + new AsyncDependencyToInitialChunkError( + /** @type {string} */ (chunkName), + module, + /** @type {DependencyLocation} */ (b.loc) + ) + ); + c = chunkGroup; + } else { + c.addOptions(b.groupOptions); + } + c.addOrigin( + module, + /** @type {DependencyLocation} */ (b.loc), + /** @type {string} */ (b.request) + ); + } + blockConnections.set(b, []); + } + blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi)); + } else if (entryOptions) { + entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup); + } else { + c = cgi.chunkGroup; + } + + if (c !== undefined) { + // 2. We store the connection for the block + // to connect it later if needed + /** @type {BlockChunkGroupConnection[]} */ + (blockConnections.get(b)).push({ + originChunkGroupInfo: chunkGroupInfo, + chunkGroup: c + }); + + // 3. We enqueue the chunk group info creation/updating + let connectList = queueConnect.get(chunkGroupInfo); + if (connectList === undefined) { + /** @type {ConnectList} */ + connectList = new Set(); + queueConnect.set(chunkGroupInfo, connectList); + } + connectList.add([ + /** @type {ChunkGroupInfo} */ (cgi), + { + action: PROCESS_BLOCK, + block: b, + module, + chunk: c.chunks[0], + chunkGroup: c, + chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi) + } + ]); + } else if ( + entrypoint !== undefined && + (chunkGroupInfo.circular || chunkGroupInfo.depModule !== depModule) + ) { + chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint); + } + }; + + /** + * Processes the provided block. + * @param {DependenciesBlock} block the block + * @returns {void} + */ + const processBlock = (block) => { + statProcessedBlocks++; + // get prepared block info + const blockModules = getBlockModules(block, chunkGroupInfo.runtime); + + if (blockModules !== undefined) { + const minAvailableModules = + /** @type {bigint} */ + (chunkGroupInfo.minAvailableModules); + // Buffer items because order need to be reversed to get indices correct + // Traverse all referenced modules + for (let i = 0, len = blockModules.length; i < len; i += 3) { + const refModule = /** @type {Module} */ (blockModules[i]); + // For single comparisons this might be cheaper + const isModuleInChunk = chunkGraph.isModuleInChunk(refModule, chunk); + + if (isModuleInChunk) { + // skip early if already connected + continue; + } + + const refOrdinal = /** @type {number} */ getModuleOrdinal(refModule); + const activeState = /** @type {ConnectionState} */ ( + blockModules[i + 1] + ); + if (activeState !== true) { + const connections = /** @type {ModuleGraphConnection[]} */ ( + blockModules[i + 2] + ); + skipConnectionBuffer.push([refModule, connections]); + // We skip inactive connections + if (activeState === false) continue; + } else if (isOrdinalSetInMask(minAvailableModules, refOrdinal)) { + // already in parent chunks, skip it for now + skipBuffer.push(refModule); + continue; + } + // enqueue, then add and enter to be in the correct order + // this is relevant with circular dependencies + queueBuffer.push({ + action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK, + block: refModule, + module: refModule, + chunk, + chunkGroup, + chunkGroupInfo + }); + } + // Add buffered items in reverse order + if (skipConnectionBuffer.length > 0) { + let { skippedModuleConnections } = chunkGroupInfo; + if (skippedModuleConnections === undefined) { + chunkGroupInfo.skippedModuleConnections = skippedModuleConnections = + new Set(); + } + for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) { + skippedModuleConnections.add(skipConnectionBuffer[i]); + } + skipConnectionBuffer.length = 0; + } + if (skipBuffer.length > 0) { + let { skippedItems } = chunkGroupInfo; + if (skippedItems === undefined) { + chunkGroupInfo.skippedItems = skippedItems = new Set(); + } + for (let i = skipBuffer.length - 1; i >= 0; i--) { + skippedItems.add(skipBuffer[i]); + } + skipBuffer.length = 0; + } + if (queueBuffer.length > 0) { + for (let i = queueBuffer.length - 1; i >= 0; i--) { + queue.push(queueBuffer[i]); + } + queueBuffer.length = 0; + } + } + + // Traverse all Blocks + for (const b of block.blocks) { + iteratorBlock(b); + } + + if (block.blocks.length > 0 && module !== block) { + blocksWithNestedBlocks.add(block); + } + }; + + /** + * Process entry block. + * @param {DependenciesBlock} block the block + * @returns {void} + */ + const processEntryBlock = (block) => { + statProcessedBlocks++; + // get prepared block info + const blockModules = getBlockModules(block, chunkGroupInfo.runtime); + + if (blockModules !== undefined) { + // Traverse all referenced modules in reverse order + for (let i = blockModules.length - 3; i >= 0; i -= 3) { + const refModule = /** @type {Module} */ (blockModules[i]); + const activeState = /** @type {ConnectionState} */ ( + blockModules[i + 1] + ); + // enqueue, then add and enter to be in the correct order + // this is relevant with circular dependencies + queue.push({ + action: + activeState === true ? ADD_AND_ENTER_ENTRY_MODULE : PROCESS_BLOCK, + block: refModule, + module: refModule, + chunk, + chunkGroup, + chunkGroupInfo + }); + } + } + + // Traverse all Blocks + for (const b of block.blocks) { + iteratorBlock(b); + } + + if (block.blocks.length > 0 && module !== block) { + blocksWithNestedBlocks.add(block); + } + }; + + const processQueue = () => { + while (queue.length) { + statProcessedQueueItems++; + const queueItem = /** @type {QueueItem} */ (queue.pop()); + module = queueItem.module; + block = queueItem.block; + chunk = queueItem.chunk; + chunkGroup = queueItem.chunkGroup; + chunkGroupInfo = queueItem.chunkGroupInfo; + + switch (queueItem.action) { + case ADD_AND_ENTER_ENTRY_MODULE: + chunkGraph.connectChunkAndEntryModule( + chunk, + module, + /** @type {Entrypoint} */ (chunkGroup) + ); + // fallthrough + case ADD_AND_ENTER_MODULE: { + const isModuleInChunk = chunkGraph.isModuleInChunk(module, chunk); + + if (isModuleInChunk) { + // already connected, skip it + break; + } + // We connect Module and Chunk + chunkGraph.connectChunkAndModule(chunk, module); + const moduleOrdinal = getModuleOrdinal(module); + let chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk)); + chunkMask |= ONE_BIGINT << BigInt(moduleOrdinal); + maskByChunk.set(chunk, chunkMask); + } + // fallthrough + case ENTER_MODULE: { + const index = chunkGroup.getModulePreOrderIndex(module); + if (index === undefined) { + chunkGroup.setModulePreOrderIndex( + module, + chunkGroupInfo.preOrderIndex++ + ); + } + + if ( + moduleGraph.setPreOrderIndexIfUnset( + module, + nextFreeModulePreOrderIndex + ) + ) { + nextFreeModulePreOrderIndex++; + } + + // reuse queueItem + queueItem.action = LEAVE_MODULE; + queue.push(queueItem); + } + // fallthrough + case PROCESS_BLOCK: { + processBlock(block); + break; + } + case PROCESS_ENTRY_BLOCK: { + processEntryBlock(block); + break; + } + case LEAVE_MODULE: { + const index = chunkGroup.getModulePostOrderIndex(module); + if (index === undefined) { + chunkGroup.setModulePostOrderIndex( + module, + chunkGroupInfo.postOrderIndex++ + ); + } + + if ( + moduleGraph.setPostOrderIndexIfUnset( + module, + nextFreeModulePostOrderIndex + ) + ) { + nextFreeModulePostOrderIndex++; + } + break; + } + } + } + }; + + /** + * Calculate resulting available modules. + * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group + * @returns {bigint} The mask of available modules after the chunk group + */ + const calculateResultingAvailableModules = (chunkGroupInfo) => { + if (chunkGroupInfo.resultingAvailableModules !== undefined) { + return chunkGroupInfo.resultingAvailableModules; + } + + let resultingAvailableModules = /** @type {bigint} */ ( + chunkGroupInfo.minAvailableModules + ); + + // add the modules from the chunk group to the set + for (const chunk of chunkGroupInfo.chunkGroup.chunks) { + const mask = /** @type {bigint} */ (maskByChunk.get(chunk)); + resultingAvailableModules |= mask; + } + + return (chunkGroupInfo.resultingAvailableModules = + resultingAvailableModules); + }; + + const processConnectQueue = () => { + // Figure out new parents for chunk groups + // to get new available modules for these children + for (const [chunkGroupInfo, targets] of queueConnect) { + // 1. Add new targets to the list of children + if (chunkGroupInfo.children === undefined) { + chunkGroupInfo.children = new Set(); + } + for (const [target] of targets) { + chunkGroupInfo.children.add(target); + } + + // 2. Calculate resulting available modules + const resultingAvailableModules = + calculateResultingAvailableModules(chunkGroupInfo); + + const runtime = chunkGroupInfo.runtime; + + // 3. Update chunk group info + for (const [target, processBlock] of targets) { + target.availableModulesToBeMerged.push(resultingAvailableModules); + chunkGroupsForMerging.add([target, processBlock]); + const oldRuntime = target.runtime; + const newRuntime = mergeRuntime(oldRuntime, runtime); + if (oldRuntime !== newRuntime) { + target.runtime = newRuntime; + outdatedChunkGroupInfo.add(target); + } + } + + statConnectedChunkGroups += targets.size; + } + queueConnect.clear(); + }; + + const processChunkGroupsForMerging = () => { + statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size; + + // Execute the merge + for (const [info, processBlock] of chunkGroupsForMerging) { + const availableModulesToBeMerged = info.availableModulesToBeMerged; + const cachedMinAvailableModules = info.minAvailableModules; + let minAvailableModules = cachedMinAvailableModules; + + statMergedAvailableModuleSets += availableModulesToBeMerged.length; + + for (const availableModules of availableModulesToBeMerged) { + if (minAvailableModules === undefined) { + minAvailableModules = availableModules; + } else { + minAvailableModules &= availableModules; + } + } + + const changed = minAvailableModules !== cachedMinAvailableModules; + + availableModulesToBeMerged.length = 0; + if (changed) { + info.minAvailableModules = minAvailableModules; + info.resultingAvailableModules = undefined; + outdatedChunkGroupInfo.add(info); + } + + if (processBlock) { + let blocks = blocksByChunkGroups.get(info); + if (!blocks) { + blocksByChunkGroups.set(info, (blocks = new Set())); + } + + // Whether to walk block depends on minAvailableModules and input block. + // We can treat creating chunk group as a function with 2 input, entry block and minAvailableModules + // If input is the same, we can skip re-walk + let needWalkBlock = !info.initialized || changed; + if (!blocks.has(processBlock.block)) { + needWalkBlock = true; + blocks.add(processBlock.block); + } + + if (needWalkBlock) { + info.initialized = true; + queueDelayed.push(processBlock); + } + } + } + chunkGroupsForMerging.clear(); + }; + + const processChunkGroupsForCombining = () => { + for (const info of chunkGroupsForCombining) { + for (const source of /** @type {Set} */ ( + info.availableSources + )) { + if (source.minAvailableModules === undefined) { + chunkGroupsForCombining.delete(info); + break; + } + } + } + + for (const info of chunkGroupsForCombining) { + let availableModules = ZERO_BIGINT; + // combine minAvailableModules from all resultingAvailableModules + for (const source of /** @type {Set} */ ( + info.availableSources + )) { + const resultingAvailableModules = + calculateResultingAvailableModules(source); + availableModules |= resultingAvailableModules; + } + info.minAvailableModules = availableModules; + info.resultingAvailableModules = undefined; + outdatedChunkGroupInfo.add(info); + } + chunkGroupsForCombining.clear(); + }; + + const processOutdatedChunkGroupInfo = () => { + statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size; + // Revisit skipped elements + for (const info of outdatedChunkGroupInfo) { + // 1. Reconsider skipped items + if (info.skippedItems !== undefined) { + const minAvailableModules = + /** @type {bigint} */ + (info.minAvailableModules); + for (const module of info.skippedItems) { + const ordinal = getModuleOrdinal(module); + if (!isOrdinalSetInMask(minAvailableModules, ordinal)) { + queue.push({ + action: ADD_AND_ENTER_MODULE, + block: module, + module, + chunk: info.chunkGroup.chunks[0], + chunkGroup: info.chunkGroup, + chunkGroupInfo: info + }); + info.skippedItems.delete(module); + } + } + } + + // 2. Reconsider skipped connections + if (info.skippedModuleConnections !== undefined) { + const minAvailableModules = + /** @type {bigint} */ + (info.minAvailableModules); + for (const entry of info.skippedModuleConnections) { + const [module, connections] = entry; + const activeState = getActiveStateOfConnections( + connections, + info.runtime + ); + if (activeState === false) continue; + if (activeState === true) { + const ordinal = getModuleOrdinal(module); + info.skippedModuleConnections.delete(entry); + if (isOrdinalSetInMask(minAvailableModules, ordinal)) { + /** @type {NonNullable} */ + (info.skippedItems).add(module); + continue; + } + } + queue.push({ + action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK, + block: module, + module, + chunk: info.chunkGroup.chunks[0], + chunkGroup: info.chunkGroup, + chunkGroupInfo: info + }); + } + } + + // 2. Reconsider children chunk groups + if (info.children !== undefined) { + statChildChunkGroupsReconnected += info.children.size; + for (const cgi of info.children) { + let connectList = queueConnect.get(info); + if (connectList === undefined) { + /** @type {ConnectList} */ + connectList = new Set(); + queueConnect.set(info, connectList); + } + connectList.add([cgi, null]); + } + } + + // 3. Reconsider chunk groups for combining + if (info.availableChildren !== undefined) { + for (const cgi of info.availableChildren) { + chunkGroupsForCombining.add(cgi); + } + } + outdatedOrderIndexChunkGroups.add(info); + } + outdatedChunkGroupInfo.clear(); + }; + + // Iterative traversal of the Module graph + // Recursive would be simpler to write but could result in Stack Overflows + while (queue.length || queueConnect.size) { + logger.time("visitModules: visiting"); + processQueue(); + logger.timeAggregateEnd("visitModules: prepare"); + logger.timeEnd("visitModules: visiting"); + + if (chunkGroupsForCombining.size > 0) { + logger.time("visitModules: combine available modules"); + processChunkGroupsForCombining(); + logger.timeEnd("visitModules: combine available modules"); + } + + if (queueConnect.size > 0) { + logger.time("visitModules: calculating available modules"); + processConnectQueue(); + logger.timeEnd("visitModules: calculating available modules"); + + if (chunkGroupsForMerging.size > 0) { + logger.time("visitModules: merging available modules"); + processChunkGroupsForMerging(); + logger.timeEnd("visitModules: merging available modules"); + } + } + + if (outdatedChunkGroupInfo.size > 0) { + logger.time("visitModules: check modules for revisit"); + processOutdatedChunkGroupInfo(); + logger.timeEnd("visitModules: check modules for revisit"); + } + + // Run queueDelayed when all items of the queue are processed + // This is important to get the global indexing correct + // Async blocks should be processed after all sync blocks are processed + if (queue.length === 0) { + const tempQueue = queue; + queue = queueDelayed.reverse(); + queueDelayed = tempQueue; + } + } + + for (const info of outdatedOrderIndexChunkGroups) { + const { chunkGroup, runtime } = info; + + const blocks = blocksByChunkGroups.get(info); + + if (!blocks) { + continue; + } + + for (const block of blocks) { + let preOrderIndex = 0; + let postOrderIndex = 0; + /** + * Processes the provided current. + * @param {DependenciesBlock} current current + * @param {BlocksWithNestedBlocks} visited visited dependencies blocks + */ + const process = (current, visited) => { + const blockModules = + /** @type {BlockModulesInFlattenTuples} */ + (getBlockModules(current, runtime)); + for (let i = 0, len = blockModules.length; i < len; i += 3) { + const activeState = /** @type {ConnectionState} */ ( + blockModules[i + 1] + ); + if (activeState === false) { + continue; + } + const refModule = /** @type {Module} */ (blockModules[i]); + if (visited.has(refModule)) { + continue; + } + + visited.add(refModule); + + if (refModule) { + chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++); + process(refModule, visited); + chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++); + } + } + }; + process(block, new Set()); + } + } + outdatedOrderIndexChunkGroups.clear(); + ordinalByModule.clear(); + + logger.log( + `${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)` + ); + logger.log(`${statConnectedChunkGroups} chunk groups connected`); + logger.log( + `${statProcessedChunkGroupsForMerging} chunk groups processed for merging (${statMergedAvailableModuleSets} module sets, ${statForkedAvailableModules} forked, ${statForkedAvailableModulesCount} + ${statForkedAvailableModulesCountPlus} modules forked, ${statForkedMergedModulesCount} + ${statForkedMergedModulesCountPlus} modules merged into fork, ${statForkedResultModulesCount} resulting modules)` + ); + logger.log( + `${statChunkGroupInfoUpdated} chunk group info updated (${statChildChunkGroupsReconnected} already connected chunk groups reconnected)` + ); +}; + +/** + * Connects chunk groups. + * @param {Compilation} compilation the compilation + * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks + * @param {BlockConnections} blockConnections connection for blocks + * @param {MaskByChunk} maskByChunk mapping from chunk to module mask + */ +const connectChunkGroups = ( + compilation, + blocksWithNestedBlocks, + blockConnections, + maskByChunk +) => { + const { chunkGraph } = compilation; + + /** + * Helper function to check if all modules of a chunk are available + * @param {ChunkGroup} chunkGroup the chunkGroup to scan + * @param {bigint} availableModules the comparator set + * @returns {boolean} return true if all modules of a chunk are available + */ + const areModulesAvailable = (chunkGroup, availableModules) => { + for (const chunk of chunkGroup.chunks) { + const chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk)); + if ((chunkMask & availableModules) !== chunkMask) return false; + } + return true; + }; + + // For each edge in the basic chunk graph + for (const [block, connections] of blockConnections) { + // 1. Check if connection is needed + // When none of the dependencies need to be connected + // we can skip all of them + // It's not possible to filter each item so it doesn't create inconsistent + // connections and modules can only create one version + // TODO maybe decide this per runtime + if ( + // TODO is this needed? + !blocksWithNestedBlocks.has(block) && + connections.every(({ chunkGroup, originChunkGroupInfo }) => + areModulesAvailable( + chunkGroup, + /** @type {bigint} */ (originChunkGroupInfo.resultingAvailableModules) + ) + ) + ) { + continue; + } + + // 2. Foreach edge + for (let i = 0; i < connections.length; i++) { + const { chunkGroup, originChunkGroupInfo } = connections[i]; + + // 3. Connect block with chunk + chunkGraph.connectBlockAndChunkGroup(block, chunkGroup); + + // 4. Connect chunk with parent + if (originChunkGroupInfo.chunkGroup.addChild(chunkGroup)) { + chunkGroup.addParent(originChunkGroupInfo.chunkGroup); + } + } + } +}; + +/** + * Remove all unconnected chunk groups + * @param {Compilation} compilation the compilation + * @param {Iterable} allCreatedChunkGroups all chunk groups that where created before + */ +const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => { + const { chunkGraph } = compilation; + + for (const chunkGroup of allCreatedChunkGroups) { + if (chunkGroup.getNumberOfParents() === 0) { + for (const chunk of chunkGroup.chunks) { + compilation.chunks.delete(chunk); + chunkGraph.disconnectChunk(chunk); + } + chunkGraph.disconnectChunkGroup(chunkGroup); + chunkGroup.remove(); + } + } +}; + +/** + * This method creates the Chunk graph from the Module graph + * @param {Compilation} compilation the compilation + * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules + * @returns {void} + */ +const buildChunkGraph = (compilation, inputEntrypointsAndModules) => { + const logger = compilation.getLogger("webpack.buildChunkGraph"); + + // SHARED STATE + + /** @type {BlockConnections} */ + const blockConnections = new Map(); + + /** @type {AllCreatedChunkGroups} */ + const allCreatedChunkGroups = new Set(); + + /** @type {ChunkGroupInfoMap} */ + const chunkGroupInfoMap = new Map(); + + /** @type {BlocksWithNestedBlocks} */ + const blocksWithNestedBlocks = new Set(); + + /** @type {MaskByChunk} */ + const maskByChunk = new Map(); + + // PART ONE + + logger.time("visitModules"); + visitModules( + logger, + compilation, + inputEntrypointsAndModules, + chunkGroupInfoMap, + blockConnections, + blocksWithNestedBlocks, + allCreatedChunkGroups, + maskByChunk + ); + logger.timeEnd("visitModules"); + + // PART TWO + + logger.time("connectChunkGroups"); + connectChunkGroups( + compilation, + blocksWithNestedBlocks, + blockConnections, + maskByChunk + ); + logger.timeEnd("connectChunkGroups"); + + for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) { + for (const chunk of chunkGroup.chunks) { + chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime); + } + } + + // Cleanup work + + logger.time("cleanup"); + cleanupUnconnectedGroups(compilation, allCreatedChunkGroups); + logger.timeEnd("cleanup"); +}; + +module.exports = buildChunkGraph; Index: frontend/node_modules/webpack/lib/cache/AddBuildDependenciesPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/cache/AddBuildDependenciesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/AddBuildDependenciesPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("../Compiler")} Compiler */ + +const PLUGIN_NAME = "AddBuildDependenciesPlugin"; + +class AddBuildDependenciesPlugin { + /** + * Creates an instance of AddBuildDependenciesPlugin. + * @param {Iterable} buildDependencies list of build dependencies + */ + constructor(buildDependencies) { + this.buildDependencies = new Set(buildDependencies); + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => { + compilation.buildDependencies.addAll(this.buildDependencies); + }); + } +} + +module.exports = AddBuildDependenciesPlugin; Index: frontend/node_modules/webpack/lib/cache/AddManagedPathsPlugin.js =================================================================== --- frontend/node_modules/webpack/lib/cache/AddManagedPathsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/AddManagedPathsPlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,41 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("../Compiler")} Compiler */ + +class AddManagedPathsPlugin { + /** + * Creates an instance of AddManagedPathsPlugin. + * @param {Iterable} managedPaths list of managed paths + * @param {Iterable} immutablePaths list of immutable paths + * @param {Iterable} unmanagedPaths list of unmanaged paths + */ + constructor(managedPaths, immutablePaths, unmanagedPaths) { + this.managedPaths = new Set(managedPaths); + this.immutablePaths = new Set(immutablePaths); + this.unmanagedPaths = new Set(unmanagedPaths); + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + for (const managedPath of this.managedPaths) { + compiler.managedPaths.add(managedPath); + } + for (const immutablePath of this.immutablePaths) { + compiler.immutablePaths.add(immutablePath); + } + for (const unmanagedPath of this.unmanagedPaths) { + compiler.unmanagedPaths.add(unmanagedPath); + } + } +} + +module.exports = AddManagedPathsPlugin; Index: frontend/node_modules/webpack/lib/cache/IdleFileCachePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/cache/IdleFileCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/IdleFileCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,243 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Cache = require("../Cache"); +const ProgressPlugin = require("../ProgressPlugin"); + +/** @typedef {import("../Compiler")} Compiler */ +/** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */ + +const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key"); +const PLUGIN_NAME = "IdleFileCachePlugin"; + +class IdleFileCachePlugin { + /** + * Creates an instance of IdleFileCachePlugin. + * @param {PackFileCacheStrategy} strategy cache strategy + * @param {number} idleTimeout timeout + * @param {number} idleTimeoutForInitialStore initial timeout + * @param {number} idleTimeoutAfterLargeChanges timeout after changes + */ + constructor( + strategy, + idleTimeout, + idleTimeoutForInitialStore, + idleTimeoutAfterLargeChanges + ) { + this.strategy = strategy; + this.idleTimeout = idleTimeout; + this.idleTimeoutForInitialStore = idleTimeoutForInitialStore; + this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const strategy = this.strategy; + const idleTimeout = this.idleTimeout; + const idleTimeoutForInitialStore = Math.min( + idleTimeout, + this.idleTimeoutForInitialStore + ); + const idleTimeoutAfterLargeChanges = this.idleTimeoutAfterLargeChanges; + const resolvedPromise = Promise.resolve(); + + let timeSpendInBuild = 0; + let timeSpendInStore = 0; + let avgTimeSpendInStore = 0; + + /** @type {Map Promise>} */ + const pendingIdleTasks = new Map(); + + compiler.cache.hooks.store.tap( + { name: PLUGIN_NAME, stage: Cache.STAGE_DISK }, + (identifier, etag, data) => { + pendingIdleTasks.set(identifier, () => + strategy.store(identifier, etag, data) + ); + } + ); + + compiler.cache.hooks.get.tapPromise( + { name: PLUGIN_NAME, stage: Cache.STAGE_DISK }, + (identifier, etag, gotHandlers) => { + const restore = () => + strategy.restore(identifier, etag).then((cacheEntry) => { + if (cacheEntry === undefined) { + gotHandlers.push((result, callback) => { + if (result !== undefined) { + pendingIdleTasks.set(identifier, () => + strategy.store(identifier, etag, result) + ); + } + callback(); + }); + } else { + return cacheEntry; + } + }); + const pendingTask = pendingIdleTasks.get(identifier); + if (pendingTask !== undefined) { + pendingIdleTasks.delete(identifier); + return pendingTask().then(restore); + } + return restore(); + } + ); + + compiler.cache.hooks.storeBuildDependencies.tap( + { name: PLUGIN_NAME, stage: Cache.STAGE_DISK }, + (dependencies) => { + pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () => + Promise.resolve().then(() => + strategy.storeBuildDependencies(dependencies) + ) + ); + } + ); + + compiler.cache.hooks.shutdown.tapPromise( + { name: PLUGIN_NAME, stage: Cache.STAGE_DISK }, + () => { + if (idleTimer) { + clearTimeout(idleTimer); + idleTimer = undefined; + } + isIdle = false; + const reportProgress = ProgressPlugin.getReporter(compiler); + const jobs = [...pendingIdleTasks.values()]; + if (reportProgress) reportProgress(0, "process pending cache items"); + const promises = jobs.map((fn) => fn()); + pendingIdleTasks.clear(); + promises.push(currentIdlePromise); + const promise = Promise.all(promises); + currentIdlePromise = promise.then(() => strategy.afterAllStored()); + if (reportProgress) { + currentIdlePromise = currentIdlePromise.then(() => { + reportProgress(1, "stored"); + }); + } + return currentIdlePromise.then(() => { + // Reset strategy + if (strategy.clear) strategy.clear(); + }); + } + ); + + /** @type {Promise} */ + let currentIdlePromise = resolvedPromise; + let isIdle = false; + let isInitialStore = true; + const processIdleTasks = () => { + if (isIdle) { + const startTime = Date.now(); + if (pendingIdleTasks.size > 0) { + const promises = [currentIdlePromise]; + const maxTime = startTime + 100; + let maxCount = 100; + for (const [filename, factory] of pendingIdleTasks) { + pendingIdleTasks.delete(filename); + promises.push(factory()); + if (maxCount-- <= 0 || Date.now() > maxTime) break; + } + currentIdlePromise = Promise.all( + /** @type {Promise[]} */ + (promises) + ); + currentIdlePromise.then(() => { + timeSpendInStore += Date.now() - startTime; + // Allow to exit the process between + idleTimer = setTimeout(processIdleTasks, 0); + idleTimer.unref(); + }); + return; + } + currentIdlePromise = currentIdlePromise + .then(async () => { + await strategy.afterAllStored(); + timeSpendInStore += Date.now() - startTime; + avgTimeSpendInStore = + Math.max(avgTimeSpendInStore, timeSpendInStore) * 0.9 + + timeSpendInStore * 0.1; + timeSpendInStore = 0; + timeSpendInBuild = 0; + }) + .catch((err) => { + const logger = compiler.getInfrastructureLogger(PLUGIN_NAME); + logger.warn(`Background tasks during idle failed: ${err.message}`); + logger.debug(err.stack); + }); + isInitialStore = false; + } + }; + /** @type {ReturnType | undefined} */ + let idleTimer; + compiler.cache.hooks.beginIdle.tap( + { name: PLUGIN_NAME, stage: Cache.STAGE_DISK }, + () => { + const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2; + if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) { + compiler + .getInfrastructureLogger(PLUGIN_NAME) + .log( + `Initial cache was generated and cache will be persisted in ${ + idleTimeoutForInitialStore / 1000 + }s.` + ); + } else if ( + isLargeChange && + idleTimeoutAfterLargeChanges < idleTimeout + ) { + compiler + .getInfrastructureLogger(PLUGIN_NAME) + .log( + `Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${ + Math.round(avgTimeSpendInStore) / 1000 + }s in average in cache store. This is considered as large change and cache will be persisted in ${ + idleTimeoutAfterLargeChanges / 1000 + }s.` + ); + } + idleTimer = setTimeout( + () => { + idleTimer = undefined; + isIdle = true; + resolvedPromise.then(processIdleTasks); + }, + Math.min( + isInitialStore ? idleTimeoutForInitialStore : Infinity, + isLargeChange ? idleTimeoutAfterLargeChanges : Infinity, + idleTimeout + ) + ); + idleTimer.unref(); + } + ); + compiler.cache.hooks.endIdle.tap( + { name: PLUGIN_NAME, stage: Cache.STAGE_DISK }, + () => { + if (idleTimer) { + clearTimeout(idleTimer); + idleTimer = undefined; + } + isIdle = false; + } + ); + compiler.hooks.done.tap(PLUGIN_NAME, (stats) => { + // 10% build overhead is ignored, as it's not cacheable + timeSpendInBuild *= 0.9; + timeSpendInBuild += + /** @type {number} */ (stats.endTime) - + /** @type {number} */ (stats.startTime); + }); + } +} + +module.exports = IdleFileCachePlugin; Index: frontend/node_modules/webpack/lib/cache/MemoryCachePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/cache/MemoryCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/MemoryCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,57 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Cache = require("../Cache"); + +/** @typedef {import("../Cache").Data} Data */ +/** @typedef {import("../Cache").Etag} Etag */ +/** @typedef {import("../Compiler")} Compiler */ + +class MemoryCachePlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + /** @type {Map} */ + const cache = new Map(); + compiler.cache.hooks.store.tap( + { name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY }, + (identifier, etag, data) => { + cache.set(identifier, { etag, data }); + } + ); + compiler.cache.hooks.get.tap( + { name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY }, + (identifier, etag, gotHandlers) => { + const cacheEntry = cache.get(identifier); + if (cacheEntry === null) { + return null; + } else if (cacheEntry !== undefined) { + return cacheEntry.etag === etag ? cacheEntry.data : null; + } + gotHandlers.push((result, callback) => { + if (result === undefined) { + cache.set(identifier, null); + } else { + cache.set(identifier, { etag, data: result }); + } + return callback(); + }); + } + ); + compiler.cache.hooks.shutdown.tap( + { name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY }, + () => { + cache.clear(); + } + ); + } +} + +module.exports = MemoryCachePlugin; Index: frontend/node_modules/webpack/lib/cache/MemoryWithGcCachePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/cache/MemoryWithGcCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/MemoryWithGcCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,144 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const Cache = require("../Cache"); + +/** @typedef {import("../Cache").Data} Data */ +/** @typedef {import("../Cache").Etag} Etag */ +/** @typedef {import("../Compiler")} Compiler */ + +/** + * Defines the memory with gc cache plugin options type used by this module. + * @typedef {object} MemoryWithGcCachePluginOptions + * @property {number} maxGenerations max generations + */ + +const PLUGIN_NAME = "MemoryWithGcCachePlugin"; + +class MemoryWithGcCachePlugin { + /** + * Creates an instance of MemoryWithGcCachePlugin. + * @param {MemoryWithGcCachePluginOptions} options options + */ + constructor({ maxGenerations }) { + this._maxGenerations = maxGenerations; + } + + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const maxGenerations = this._maxGenerations; + /** @type {Map} */ + const cache = new Map(); + /** @type {Map} */ + const oldCache = new Map(); + let generation = 0; + let cachePosition = 0; + const logger = compiler.getInfrastructureLogger(PLUGIN_NAME); + compiler.hooks.afterDone.tap(PLUGIN_NAME, () => { + generation++; + let clearedEntries = 0; + /** @type {undefined | string} */ + let lastClearedIdentifier; + // Avoid coverage problems due indirect changes + /* istanbul ignore next */ + for (const [identifier, entry] of oldCache) { + if (entry.until > generation) break; + + oldCache.delete(identifier); + if (cache.get(identifier) === undefined) { + cache.delete(identifier); + clearedEntries++; + lastClearedIdentifier = identifier; + } + } + if (clearedEntries > 0 || oldCache.size > 0) { + logger.log( + `${cache.size - oldCache.size} active entries, ${ + oldCache.size + } recently unused cached entries${ + clearedEntries > 0 + ? `, ${clearedEntries} old unused cache entries removed e. g. ${lastClearedIdentifier}` + : "" + }` + ); + } + let i = (cache.size / maxGenerations) | 0; + let j = cachePosition >= cache.size ? 0 : cachePosition; + cachePosition = j + i; + for (const [identifier, entry] of cache) { + if (j !== 0) { + j--; + continue; + } + if (entry !== undefined) { + // We don't delete the cache entry, but set it to undefined instead + // This reserves the location in the data table and avoids rehashing + // when constantly adding and removing entries. + // It will be deleted when removed from oldCache. + cache.set(identifier, undefined); + oldCache.delete(identifier); + oldCache.set(identifier, { + entry, + until: generation + maxGenerations + }); + if (i-- === 0) break; + } + } + }); + compiler.cache.hooks.store.tap( + { name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY }, + (identifier, etag, data) => { + cache.set(identifier, { etag, data }); + } + ); + compiler.cache.hooks.get.tap( + { name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY }, + (identifier, etag, gotHandlers) => { + const cacheEntry = cache.get(identifier); + if (cacheEntry === null) { + return null; + } else if (cacheEntry !== undefined) { + return cacheEntry.etag === etag ? cacheEntry.data : null; + } + const oldCacheEntry = oldCache.get(identifier); + if (oldCacheEntry !== undefined) { + const cacheEntry = oldCacheEntry.entry; + if (cacheEntry === null) { + oldCache.delete(identifier); + cache.set(identifier, cacheEntry); + return null; + } + if (cacheEntry.etag !== etag) return null; + oldCache.delete(identifier); + cache.set(identifier, cacheEntry); + return cacheEntry.data; + } + gotHandlers.push((result, callback) => { + if (result === undefined) { + cache.set(identifier, null); + } else { + cache.set(identifier, { etag, data: result }); + } + return callback(); + }); + } + ); + compiler.cache.hooks.shutdown.tap( + { name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY }, + () => { + cache.clear(); + oldCache.clear(); + } + ); + } +} + +module.exports = MemoryWithGcCachePlugin; Index: frontend/node_modules/webpack/lib/cache/PackFileCacheStrategy.js =================================================================== --- frontend/node_modules/webpack/lib/cache/PackFileCacheStrategy.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/PackFileCacheStrategy.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1629 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const FileSystemInfo = require("../FileSystemInfo"); +const ProgressPlugin = require("../ProgressPlugin"); +const SerializerMiddleware = require("../serialization/SerializerMiddleware"); +const LazySet = require("../util/LazySet"); +const formatSize = require("../util/formatSize"); +const makeSerializable = require("../util/makeSerializable"); +const memoize = require("../util/memoize"); +const { + NOT_SERIALIZABLE, + createFileSerializer +} = require("../util/serialization"); + +/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */ +/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */ +/** @typedef {import("../Cache").Data} Data */ +/** @typedef {import("../Cache").Etag} Etag */ +/** @typedef {import("../Compiler")} Compiler */ +/** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */ +/** @typedef {import("../FileSystemInfo").ResolveResults} ResolveResults */ +/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */ +/** @typedef {import("../logging/Logger").Logger} Logger */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ +/** @typedef {import("../util/Hash").HashFunction} HashFunction */ +/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */ + +/** @typedef {Set} Items */ +/** @typedef {Set} BuildDependencies */ +/** @typedef {Map} ItemInfo */ + +class PackContainer { + /** + * Creates an instance of PackContainer. + * @param {Pack} data stored data + * @param {string} version version identifier + * @param {Snapshot} buildSnapshot snapshot of all build dependencies + * @param {BuildDependencies} buildDependencies list of all unresolved build dependencies captured + * @param {ResolveResults} resolveResults result of the resolved build dependencies + * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving + */ + constructor( + data, + version, + buildSnapshot, + buildDependencies, + resolveResults, + resolveBuildDependenciesSnapshot + ) { + /** @type {Pack | (() => Pack)} */ + this.data = data; + /** @type {string} */ + this.version = version; + /** @type {Snapshot} */ + this.buildSnapshot = buildSnapshot; + /** @type {BuildDependencies} */ + this.buildDependencies = buildDependencies; + /** @type {ResolveResults} */ + this.resolveResults = resolveResults; + /** @type {Snapshot} */ + this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize({ write, writeLazy }) { + write(this.version); + write(this.buildSnapshot); + write(this.buildDependencies); + write(this.resolveResults); + write(this.resolveBuildDependenciesSnapshot); + /** @type {NonNullable} */ + (writeLazy)(this.data); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize({ read }) { + this.version = read(); + this.buildSnapshot = read(); + this.buildDependencies = read(); + this.resolveResults = read(); + this.resolveBuildDependenciesSnapshot = read(); + this.data = read(); + } +} + +makeSerializable( + PackContainer, + "webpack/lib/cache/PackFileCacheStrategy", + "PackContainer" +); + +const MIN_CONTENT_SIZE = 1024 * 1024; // 1 MB +const CONTENT_COUNT_TO_MERGE = 10; +const MIN_ITEMS_IN_FRESH_PACK = 100; +const MAX_ITEMS_IN_FRESH_PACK = 50000; +const MAX_TIME_IN_FRESH_PACK = 60 * 1000; // 1 min + +class PackItemInfo { + /** + * Creates an instance of PackItemInfo. + * @param {string} identifier identifier of item + * @param {string | null | undefined} etag etag of item + * @param {Data} value fresh value of item + */ + constructor(identifier, etag, value) { + /** @type {string} */ + this.identifier = identifier; + /** @type {string | null | undefined} */ + this.etag = etag; + /** @type {number} */ + this.location = -1; + /** @type {number} */ + this.lastAccess = Date.now(); + /** @type {Data} */ + this.freshValue = value; + } +} + +class Pack { + /** + * Creates an instance of Pack. + * @param {Logger} logger a logger + * @param {number} maxAge max age of cache items + */ + constructor(logger, maxAge) { + /** @type {ItemInfo} */ + this.itemInfo = new Map(); + /** @type {(string | undefined)[]} */ + this.requests = []; + /** @type {undefined | NodeJS.Timeout} */ + this.requestsTimeout = undefined; + /** @type {ItemInfo} */ + this.freshContent = new Map(); + /** @type {(undefined | PackContent)[]} */ + this.content = []; + /** @type {boolean} */ + this.invalid = false; + /** @type {Logger} */ + this.logger = logger; + /** @type {number} */ + this.maxAge = maxAge; + } + + /** + * Adds the provided identifier to the pack. + * @param {string} identifier identifier + */ + _addRequest(identifier) { + this.requests.push(identifier); + if (this.requestsTimeout === undefined) { + this.requestsTimeout = setTimeout(() => { + this.requests.push(undefined); + this.requestsTimeout = undefined; + }, MAX_TIME_IN_FRESH_PACK); + if (this.requestsTimeout.unref) this.requestsTimeout.unref(); + } + } + + stopCapturingRequests() { + if (this.requestsTimeout !== undefined) { + clearTimeout(this.requestsTimeout); + this.requestsTimeout = undefined; + } + } + + /** + * Returns cached content. + * @param {string} identifier unique name for the resource + * @param {string | null} etag etag of the resource + * @returns {Data} cached content + */ + get(identifier, etag) { + const info = this.itemInfo.get(identifier); + this._addRequest(identifier); + if (info === undefined) { + return; + } + if (info.etag !== etag) return null; + info.lastAccess = Date.now(); + const loc = info.location; + if (loc === -1) { + return info.freshValue; + } + if (!this.content[loc]) { + return; + } + return /** @type {PackContent} */ (this.content[loc]).get(identifier); + } + + /** + * Updates value using the provided identifier. + * @param {string} identifier unique name for the resource + * @param {string | null} etag etag of the resource + * @param {Data} data cached content + * @returns {void} + */ + set(identifier, etag, data) { + if (!this.invalid) { + this.invalid = true; + this.logger.log(`Pack got invalid because of write to: ${identifier}`); + } + const info = this.itemInfo.get(identifier); + if (info === undefined) { + const newInfo = new PackItemInfo(identifier, etag, data); + this.itemInfo.set(identifier, newInfo); + this._addRequest(identifier); + this.freshContent.set(identifier, newInfo); + } else { + const loc = info.location; + if (loc >= 0) { + this._addRequest(identifier); + this.freshContent.set(identifier, info); + const content = /** @type {PackContent} */ (this.content[loc]); + content.delete(identifier); + if (content.items.size === 0) { + this.content[loc] = undefined; + this.logger.debug("Pack %d got empty and is removed", loc); + } + } + info.freshValue = data; + info.lastAccess = Date.now(); + info.etag = etag; + info.location = -1; + } + } + + getContentStats() { + let count = 0; + let size = 0; + for (const content of this.content) { + if (content !== undefined) { + count++; + const s = content.getSize(); + if (s > 0) { + size += s; + } + } + } + return { count, size }; + } + + /** + * Returns new location of data entries. + * @returns {number} new location of data entries + */ + _findLocation() { + /** @type {number} */ + let i; + for (i = 0; i < this.content.length && this.content[i] !== undefined; i++); + return i; + } + + /** + * Gc and update location. + * @private + * @param {Items} items items + * @param {Items} usedItems used items + * @param {number} newLoc new location + */ + _gcAndUpdateLocation(items, usedItems, newLoc) { + let count = 0; + /** @type {undefined | string} */ + let lastGC; + const now = Date.now(); + for (const identifier of items) { + const info = /** @type {PackItemInfo} */ (this.itemInfo.get(identifier)); + if (now - info.lastAccess > this.maxAge) { + this.itemInfo.delete(identifier); + items.delete(identifier); + usedItems.delete(identifier); + count++; + lastGC = identifier; + } else { + info.location = newLoc; + } + } + if (count > 0) { + this.logger.log( + "Garbage Collected %d old items at pack %d (%d items remaining) e. g. %s", + count, + newLoc, + items.size, + lastGC + ); + } + } + + _persistFreshContent() { + /** @typedef {{ items: Items, map: Content, loc: number }} PackItem */ + const itemsCount = this.freshContent.size; + if (itemsCount > 0) { + const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK); + const itemsPerPack = Math.ceil(itemsCount / packCount); + /** @type {PackItem[]} */ + const packs = []; + let i = 0; + let ignoreNextTimeTick = false; + const createNextPack = () => { + const loc = this._findLocation(); + this.content[loc] = /** @type {EXPECTED_ANY} */ (null); // reserve + /** @type {PackItem} */ + const pack = { + items: new Set(), + map: new Map(), + loc + }; + packs.push(pack); + return pack; + }; + let pack = createNextPack(); + if (this.requestsTimeout !== undefined) { + clearTimeout(this.requestsTimeout); + } + for (const identifier of this.requests) { + if (identifier === undefined) { + if (ignoreNextTimeTick) { + ignoreNextTimeTick = false; + } else if (pack.items.size >= MIN_ITEMS_IN_FRESH_PACK) { + i = 0; + pack = createNextPack(); + } + continue; + } + const info = this.freshContent.get(identifier); + if (info === undefined) continue; + pack.items.add(identifier); + pack.map.set(identifier, info.freshValue); + info.location = pack.loc; + info.freshValue = undefined; + this.freshContent.delete(identifier); + if (++i > itemsPerPack) { + i = 0; + pack = createNextPack(); + ignoreNextTimeTick = true; + } + } + this.requests.length = 0; + for (const pack of packs) { + this.content[pack.loc] = new PackContent( + pack.items, + new Set(pack.items), + new PackContentItems(pack.map) + ); + } + this.logger.log( + `${itemsCount} fresh items in cache put into pack ${ + packs.length > 1 + ? packs + .map((pack) => `${pack.loc} (${pack.items.size} items)`) + .join(", ") + : packs[0].loc + }` + ); + } + } + + /** + * Merges small content files to a single content file + */ + _optimizeSmallContent() { + // 1. Find all small content files + // Treat unused content files separately to avoid + // a merge-split cycle + /** @type {number[]} */ + const smallUsedContents = []; + /** @type {number} */ + let smallUsedContentSize = 0; + /** @type {number[]} */ + const smallUnusedContents = []; + /** @type {number} */ + let smallUnusedContentSize = 0; + for (let i = 0; i < this.content.length; i++) { + const content = this.content[i]; + if (content === undefined) continue; + if (content.outdated) continue; + const size = content.getSize(); + if (size < 0 || size > MIN_CONTENT_SIZE) continue; + if (content.used.size > 0) { + smallUsedContents.push(i); + smallUsedContentSize += size; + } else { + smallUnusedContents.push(i); + smallUnusedContentSize += size; + } + } + + // 2. Check if minimum number is reached + /** @type {number[]} */ + let mergedIndices; + if ( + smallUsedContents.length >= CONTENT_COUNT_TO_MERGE || + smallUsedContentSize > MIN_CONTENT_SIZE + ) { + mergedIndices = smallUsedContents; + } else if ( + smallUnusedContents.length >= CONTENT_COUNT_TO_MERGE || + smallUnusedContentSize > MIN_CONTENT_SIZE + ) { + mergedIndices = smallUnusedContents; + } else { + return; + } + + /** @type {PackContent[]} */ + const mergedContent = []; + + // 3. Remove old content entries + for (const i of mergedIndices) { + mergedContent.push(/** @type {PackContent} */ (this.content[i])); + this.content[i] = undefined; + } + + // 4. Determine merged items + /** @type {Items} */ + const mergedItems = new Set(); + /** @type {Items} */ + const mergedUsedItems = new Set(); + /** @type {((map: Content) => Promise)[]} */ + const addToMergedMap = []; + for (const content of mergedContent) { + for (const identifier of content.items) { + mergedItems.add(identifier); + } + for (const identifier of content.used) { + mergedUsedItems.add(identifier); + } + addToMergedMap.push(async (map) => { + // unpack existing content + // after that values are accessible in .content + await content.unpack( + "it should be merged with other small pack contents" + ); + for (const [identifier, value] of /** @type {Content} */ ( + content.content + )) { + map.set(identifier, value); + } + }); + } + + // 5. GC and update location of merged items + const newLoc = this._findLocation(); + this._gcAndUpdateLocation(mergedItems, mergedUsedItems, newLoc); + + // 6. If not empty, store content somewhere + if (mergedItems.size > 0) { + this.content[newLoc] = new PackContent( + mergedItems, + mergedUsedItems, + memoize(async () => { + /** @type {Content} */ + const map = new Map(); + await Promise.all(addToMergedMap.map((fn) => fn(map))); + return new PackContentItems(map); + }) + ); + this.logger.log( + "Merged %d small files with %d cache items into pack %d", + mergedContent.length, + mergedItems.size, + newLoc + ); + } + } + + /** + * Split large content files with used and unused items + * into two parts to separate used from unused items + */ + _optimizeUnusedContent() { + // 1. Find a large content file with used and unused items + for (let i = 0; i < this.content.length; i++) { + const content = this.content[i]; + if (content === undefined) continue; + const size = content.getSize(); + if (size < MIN_CONTENT_SIZE) continue; + const used = content.used.size; + const total = content.items.size; + if (used > 0 && used < total) { + // 2. Remove this content + this.content[i] = undefined; + + // 3. Determine items for the used content file + const usedItems = new Set(content.used); + const newLoc = this._findLocation(); + this._gcAndUpdateLocation(usedItems, usedItems, newLoc); + + // 4. Create content file for used items + if (usedItems.size > 0) { + this.content[newLoc] = new PackContent( + usedItems, + new Set(usedItems), + async () => { + await content.unpack( + "it should be splitted into used and unused items" + ); + /** @type {Content} */ + const map = new Map(); + for (const identifier of usedItems) { + map.set( + identifier, + /** @type {Content} */ + (content.content).get(identifier) + ); + } + return new PackContentItems(map); + } + ); + } + + // 5. Determine items for the unused content file + const unusedItems = new Set(content.items); + /** @type {Items} */ + const usedOfUnusedItems = new Set(); + for (const identifier of usedItems) { + unusedItems.delete(identifier); + } + const newUnusedLoc = this._findLocation(); + this._gcAndUpdateLocation(unusedItems, usedOfUnusedItems, newUnusedLoc); + + // 6. Create content file for unused items + if (unusedItems.size > 0) { + this.content[newUnusedLoc] = new PackContent( + unusedItems, + usedOfUnusedItems, + async () => { + await content.unpack( + "it should be splitted into used and unused items" + ); + /** @type {Content} */ + const map = new Map(); + for (const identifier of unusedItems) { + map.set( + identifier, + /** @type {Content} */ + (content.content).get(identifier) + ); + } + return new PackContentItems(map); + } + ); + } + + this.logger.log( + "Split pack %d into pack %d with %d used items and pack %d with %d unused items", + i, + newLoc, + usedItems.size, + newUnusedLoc, + unusedItems.size + ); + + // optimizing only one of them is good enough and + // reduces the amount of serialization needed + return; + } + } + } + + /** + * Find the content with the oldest item and run GC on that. + * Only runs for one content to avoid large invalidation. + */ + _gcOldestContent() { + /** @type {PackItemInfo | undefined} */ + let oldest; + for (const info of this.itemInfo.values()) { + if (oldest === undefined || info.lastAccess < oldest.lastAccess) { + oldest = info; + } + } + if ( + Date.now() - /** @type {PackItemInfo} */ (oldest).lastAccess > + this.maxAge + ) { + const loc = /** @type {PackItemInfo} */ (oldest).location; + if (loc < 0) return; + const content = /** @type {PackContent} */ (this.content[loc]); + const items = new Set(content.items); + const usedItems = new Set(content.used); + this._gcAndUpdateLocation(items, usedItems, loc); + + this.content[loc] = + items.size > 0 + ? new PackContent(items, usedItems, async () => { + await content.unpack( + "it contains old items that should be garbage collected" + ); + /** @type {Content} */ + const map = new Map(); + for (const identifier of items) { + map.set( + identifier, + /** @type {Content} */ + (content.content).get(identifier) + ); + } + return new PackContentItems(map); + }) + : undefined; + } + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize({ write, writeSeparate }) { + this._persistFreshContent(); + this._optimizeSmallContent(); + this._optimizeUnusedContent(); + this._gcOldestContent(); + for (const identifier of this.itemInfo.keys()) { + write(identifier); + } + write(null); // null as marker of the end of keys + for (const info of this.itemInfo.values()) { + write(info.etag); + } + for (const info of this.itemInfo.values()) { + write(info.lastAccess); + } + for (let i = 0; i < this.content.length; i++) { + const content = this.content[i]; + if (content !== undefined) { + write(content.items); + content.writeLazy((lazy) => + /** @type {NonNullable} */ + (writeSeparate)(lazy, { name: `${i}` }) + ); + } else { + write(undefined); // undefined marks an empty content slot + } + } + write(null); // null as marker of the end of items + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext & { logger: Logger }} context context + */ + deserialize({ read, logger }) { + this.logger = logger; + { + const items = []; + let item = read(); + while (item !== null) { + items.push(item); + item = read(); + } + this.itemInfo.clear(); + const infoItems = items.map((identifier) => { + const info = new PackItemInfo(identifier, undefined, undefined); + this.itemInfo.set(identifier, info); + return info; + }); + for (const info of infoItems) { + info.etag = read(); + } + for (const info of infoItems) { + info.lastAccess = read(); + } + } + this.content.length = 0; + let items = read(); + while (items !== null) { + if (items === undefined) { + this.content.push(items); + } else { + const idx = this.content.length; + const lazy = read(); + this.content.push( + new PackContent( + items, + new Set(), + lazy, + logger, + `${this.content.length}` + ) + ); + for (const identifier of items) { + /** @type {PackItemInfo} */ + (this.itemInfo.get(identifier)).location = idx; + } + } + items = read(); + } + } +} + +makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack"); + +/** @typedef {Map} Content */ + +class PackContentItems { + /** + * Creates an instance of PackContentItems. + * @param {Content} map items + */ + constructor(map) { + this.map = map; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext & { logger: Logger, profile: boolean | undefined }} context context + */ + serialize({ write, snapshot, rollback, logger, profile }) { + if (profile) { + write(false); + for (const [key, value] of this.map) { + const s = snapshot(); + try { + write(key); + const start = process.hrtime(); + write(value); + const durationHr = process.hrtime(start); + const duration = durationHr[0] * 1000 + durationHr[1] / 1e6; + if (duration > 1) { + if (duration > 500) { + logger.error(`Serialization of '${key}': ${duration} ms`); + } else if (duration > 50) { + logger.warn(`Serialization of '${key}': ${duration} ms`); + } else if (duration > 10) { + logger.info(`Serialization of '${key}': ${duration} ms`); + } else if (duration > 5) { + logger.log(`Serialization of '${key}': ${duration} ms`); + } else { + logger.debug(`Serialization of '${key}': ${duration} ms`); + } + } + } catch (err) { + rollback(s); + if (err === NOT_SERIALIZABLE) continue; + const msg = "Skipped not serializable cache item"; + const notSerializableErr = /** @type {Error} */ (err); + if (notSerializableErr.message.includes("ModuleBuildError")) { + logger.log( + `${msg} (in build error): ${notSerializableErr.message}` + ); + logger.debug( + `${msg} '${key}' (in build error): ${notSerializableErr.stack}` + ); + } else { + logger.warn(`${msg}: ${notSerializableErr.message}`); + logger.debug(`${msg} '${key}': ${notSerializableErr.stack}`); + } + } + } + write(null); + return; + } + // Try to serialize all at once + const s = snapshot(); + try { + write(true); + write(this.map); + } catch (_err) { + rollback(s); + + // Try to serialize each item on it's own + write(false); + for (const [key, value] of this.map) { + const s = snapshot(); + try { + write(key); + write(value); + } catch (err) { + rollback(s); + if (err === NOT_SERIALIZABLE) continue; + const notSerializableErr = /** @type {Error} */ (err); + logger.warn( + `Skipped not serializable cache item '${key}': ${notSerializableErr.message}` + ); + logger.debug(notSerializableErr.stack); + } + } + write(null); + } + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext & { logger: Logger, profile: boolean | undefined }} context context + */ + deserialize({ read, logger, profile }) { + if (read()) { + this.map = read(); + } else if (profile) { + /** @type {Content} */ + const map = new Map(); + let key = read(); + while (key !== null) { + const start = process.hrtime(); + const value = read(); + const durationHr = process.hrtime(start); + const duration = durationHr[0] * 1000 + durationHr[1] / 1e6; + if (duration > 1) { + if (duration > 100) { + logger.error(`Deserialization of '${key}': ${duration} ms`); + } else if (duration > 20) { + logger.warn(`Deserialization of '${key}': ${duration} ms`); + } else if (duration > 5) { + logger.info(`Deserialization of '${key}': ${duration} ms`); + } else if (duration > 2) { + logger.log(`Deserialization of '${key}': ${duration} ms`); + } else { + logger.debug(`Deserialization of '${key}': ${duration} ms`); + } + } + map.set(key, value); + key = read(); + } + this.map = map; + } else { + /** @type {Content} */ + const map = new Map(); + let key = read(); + while (key !== null) { + map.set(key, read()); + key = read(); + } + this.map = map; + } + } +} + +makeSerializable( + PackContentItems, + "webpack/lib/cache/PackFileCacheStrategy", + "PackContentItems" +); + +/** @typedef {(() => Promise | PackContentItems) & Partial<{ options: { size?: number } }>} LazyFunction */ + +class PackContent { + /* + This class can be in these states: + | this.lazy | this.content | this.outdated | state + A1 | undefined | Map | false | fresh content + A2 | undefined | Map | true | (will not happen) + B1 | lazy () => {} | undefined | false | not deserialized + B2 | lazy () => {} | undefined | true | not deserialized, but some items has been removed + C1 | lazy* () => {} | Map | false | deserialized + C2 | lazy* () => {} | Map | true | deserialized, and some items has been removed + + this.used is a subset of this.items. + this.items is a subset of this.content.keys() resp. this.lazy().map.keys() + When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys() + When this.outdated === true, this.items should be used to recreated this.lazy/this.content. + When this.lazy and this.content is set, they contain the same data. + this.get must only be called with a valid item from this.items. + In state C this.lazy is unMemoized + */ + + /** + * Creates an instance of PackContent. + * @param {Items} items keys + * @param {Items} usedItems used keys + * @param {PackContentItems | (() => Promise)} dataOrFn sync or async content + * @param {Logger=} logger logger for logging + * @param {string=} lazyName name of dataOrFn for logging + */ + constructor(items, usedItems, dataOrFn, logger, lazyName) { + /** @type {Items} */ + this.items = items; + /** @type {LazyFunction | undefined} */ + this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined; + /** @type {Content | undefined} */ + this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map; + /** @type {boolean} */ + this.outdated = false; + /** @type {Items} */ + this.used = usedItems; + /** @type {Logger | undefined} */ + this.logger = logger; + /** @type {string | undefined} */ + this.lazyName = lazyName; + } + + /** + * Returns result. + * @param {string} identifier identifier + * @returns {string | Promise} result + */ + get(identifier) { + this.used.add(identifier); + if (this.content) { + return this.content.get(identifier); + } + + const logger = /** @type {Logger} */ (this.logger); + // We are in state B + const { lazyName } = this; + /** @type {string | undefined} */ + let timeMessage; + if (lazyName) { + // only log once + this.lazyName = undefined; + timeMessage = `restore cache content ${lazyName} (${formatSize( + this.getSize() + )})`; + logger.log( + `starting to restore cache content ${lazyName} (${formatSize( + this.getSize() + )}) because of request to: ${identifier}` + ); + logger.time(timeMessage); + } + const value = /** @type {LazyFunction} */ (this.lazy)(); + if ("then" in value) { + return value.then((data) => { + const map = data.map; + if (timeMessage) { + logger.timeEnd(timeMessage); + } + // Move to state C + this.content = map; + this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy); + return map.get(identifier); + }); + } + + const map = value.map; + if (timeMessage) { + logger.timeEnd(timeMessage); + } + // Move to state C + this.content = map; + this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy); + return map.get(identifier); + } + + /** + * Returns maybe a promise if lazy. + * @param {string} reason explanation why unpack is necessary + * @returns {void | Promise} maybe a promise if lazy + */ + unpack(reason) { + if (this.content) return; + + const logger = /** @type {Logger} */ (this.logger); + // Move from state B to C + if (this.lazy) { + const { lazyName } = this; + /** @type {string | undefined} */ + let timeMessage; + if (lazyName) { + // only log once + this.lazyName = undefined; + timeMessage = `unpack cache content ${lazyName} (${formatSize( + this.getSize() + )})`; + logger.log( + `starting to unpack cache content ${lazyName} (${formatSize( + this.getSize() + )}) because ${reason}` + ); + logger.time(timeMessage); + } + const value = + /** @type {PackContentItems | Promise} */ + (this.lazy()); + if ("then" in value) { + return value.then((data) => { + if (timeMessage) { + logger.timeEnd(timeMessage); + } + this.content = data.map; + }); + } + if (timeMessage) { + logger.timeEnd(timeMessage); + } + this.content = value.map; + } + } + + /** + * Returns the estimated size for the requested source type. + * @returns {number} size of the content or -1 if not known + */ + getSize() { + if (!this.lazy) return -1; + const options = + /** @type {{ options: { size?: number } }} */ + (this.lazy).options; + if (!options) return -1; + const size = options.size; + if (typeof size !== "number") return -1; + return size; + } + + /** + * Processes the provided identifier. + * @param {string} identifier identifier + */ + delete(identifier) { + this.items.delete(identifier); + this.used.delete(identifier); + this.outdated = true; + } + + /** + * Processes the provided write. + * @param {(lazy: LazyFunction) => (() => PackContentItems | Promise)} write write function + * @returns {void} + */ + writeLazy(write) { + if (!this.outdated && this.lazy) { + // State B1 or C1 + // this.lazy is still the valid deserialized version + write(this.lazy); + return; + } + if (!this.outdated && this.content) { + // State A1 + const map = new Map(this.content); + // Move to state C1 + this.lazy = SerializerMiddleware.unMemoizeLazy( + write(() => new PackContentItems(map)) + ); + return; + } + if (this.content) { + // State A2 or C2 + /** @type {Content} */ + const map = new Map(); + for (const item of this.items) { + map.set(item, this.content.get(item)); + } + // Move to state C1 + this.outdated = false; + this.content = map; + this.lazy = SerializerMiddleware.unMemoizeLazy( + write(() => new PackContentItems(map)) + ); + return; + } + const logger = /** @type {Logger} */ (this.logger); + // State B2 + const { lazyName } = this; + /** @type {string | undefined} */ + let timeMessage; + if (lazyName) { + // only log once + this.lazyName = undefined; + timeMessage = `unpack cache content ${lazyName} (${formatSize( + this.getSize() + )})`; + logger.log( + `starting to unpack cache content ${lazyName} (${formatSize( + this.getSize() + )}) because it's outdated and need to be serialized` + ); + logger.time(timeMessage); + } + const value = /** @type {LazyFunction} */ (this.lazy)(); + this.outdated = false; + if ("then" in value) { + // Move to state B1 + this.lazy = write(() => + value.then((data) => { + if (timeMessage) { + logger.timeEnd(timeMessage); + } + const oldMap = data.map; + /** @type {Content} */ + const map = new Map(); + for (const item of this.items) { + map.set(item, oldMap.get(item)); + } + // Move to state C1 (or maybe C2) + this.content = map; + this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy); + + return new PackContentItems(map); + }) + ); + } else { + // Move to state C1 + if (timeMessage) { + logger.timeEnd(timeMessage); + } + const oldMap = value.map; + /** @type {Content} */ + const map = new Map(); + for (const item of this.items) { + map.set(item, oldMap.get(item)); + } + this.content = map; + this.lazy = write(() => new PackContentItems(map)); + } + } +} + +/** + * Allow collecting memory. + * @param {Buffer} buf buffer + * @returns {Buffer} buffer that can be collected + */ +const allowCollectingMemory = (buf) => { + const wasted = buf.buffer.byteLength - buf.byteLength; + if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) { + return Buffer.from(buf); + } + return buf; +}; + +class PackFileCacheStrategy { + /** + * Creates an instance of PackFileCacheStrategy. + * @param {object} options options + * @param {Compiler} options.compiler the compiler + * @param {IntermediateFileSystem} options.fs the filesystem + * @param {string} options.context the context directory + * @param {string} options.cacheLocation the location of the cache data + * @param {string} options.version version identifier + * @param {Logger} options.logger a logger + * @param {SnapshotOptions} options.snapshot options regarding snapshotting + * @param {number} options.maxAge max age of cache items + * @param {boolean=} options.profile track and log detailed timing information for individual cache items + * @param {boolean=} options.allowCollectingMemory allow to collect unused memory created during deserialization + * @param {false | "gzip" | "brotli"=} options.compression compression used + * @param {boolean=} options.readonly disable storing cache into filesystem + */ + constructor({ + compiler, + fs, + context, + cacheLocation, + version, + logger, + snapshot, + maxAge, + profile, + allowCollectingMemory, + compression, + readonly + }) { + /** @type {import("../serialization/Serializer")} */ + this.fileSerializer = createFileSerializer( + fs, + /** @type {HashFunction} */ + (compiler.options.output.hashFunction) + ); + /** @type {FileSystemInfo} */ + this.fileSystemInfo = new FileSystemInfo(fs, { + managedPaths: snapshot.managedPaths, + immutablePaths: snapshot.immutablePaths, + logger: logger.getChildLogger("webpack.FileSystemInfo"), + hashFunction: compiler.options.output.hashFunction + }); + /** @type {Compiler} */ + this.compiler = compiler; + /** @type {string} */ + this.context = context; + /** @type {string} */ + this.cacheLocation = cacheLocation; + /** @type {string} */ + this.version = version; + /** @type {Logger} */ + this.logger = logger; + /** @type {number} */ + this.maxAge = maxAge; + /** @type {boolean | undefined} */ + this.profile = profile; + /** @type {boolean | undefined} */ + this.readonly = readonly; + /** @type {boolean | undefined} */ + this.allowCollectingMemory = allowCollectingMemory; + /** @type {false | "gzip" | "brotli" | undefined} */ + this.compression = compression; + /** @type {string} */ + this._extension = + compression === "brotli" + ? ".pack.br" + : compression === "gzip" + ? ".pack.gz" + : ".pack"; + /** @type {SnapshotOptions} */ + this.snapshot = snapshot; + /** @type {BuildDependencies} */ + this.buildDependencies = new Set(); + /** @type {FileSystemDependencies} */ + this.newBuildDependencies = new LazySet(); + /** @type {Snapshot | undefined} */ + this.resolveBuildDependenciesSnapshot = undefined; + /** @type {ResolveResults | undefined} */ + this.resolveResults = undefined; + /** @type {Snapshot | undefined} */ + this.buildSnapshot = undefined; + /** @type {Promise | undefined} */ + this.packPromise = this._openPack(); + /** @type {Promise} */ + this.storePromise = Promise.resolve(); + } + + /** + * Returns pack. + * @returns {Promise} pack + */ + _getPack() { + if (this.packPromise === undefined) { + this.packPromise = this.storePromise.then(() => this._openPack()); + } + return this.packPromise; + } + + /** + * Returns the pack. + * @returns {Promise} the pack + */ + _openPack() { + const { logger, profile, cacheLocation, version } = this; + /** @type {Snapshot} */ + let buildSnapshot; + /** @type {BuildDependencies} */ + let buildDependencies; + /** @type {BuildDependencies} */ + let newBuildDependencies; + /** @type {Snapshot} */ + let resolveBuildDependenciesSnapshot; + /** @type {ResolveResults | undefined} */ + let resolveResults; + logger.time("restore cache container"); + return this.fileSerializer + .deserialize(null, { + filename: `${cacheLocation}/index${this._extension}`, + extension: `${this._extension}`, + logger, + profile, + retainedBuffer: this.allowCollectingMemory + ? allowCollectingMemory + : undefined + }) + .catch((err) => { + if (err.code !== "ENOENT") { + logger.warn( + `Restoring pack failed from ${cacheLocation}${this._extension}: ${err}` + ); + logger.debug(err.stack); + } else { + logger.debug( + `No pack exists at ${cacheLocation}${this._extension}: ${err}` + ); + } + return undefined; + }) + .then((packContainer) => { + logger.timeEnd("restore cache container"); + if (!packContainer) return; + if (!(packContainer instanceof PackContainer)) { + logger.warn( + `Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`, + packContainer + ); + return; + } + if (packContainer.version !== version) { + logger.log( + `Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.` + ); + return; + } + logger.time("check build dependencies"); + return Promise.all([ + new Promise((resolve, _reject) => { + this.fileSystemInfo.checkSnapshotValid( + packContainer.buildSnapshot, + (err, valid) => { + if (err) { + logger.log( + `Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of build dependencies errored: ${err}.` + ); + logger.debug(err.stack); + return resolve(false); + } + if (!valid) { + logger.log( + `Restored pack from ${cacheLocation}${this._extension}, but build dependencies have changed.` + ); + return resolve(false); + } + buildSnapshot = packContainer.buildSnapshot; + return resolve(true); + } + ); + }), + new Promise((resolve, _reject) => { + this.fileSystemInfo.checkSnapshotValid( + packContainer.resolveBuildDependenciesSnapshot, + (err, valid) => { + if (err) { + logger.log( + `Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of resolving of build dependencies errored: ${err}.` + ); + logger.debug(err.stack); + return resolve(false); + } + if (valid) { + resolveBuildDependenciesSnapshot = + packContainer.resolveBuildDependenciesSnapshot; + buildDependencies = packContainer.buildDependencies; + resolveResults = packContainer.resolveResults; + return resolve(true); + } + logger.log( + "resolving of build dependencies is invalid, will re-resolve build dependencies" + ); + this.fileSystemInfo.checkResolveResultsValid( + packContainer.resolveResults, + (err, valid) => { + if (err) { + logger.log( + `Restored pack from ${cacheLocation}${this._extension}, but resolving of build dependencies errored: ${err}.` + ); + logger.debug(err.stack); + return resolve(false); + } + if (valid) { + newBuildDependencies = packContainer.buildDependencies; + resolveResults = packContainer.resolveResults; + return resolve(true); + } + logger.log( + `Restored pack from ${cacheLocation}${this._extension}, but build dependencies resolve to different locations.` + ); + return resolve(false); + } + ); + } + ); + }) + ]) + .catch((err) => { + logger.timeEnd("check build dependencies"); + throw err; + }) + .then(([buildSnapshotValid, resolveValid]) => { + logger.timeEnd("check build dependencies"); + if (buildSnapshotValid && resolveValid) { + logger.time("restore cache content metadata"); + const d = + /** @type {() => Pack} */ + (packContainer.data)(); + logger.timeEnd("restore cache content metadata"); + return d; + } + return undefined; + }); + }) + .then((pack) => { + if (pack) { + pack.maxAge = this.maxAge; + this.buildSnapshot = buildSnapshot; + if (buildDependencies) this.buildDependencies = buildDependencies; + if (newBuildDependencies) { + this.newBuildDependencies.addAll(newBuildDependencies); + } + this.resolveResults = resolveResults; + this.resolveBuildDependenciesSnapshot = + resolveBuildDependenciesSnapshot; + return pack; + } + return new Pack(logger, this.maxAge); + }) + .catch((err) => { + this.logger.warn( + `Restoring pack from ${cacheLocation}${this._extension} failed: ${err}` + ); + this.logger.debug(err.stack); + return new Pack(logger, this.maxAge); + }); + } + + /** + * Returns promise. + * @param {string} identifier unique name for the resource + * @param {Etag | null} etag etag of the resource + * @param {Data} data cached content + * @returns {Promise} promise + */ + store(identifier, etag, data) { + if (this.readonly) return Promise.resolve(); + + return this._getPack().then((pack) => { + pack.set(identifier, etag === null ? null : etag.toString(), data); + }); + } + + /** + * Returns promise to the cached content. + * @param {string} identifier unique name for the resource + * @param {Etag | null} etag etag of the resource + * @returns {Promise} promise to the cached content + */ + restore(identifier, etag) { + return this._getPack() + .then((pack) => + pack.get(identifier, etag === null ? null : etag.toString()) + ) + .catch((err) => { + if (err && err.code !== "ENOENT") { + this.logger.warn( + `Restoring failed for ${identifier} from pack: ${err}` + ); + this.logger.debug(err.stack); + } + }); + } + + /** + * Stores build dependencies. + * @param {FileSystemDependencies | Iterable} dependencies dependencies to store + */ + storeBuildDependencies(dependencies) { + if (this.readonly) return; + this.newBuildDependencies.addAll(dependencies); + } + + afterAllStored() { + const packPromise = this.packPromise; + if (packPromise === undefined) return Promise.resolve(); + const reportProgress = ProgressPlugin.getReporter(this.compiler); + return (this.storePromise = packPromise + .then((pack) => { + pack.stopCapturingRequests(); + if (!pack.invalid) return; + this.packPromise = undefined; + this.logger.log("Storing pack..."); + /** @type {undefined | Promise} */ + let promise; + /** @type {Set} */ + const newBuildDependencies = new Set(); + for (const dep of this.newBuildDependencies) { + if (!this.buildDependencies.has(dep)) { + newBuildDependencies.add(dep); + } + } + if (newBuildDependencies.size > 0 || !this.buildSnapshot) { + if (reportProgress) reportProgress(0.5, "resolve build dependencies"); + this.logger.debug( + `Capturing build dependencies... (${[...newBuildDependencies].join(", ")})` + ); + promise = new Promise( + /** + * Handles the callback logic for this hook. + * @param {(value?: undefined) => void} resolve resolve + * @param {(reason?: Error) => void} reject reject + */ + (resolve, reject) => { + this.logger.time("resolve build dependencies"); + this.fileSystemInfo.resolveBuildDependencies( + this.context, + newBuildDependencies, + (err, result) => { + this.logger.timeEnd("resolve build dependencies"); + if (err) return reject(err); + + this.logger.time("snapshot build dependencies"); + const { + files, + directories, + missing, + resolveResults, + resolveDependencies + } = /** @type {ResolveBuildDependenciesResult} */ (result); + if (this.resolveResults) { + for (const [key, value] of resolveResults) { + this.resolveResults.set(key, value); + } + } else { + this.resolveResults = resolveResults; + } + if (reportProgress) { + reportProgress( + 0.6, + "snapshot build dependencies", + "resolving" + ); + } + this.fileSystemInfo.createSnapshot( + undefined, + resolveDependencies.files, + resolveDependencies.directories, + resolveDependencies.missing, + this.snapshot.resolveBuildDependencies, + (err, snapshot) => { + if (err) { + this.logger.timeEnd("snapshot build dependencies"); + return reject(err); + } + if (!snapshot) { + this.logger.timeEnd("snapshot build dependencies"); + return reject( + new Error("Unable to snapshot resolve dependencies") + ); + } + if (this.resolveBuildDependenciesSnapshot) { + this.resolveBuildDependenciesSnapshot = + this.fileSystemInfo.mergeSnapshots( + this.resolveBuildDependenciesSnapshot, + snapshot + ); + } else { + this.resolveBuildDependenciesSnapshot = snapshot; + } + if (reportProgress) { + reportProgress( + 0.7, + "snapshot build dependencies", + "modules" + ); + } + this.fileSystemInfo.createSnapshot( + undefined, + files, + directories, + missing, + this.snapshot.buildDependencies, + (err, snapshot) => { + this.logger.timeEnd("snapshot build dependencies"); + if (err) return reject(err); + if (!snapshot) { + return reject( + new Error("Unable to snapshot build dependencies") + ); + } + this.logger.debug("Captured build dependencies"); + + if (this.buildSnapshot) { + this.buildSnapshot = + this.fileSystemInfo.mergeSnapshots( + this.buildSnapshot, + snapshot + ); + } else { + this.buildSnapshot = snapshot; + } + + resolve(); + } + ); + } + ); + } + ); + } + ); + } else { + promise = Promise.resolve(); + } + return promise.then(() => { + if (reportProgress) reportProgress(0.8, "serialize pack"); + this.logger.time("store pack"); + const updatedBuildDependencies = new Set(this.buildDependencies); + for (const dep of newBuildDependencies) { + updatedBuildDependencies.add(dep); + } + const content = new PackContainer( + pack, + this.version, + /** @type {Snapshot} */ + (this.buildSnapshot), + updatedBuildDependencies, + /** @type {ResolveResults} */ + (this.resolveResults), + /** @type {Snapshot} */ + (this.resolveBuildDependenciesSnapshot) + ); + return this.fileSerializer + .serialize(content, { + filename: `${this.cacheLocation}/index${this._extension}`, + extension: `${this._extension}`, + logger: this.logger, + profile: this.profile + }) + .then(() => { + for (const dep of newBuildDependencies) { + this.buildDependencies.add(dep); + } + this.newBuildDependencies.clear(); + this.logger.timeEnd("store pack"); + const stats = pack.getContentStats(); + this.logger.log( + "Stored pack (%d items, %d files, %d MiB)", + pack.itemInfo.size, + stats.count, + Math.round(stats.size / 1024 / 1024) + ); + }) + .catch((err) => { + this.logger.timeEnd("store pack"); + this.logger.warn(`Caching failed for pack: ${err}`); + this.logger.debug(err.stack); + }); + }); + }) + .catch((err) => { + this.logger.warn(`Caching failed for pack: ${err}`); + this.logger.debug(err.stack); + })); + } + + clear() { + this.fileSystemInfo.clear(); + this.buildDependencies.clear(); + this.newBuildDependencies.clear(); + this.resolveBuildDependenciesSnapshot = undefined; + this.resolveResults = undefined; + this.buildSnapshot = undefined; + this.packPromise = undefined; + } +} + +module.exports = PackFileCacheStrategy; Index: frontend/node_modules/webpack/lib/cache/ResolverCachePlugin.js =================================================================== --- frontend/node_modules/webpack/lib/cache/ResolverCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/ResolverCachePlugin.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,459 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const LazySet = require("../util/LazySet"); +const makeSerializable = require("../util/makeSerializable"); + +/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */ +/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */ +/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */ +/** @typedef {import("enhanced-resolve").Resolver} Resolver */ +/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */ +/** @typedef {import("../Compiler")} Compiler */ +/** @typedef {import("../FileSystemInfo")} FileSystemInfo */ +/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */ +/** @typedef {import("../FileSystemInfo").SnapshotOptions} SnapshotOptions */ +/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ + +/** + * Defines the sync hook type used by this module. + * @template T + * @typedef {import("tapable").SyncHook} SyncHook + */ + +/** @typedef {Set} Dependencies */ + +class CacheEntry { + /** + * Creates an instance of CacheEntry. + * @param {ResolveRequest} result result + * @param {Snapshot} snapshot snapshot + */ + constructor(result, snapshot) { + this.result = result; + this.snapshot = snapshot; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize({ write }) { + write(this.result); + write(this.snapshot); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize({ read }) { + this.result = read(); + this.snapshot = read(); + } +} + +makeSerializable(CacheEntry, "webpack/lib/cache/ResolverCachePlugin"); + +/** + * Adds the provided set to the cache entry. + * @template T + * @param {Set | LazySet} set set to add items to + * @param {Set | LazySet | Iterable} otherSet set to add items from + * @returns {void} + */ +const addAllToSet = (set, otherSet) => { + if (set instanceof LazySet) { + set.addAll(otherSet); + } else { + for (const item of otherSet) { + set.add(item); + } + } +}; + +/** + * Returns stringified version. + * @template {object} T + * @param {T} object an object + * @param {boolean} excludeContext if true, context is not included in string + * @returns {string} stringified version + */ +const objectToString = (object, excludeContext) => { + let str = ""; + for (const key in object) { + if (excludeContext && key === "context") continue; + const value = object[key]; + str += + typeof value === "object" && value !== null + ? `|${key}=[${objectToString(value, false)}|]` + : `|${key}=|${value}`; + } + return str; +}; + +/** @typedef {NonNullable} Yield */ + +const PLUGIN_NAME = "ResolverCachePlugin"; + +class ResolverCachePlugin { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Compiler} compiler the compiler instance + * @returns {void} + */ + apply(compiler) { + const cache = compiler.getCache(PLUGIN_NAME); + /** @type {FileSystemInfo} */ + let fileSystemInfo; + /** @type {SnapshotOptions | undefined} */ + let snapshotOptions; + let realResolves = 0; + let cachedResolves = 0; + let cacheInvalidResolves = 0; + let concurrentResolves = 0; + compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => { + snapshotOptions = compilation.options.snapshot.resolve; + fileSystemInfo = compilation.fileSystemInfo; + compilation.hooks.finishModules.tap(PLUGIN_NAME, () => { + if (realResolves + cachedResolves > 0) { + const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`); + logger.log( + `${Math.round( + (100 * realResolves) / (realResolves + cachedResolves) + )}% really resolved (${realResolves} real resolves with ${cacheInvalidResolves} cached but invalid, ${cachedResolves} cached valid, ${concurrentResolves} concurrent)` + ); + realResolves = 0; + cachedResolves = 0; + cacheInvalidResolves = 0; + concurrentResolves = 0; + } + }); + }); + + /** @typedef {(err?: Error | null, resolveRequest?: ResolveRequest | null) => void} Callback */ + /** @typedef {ResolveRequest & { _ResolverCachePluginCacheMiss: true }} ResolveRequestWithCacheMiss */ + + /** + * Processes the provided item cache. + * @param {ItemCacheFacade} itemCache cache + * @param {Resolver} resolver the resolver + * @param {ResolveContext} resolveContext context for resolving meta info + * @param {ResolveRequest} request the request info object + * @param {Callback} callback callback function + * @returns {void} + */ + const doRealResolve = ( + itemCache, + resolver, + resolveContext, + request, + callback + ) => { + realResolves++; + const newRequest = + /** @type {ResolveRequestWithCacheMiss} */ + ({ + _ResolverCachePluginCacheMiss: true, + ...request + }); + /** @type {ResolveContext} */ + const newResolveContext = { + ...resolveContext, + stack: new Set(), + missingDependencies: new LazySet(), + fileDependencies: new LazySet(), + contextDependencies: new LazySet() + }; + /** @type {ResolveRequest[] | undefined} */ + let yieldResult; + let withYield = false; + if (typeof newResolveContext.yield === "function") { + yieldResult = []; + withYield = true; + newResolveContext.yield = (obj) => + /** @type {ResolveRequest[]} */ + (yieldResult).push(obj); + } + /** + * Processes the provided key. + * @param {"fileDependencies" | "contextDependencies" | "missingDependencies"} key key + */ + const propagate = (key) => { + if (resolveContext[key]) { + addAllToSet( + /** @type {Dependencies} */ (resolveContext[key]), + /** @type {Dependencies} */ (newResolveContext[key]) + ); + } + }; + const resolveTime = Date.now(); + resolver.doResolve( + resolver.hooks.resolve, + newRequest, + "Cache miss", + newResolveContext, + (err, result) => { + propagate("fileDependencies"); + propagate("contextDependencies"); + propagate("missingDependencies"); + if (err) return callback(err); + const fileDependencies = newResolveContext.fileDependencies; + const contextDependencies = newResolveContext.contextDependencies; + const missingDependencies = newResolveContext.missingDependencies; + fileSystemInfo.createSnapshot( + resolveTime, + /** @type {Dependencies} */ + (fileDependencies), + /** @type {Dependencies} */ + (contextDependencies), + /** @type {Dependencies} */ + (missingDependencies), + snapshotOptions, + (err, snapshot) => { + if (err) return callback(err); + const resolveResult = withYield ? yieldResult : result; + // since we intercept resolve hook + // we still can get result in callback + if (withYield && result) { + /** @type {ResolveRequest[]} */ + (yieldResult).push(result); + } + if (!snapshot) { + if (resolveResult) { + return callback( + null, + /** @type {ResolveRequest} */ + (resolveResult) + ); + } + return callback(); + } + itemCache.store( + new CacheEntry( + /** @type {ResolveRequest} */ + (resolveResult), + snapshot + ), + (storeErr) => { + if (storeErr) return callback(storeErr); + if (resolveResult) { + return callback( + null, + /** @type {ResolveRequest} */ + (resolveResult) + ); + } + callback(); + } + ); + } + ); + } + ); + }; + compiler.resolverFactory.hooks.resolver.intercept({ + factory(type, _hook) { + /** @typedef {(err?: Error, resolveRequest?: ResolveRequest) => void} ActiveRequest */ + /** @type {Map} */ + const activeRequests = new Map(); + /** @type {Map} */ + const activeRequestsWithYield = new Map(); + const hook = + /** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */ + (_hook); + hook.tap(PLUGIN_NAME, (resolver, options, userOptions) => { + if ( + /** @type {ResolveOptions & { cache: boolean }} */ + (options).cache !== true + ) { + return; + } + const optionsIdent = objectToString(userOptions, false); + const cacheWithContext = + options.cacheWithContext !== undefined + ? options.cacheWithContext + : false; + resolver.hooks.resolve.tapAsync( + { + name: PLUGIN_NAME, + stage: -100 + }, + (request, resolveContext, callback) => { + if ( + /** @type {ResolveRequestWithCacheMiss} */ + (request)._ResolverCachePluginCacheMiss || + !fileSystemInfo + ) { + return callback(); + } + const withYield = typeof resolveContext.yield === "function"; + const identifier = `${type}${ + withYield ? "|yield" : "|default" + }${optionsIdent}${objectToString(request, !cacheWithContext)}`; + + if (withYield) { + const activeRequest = activeRequestsWithYield.get(identifier); + if (activeRequest) { + activeRequest[0].push(callback); + activeRequest[1].push( + /** @type {Yield} */ + (resolveContext.yield) + ); + return; + } + } else { + const activeRequest = activeRequests.get(identifier); + if (activeRequest) { + activeRequest.push(callback); + return; + } + } + const itemCache = cache.getItemCache(identifier, null); + /** @type {Callback[] | false | undefined} */ + let callbacks; + /** @type {Yield[] | undefined} */ + let yields; + + /** + * @type {(err?: Error | null, result?: ResolveRequest | ResolveRequest[] | null) => void} + */ + const done = withYield + ? (err, result) => { + if (callbacks === undefined) { + if (err) { + callback(err); + } else { + if (result) { + for (const r of /** @type {ResolveRequest[]} */ ( + result + )) { + /** @type {Yield} */ + (resolveContext.yield)(r); + } + } + callback(null, null); + } + yields = undefined; + callbacks = false; + } else { + const definedCallbacks = + /** @type {Callback[]} */ + (callbacks); + + if (err) { + for (const cb of definedCallbacks) cb(err); + } else { + for (let i = 0; i < definedCallbacks.length; i++) { + const cb = definedCallbacks[i]; + const yield_ = /** @type {Yield[]} */ (yields)[i]; + if (result) { + for (const r of /** @type {ResolveRequest[]} */ ( + result + )) { + yield_(r); + } + } + cb(null, null); + } + } + activeRequestsWithYield.delete(identifier); + yields = undefined; + callbacks = false; + } + } + : (err, result) => { + if (callbacks === undefined) { + callback(err, /** @type {ResolveRequest} */ (result)); + callbacks = false; + } else { + for (const callback of /** @type {Callback[]} */ ( + callbacks + )) { + callback(err, /** @type {ResolveRequest} */ (result)); + } + activeRequests.delete(identifier); + callbacks = false; + } + }; + /** + * Process cache result. + * @param {(Error | null)=} err error if any + * @param {(CacheEntry | null)=} cacheEntry cache entry + * @returns {void} + */ + const processCacheResult = (err, cacheEntry) => { + if (err) return done(err); + + if (cacheEntry) { + const { snapshot, result } = cacheEntry; + fileSystemInfo.checkSnapshotValid(snapshot, (err, valid) => { + if (err || !valid) { + cacheInvalidResolves++; + return doRealResolve( + itemCache, + resolver, + resolveContext, + request, + done + ); + } + cachedResolves++; + if (resolveContext.missingDependencies) { + addAllToSet( + /** @type {Dependencies} */ + (resolveContext.missingDependencies), + snapshot.getMissingIterable() + ); + } + if (resolveContext.fileDependencies) { + addAllToSet( + /** @type {Dependencies} */ + (resolveContext.fileDependencies), + snapshot.getFileIterable() + ); + } + if (resolveContext.contextDependencies) { + addAllToSet( + /** @type {Dependencies} */ + (resolveContext.contextDependencies), + snapshot.getContextIterable() + ); + } + done(null, result); + }); + } else { + doRealResolve( + itemCache, + resolver, + resolveContext, + request, + done + ); + } + }; + itemCache.get(processCacheResult); + if (withYield && callbacks === undefined) { + callbacks = [callback]; + yields = [/** @type {Yield} */ (resolveContext.yield)]; + activeRequestsWithYield.set(identifier, [callbacks, yields]); + } else if (callbacks === undefined) { + callbacks = [callback]; + activeRequests.set(identifier, callbacks); + } + } + ); + }); + return hook; + } + }); + } +} + +module.exports = ResolverCachePlugin; Index: frontend/node_modules/webpack/lib/cache/getLazyHashedEtag.js =================================================================== --- frontend/node_modules/webpack/lib/cache/getLazyHashedEtag.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/getLazyHashedEtag.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,95 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { DEFAULTS } = require("../config/defaults"); +const createHash = require("../util/createHash"); + +/** @typedef {import("../util/Hash")} Hash */ +/** @typedef {typeof import("../util/Hash")} HashConstructor */ +/** @typedef {import("../util/Hash").HashFunction} HashFunction */ + +/** + * Represents the lazy hashed etag runtime component. + * @typedef {object} HashableObject + * @property {(hash: Hash) => void} updateHash + */ + +class LazyHashedEtag { + /** + * Creates an instance of LazyHashedEtag. + * @param {HashableObject} obj object with updateHash method + * @param {HashFunction} hashFunction the hash function to use + */ + constructor(obj, hashFunction = DEFAULTS.HASH_FUNCTION) { + /** @type {HashableObject} */ + this._obj = obj; + /** @type {undefined | string} */ + this._hash = undefined; + /** @type {HashFunction} */ + this._hashFunction = hashFunction; + } + + /** + * Returns a string representation. + * @returns {string} hash of object + */ + toString() { + if (this._hash === undefined) { + const hash = createHash(this._hashFunction); + this._obj.updateHash(hash); + this._hash = hash.digest("base64"); + } + return this._hash; + } +} + +/** @typedef {WeakMap} InnerCache */ + +/** @type {Map} */ +const mapStrings = new Map(); + +/** @type {WeakMap} */ +const mapObjects = new WeakMap(); + +/** + * Returns etag. + * @param {HashableObject} obj object with updateHash method + * @param {HashFunction=} hashFunction the hash function to use + * @returns {LazyHashedEtag} etag + */ +const getter = (obj, hashFunction = DEFAULTS.HASH_FUNCTION) => { + /** @type {undefined | InnerCache} */ + let innerMap; + if (typeof hashFunction === "string") { + innerMap = mapStrings.get(hashFunction); + if (innerMap === undefined) { + const newHash = new LazyHashedEtag(obj, hashFunction); + /** @type {InnerCache} */ + innerMap = new WeakMap(); + innerMap.set(obj, newHash); + mapStrings.set(hashFunction, innerMap); + return newHash; + } + } else { + innerMap = mapObjects.get(hashFunction); + if (innerMap === undefined) { + const newHash = new LazyHashedEtag(obj, hashFunction); + /** @type {InnerCache} */ + innerMap = new WeakMap(); + innerMap.set(obj, newHash); + mapObjects.set(hashFunction, innerMap); + return newHash; + } + } + const hash = innerMap.get(obj); + if (hash !== undefined) return hash; + const newHash = new LazyHashedEtag(obj, hashFunction); + innerMap.set(obj, newHash); + return newHash; +}; + +module.exports = getter; Index: frontend/node_modules/webpack/lib/cache/mergeEtags.js =================================================================== --- frontend/node_modules/webpack/lib/cache/mergeEtags.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cache/mergeEtags.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,73 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("../Cache").Etag} Etag */ + +class MergedEtag { + /** + * Creates an instance of MergedEtag. + * @param {Etag} a first + * @param {Etag} b second + */ + constructor(a, b) { + this.a = a; + this.b = b; + } + + toString() { + return `${this.a.toString()}|${this.b.toString()}`; + } +} + +/** @type {WeakMap>} */ +const dualObjectMap = new WeakMap(); +/** @type {WeakMap>} */ +const objectStringMap = new WeakMap(); + +/** + * Merges the provided values into a single result. + * @param {Etag} a first + * @param {Etag} b second + * @returns {string | MergedEtag} result + */ +const mergeEtags = (a, b) => { + if (typeof a === "string") { + if (typeof b === "string") { + return `${a}|${b}`; + } + const temp = b; + b = a; + a = temp; + } else if (typeof b !== "string") { + // both a and b are objects + let map = dualObjectMap.get(a); + if (map === undefined) { + dualObjectMap.set(a, (map = new WeakMap())); + } + const mergedEtag = map.get(b); + if (mergedEtag === undefined) { + const newMergedEtag = new MergedEtag(a, b); + map.set(b, newMergedEtag); + return newMergedEtag; + } + return mergedEtag; + } + // a is object, b is string + let map = objectStringMap.get(a); + if (map === undefined) { + objectStringMap.set(a, (map = new Map())); + } + const mergedEtag = map.get(b); + if (mergedEtag === undefined) { + const newMergedEtag = new MergedEtag(a, b); + map.set(b, newMergedEtag); + return newMergedEtag; + } + return mergedEtag; +}; + +module.exports = mergeEtags; Index: frontend/node_modules/webpack/lib/cli.js =================================================================== --- frontend/node_modules/webpack/lib/cli.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/cli.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,893 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const path = require("path"); +const tty = require("tty"); +const webpackSchema = + /** @type {EXPECTED_ANY} */ + (require("../schemas/WebpackOptions.json")); + +/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */ +/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */ +/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */ +/** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */ +/** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */ + +// TODO add originPath to PathItem for better errors +/** + * Defines the path item type used by this module. + * @typedef {object} PathItem + * @property {Schema} schema the part of the schema + * @property {string} path the path in the config + */ + +/** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */ + +/** @typedef {string | number | boolean | RegExp} Value */ + +/** + * Defines the problem type used by this module. + * @typedef {object} Problem + * @property {ProblemType} type + * @property {string} path + * @property {string} argument + * @property {Value=} value + * @property {number=} index + * @property {string=} expected + */ + +/** + * Defines the local problem type used by this module. + * @typedef {object} LocalProblem + * @property {ProblemType} type + * @property {string} path + * @property {string=} expected + */ + +/** @typedef {{ [key: string]: EnumValue }} EnumValueObject */ +/** @typedef {EnumValue[]} EnumValueArray */ +/** @typedef {string | number | boolean | EnumValueObject | EnumValueArray | null} EnumValue */ + +/** + * Defines the argument config type used by this module. + * @typedef {object} ArgumentConfig + * @property {string=} description + * @property {string=} negatedDescription + * @property {string} path + * @property {boolean} multiple + * @property {"enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset"} type + * @property {EnumValue[]=} values + */ + +/** @typedef {"string" | "number" | "boolean"} SimpleType */ + +/** + * Defines the argument type used by this module. + * @typedef {object} Argument + * @property {string | undefined} description + * @property {SimpleType} simpleType + * @property {boolean} multiple + * @property {ArgumentConfig[]} configs + */ + +/** @typedef {Record} Flags */ + +/** @typedef {Record} ObjectConfiguration */ + +/** + * Returns object of arguments. + * @param {Schema=} schema a json schema to create arguments for (by default webpack schema is used) + * @returns {Flags} object of arguments + */ +const getArguments = (schema = webpackSchema) => { + /** @type {Flags} */ + const flags = {}; + + /** + * Path to argument name. + * @param {string} input input + * @returns {string} result + */ + const pathToArgumentName = (input) => + input + .replace(/\./g, "-") + .replace(/\[\]/g, "") + .replace( + /(\p{Uppercase_Letter}+|\p{Lowercase_Letter}|\d)(\p{Uppercase_Letter}+)/gu, + "$1-$2" + ) + .replace(/-?[^\p{Uppercase_Letter}\p{Lowercase_Letter}\d]+/gu, "-") + .toLowerCase(); + + /** + * Returns schema part. + * @param {string} path path + * @returns {Schema} schema part + */ + const getSchemaPart = (path) => { + const newPath = path.split("/"); + + let schemaPart = schema; + + for (let i = 1; i < newPath.length; i++) { + const inner = schemaPart[/** @type {keyof Schema} */ (newPath[i])]; + + if (!inner) { + break; + } + + schemaPart = inner; + } + + return schemaPart; + }; + + /** + * Returns description. + * @param {PathItem[]} path path in the schema + * @returns {string | undefined} description + */ + const getDescription = (path) => { + for (const { schema } of path) { + if (schema.cli) { + if (schema.cli.helper) continue; + if (schema.cli.description) return schema.cli.description; + } + if (schema.description) return schema.description; + } + }; + + /** + * Gets negated description. + * @param {PathItem[]} path path in the schema + * @returns {string | undefined} negative description + */ + const getNegatedDescription = (path) => { + for (const { schema } of path) { + if (schema.cli) { + if (schema.cli.helper) continue; + if (schema.cli.negatedDescription) return schema.cli.negatedDescription; + } + } + }; + + /** + * Gets reset description. + * @param {PathItem[]} path path in the schema + * @returns {string | undefined} reset description + */ + const getResetDescription = (path) => { + for (const { schema } of path) { + if (schema.cli) { + if (schema.cli.helper) continue; + if (schema.cli.resetDescription) return schema.cli.resetDescription; + } + } + }; + + /** + * Schema to argument config. + * @param {Schema} schemaPart schema + * @returns {Pick | undefined} partial argument config + */ + const schemaToArgumentConfig = (schemaPart) => { + if (schemaPart.enum) { + return { + type: "enum", + values: schemaPart.enum + }; + } + switch (schemaPart.type) { + case "number": + return { + type: "number" + }; + case "string": + return { + type: schemaPart.absolutePath ? "path" : "string" + }; + case "boolean": + return { + type: "boolean" + }; + } + if (schemaPart.instanceof === "RegExp") { + return { + type: "RegExp" + }; + } + return undefined; + }; + + /** + * Adds the provided path to this object. + * @param {PathItem[]} path path in the schema + * @returns {void} + */ + const addResetFlag = (path) => { + const schemaPath = path[0].path; + const name = pathToArgumentName(`${schemaPath}.reset`); + const description = + getResetDescription(path) || + `Clear all items provided in '${schemaPath}' configuration. ${getDescription( + path + )}`; + flags[name] = { + configs: [ + { + type: "reset", + multiple: false, + description, + path: schemaPath + } + ], + description: undefined, + simpleType: + /** @type {SimpleType} */ + (/** @type {unknown} */ (undefined)), + multiple: /** @type {boolean} */ (/** @type {unknown} */ (undefined)) + }; + }; + + /** + * Adds the provided path to this object. + * @param {PathItem[]} path full path in schema + * @param {boolean} multiple inside of an array + * @returns {number} number of arguments added + */ + const addFlag = (path, multiple) => { + const argConfigBase = schemaToArgumentConfig(path[0].schema); + if (!argConfigBase) return 0; + + const negatedDescription = getNegatedDescription(path); + const name = pathToArgumentName(path[0].path); + /** @type {ArgumentConfig} */ + const argConfig = { + ...argConfigBase, + multiple, + description: getDescription(path), + path: path[0].path + }; + + if (negatedDescription) { + argConfig.negatedDescription = negatedDescription; + } + + if (!flags[name]) { + flags[name] = { + configs: [], + description: undefined, + simpleType: + /** @type {SimpleType} */ + (/** @type {unknown} */ (undefined)), + multiple: /** @type {boolean} */ (/** @type {unknown} */ (undefined)) + }; + } + + if ( + flags[name].configs.some( + (item) => JSON.stringify(item) === JSON.stringify(argConfig) + ) + ) { + return 0; + } + + if ( + flags[name].configs.some( + (item) => item.type === argConfig.type && item.multiple !== multiple + ) + ) { + if (multiple) { + throw new Error( + `Conflicting schema for ${path[0].path} with ${argConfig.type} type (array type must be before single item type)` + ); + } + return 0; + } + + flags[name].configs.push(argConfig); + + return 1; + }; + + // TODO support `not` and `if/then/else` + // TODO support `const`, but we don't use it on our schema + /** + * Returns added arguments. + * @param {Schema} schemaPart the current schema + * @param {string} schemaPath the current path in the schema + * @param {PathItem[]} path all previous visited schemaParts + * @param {string | null} inArray if inside of an array, the path to the array + * @returns {number} added arguments + */ + const traverse = (schemaPart, schemaPath = "", path = [], inArray = null) => { + while (schemaPart.$ref) { + schemaPart = getSchemaPart(schemaPart.$ref); + } + + const repetitions = path.filter(({ schema }) => schema === schemaPart); + if ( + repetitions.length >= 2 || + repetitions.some(({ path }) => path === schemaPath) + ) { + return 0; + } + + if (schemaPart.cli && schemaPart.cli.exclude) return 0; + + /** @type {PathItem[]} */ + const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path]; + + let addedArguments = 0; + + addedArguments += addFlag(fullPath, Boolean(inArray)); + + if (schemaPart.type === "object") { + if (schemaPart.properties) { + for (const property of Object.keys(schemaPart.properties)) { + addedArguments += traverse( + /** @type {Schema} */ + (schemaPart.properties[property]), + schemaPath ? `${schemaPath}.${property}` : property, + fullPath, + inArray + ); + } + } + + return addedArguments; + } + + if (schemaPart.type === "array") { + if (inArray) { + return 0; + } + if (Array.isArray(schemaPart.items)) { + const i = 0; + for (const item of schemaPart.items) { + addedArguments += traverse( + /** @type {Schema} */ + (item), + `${schemaPath}.${i}`, + fullPath, + schemaPath + ); + } + + return addedArguments; + } + + addedArguments += traverse( + /** @type {Schema} */ + (schemaPart.items), + `${schemaPath}[]`, + fullPath, + schemaPath + ); + + if (addedArguments > 0) { + addResetFlag(fullPath); + addedArguments++; + } + + return addedArguments; + } + + const maybeOf = schemaPart.oneOf || schemaPart.anyOf || schemaPart.allOf; + + if (maybeOf) { + const items = maybeOf; + + for (let i = 0; i < items.length; i++) { + addedArguments += traverse( + /** @type {Schema} */ + (items[i]), + schemaPath, + fullPath, + inArray + ); + } + + return addedArguments; + } + + return addedArguments; + }; + + traverse(schema); + + // Summarize flags + for (const name of Object.keys(flags)) { + /** @type {Argument} */ + const argument = flags[name]; + argument.description = argument.configs.reduce((desc, { description }) => { + if (!desc) return description; + if (!description) return desc; + if (desc.includes(description)) return desc; + return `${desc} ${description}`; + }, /** @type {string | undefined} */ (undefined)); + argument.simpleType = + /** @type {SimpleType} */ + ( + argument.configs.reduce((t, argConfig) => { + /** @type {SimpleType} */ + let type = "string"; + switch (argConfig.type) { + case "number": + type = "number"; + break; + case "reset": + case "boolean": + type = "boolean"; + break; + case "enum": { + const values = + /** @type {NonNullable} */ + (argConfig.values); + + if (values.every((v) => typeof v === "boolean")) type = "boolean"; + if (values.every((v) => typeof v === "number")) type = "number"; + break; + } + } + if (t === undefined) return type; + return t === type ? t : "string"; + }, /** @type {SimpleType | undefined} */ (undefined)) + ); + argument.multiple = argument.configs.some((c) => c.multiple); + } + + return flags; +}; + +/** @type {WeakMap} */ +const cliAddedItems = new WeakMap(); + +/** @typedef {string | number} Property */ + +/** + * Gets object and property. + * @param {ObjectConfiguration} config configuration + * @param {string} schemaPath path in the config + * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined + * @returns {{ problem?: LocalProblem, object?: ObjectConfiguration, property?: Property, value?: EXPECTED_OBJECT | EXPECTED_ANY[] }} problem or object with property and value + */ +const getObjectAndProperty = (config, schemaPath, index = 0) => { + if (!schemaPath) return { value: config }; + const parts = schemaPath.split("."); + const property = /** @type {string} */ (parts.pop()); + let current = config; + let i = 0; + for (const part of parts) { + const isArray = part.endsWith("[]"); + const name = isArray ? part.slice(0, -2) : part; + let value = current[name]; + if (isArray) { + if (value === undefined) { + value = {}; + current[name] = [...Array.from({ length: index }), value]; + cliAddedItems.set(current[name], index + 1); + } else if (!Array.isArray(value)) { + return { + problem: { + type: "unexpected-non-array-in-path", + path: parts.slice(0, i).join(".") + } + }; + } else { + let addedItems = cliAddedItems.get(value) || 0; + while (addedItems <= index) { + value.push(undefined); + addedItems++; + } + cliAddedItems.set(value, addedItems); + const x = value.length - addedItems + index; + if (value[x] === undefined) { + value[x] = {}; + } else if (value[x] === null || typeof value[x] !== "object") { + return { + problem: { + type: "unexpected-non-object-in-path", + path: parts.slice(0, i).join(".") + } + }; + } + value = value[x]; + } + } else if (value === undefined) { + value = current[name] = {}; + } else if (value === null || typeof value !== "object") { + return { + problem: { + type: "unexpected-non-object-in-path", + path: parts.slice(0, i).join(".") + } + }; + } + current = value; + i++; + } + const value = current[property]; + if (property.endsWith("[]")) { + const name = property.slice(0, -2); + const value = current[name]; + if (value === undefined) { + current[name] = [...Array.from({ length: index }), undefined]; + cliAddedItems.set(current[name], index + 1); + return { object: current[name], property: index, value: undefined }; + } else if (!Array.isArray(value)) { + current[name] = [value, ...Array.from({ length: index }), undefined]; + cliAddedItems.set(current[name], index + 1); + return { object: current[name], property: index + 1, value: undefined }; + } + let addedItems = cliAddedItems.get(value) || 0; + while (addedItems <= index) { + value.push(undefined); + addedItems++; + } + cliAddedItems.set(value, addedItems); + const x = value.length - addedItems + index; + if (value[x] === undefined) { + value[x] = {}; + } else if (value[x] === null || typeof value[x] !== "object") { + return { + problem: { + type: "unexpected-non-object-in-path", + path: schemaPath + } + }; + } + return { + object: value, + property: x, + value: value[x] + }; + } + return { object: current, property, value }; +}; + +/** + * Updates value using the provided config. + * @param {ObjectConfiguration} config configuration + * @param {string} schemaPath path in the config + * @param {ParsedValue} value parsed value + * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined + * @returns {LocalProblem | null} problem or null for success + */ +const setValue = (config, schemaPath, value, index) => { + const { problem, object, property } = getObjectAndProperty( + config, + schemaPath, + index + ); + if (problem) return problem; + /** @type {ObjectConfiguration} */ + (object)[/** @type {Property} */ (property)] = value; + return null; +}; + +/** + * Process argument config. + * @param {ArgumentConfig} argConfig processing instructions + * @param {ObjectConfiguration} config configuration + * @param {Value} value the value + * @param {number | undefined} index the index if multiple values provided + * @returns {LocalProblem | null} a problem if any + */ +const processArgumentConfig = (argConfig, config, value, index) => { + if (index !== undefined && !argConfig.multiple) { + return { + type: "multiple-values-unexpected", + path: argConfig.path + }; + } + const parsed = parseValueForArgumentConfig(argConfig, value); + if (parsed === undefined) { + return { + type: "invalid-value", + path: argConfig.path, + expected: getExpectedValue(argConfig) + }; + } + const problem = setValue(config, argConfig.path, parsed, index); + if (problem) return problem; + return null; +}; + +/** + * Gets expected value. + * @param {ArgumentConfig} argConfig processing instructions + * @returns {string | undefined} expected message + */ +const getExpectedValue = (argConfig) => { + switch (argConfig.type) { + case "boolean": + return "true | false"; + case "RegExp": + return "regular expression (example: /ab?c*/)"; + case "enum": + return /** @type {NonNullable} */ ( + argConfig.values + ) + .map((v) => `${v}`) + .join(" | "); + case "reset": + return "true (will reset the previous value to an empty array)"; + default: + return argConfig.type; + } +}; + +/** @typedef {null | string | number | boolean | RegExp | EnumValue | []} ParsedValue */ + +const DECIMAL_NUMBER_REGEXP = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i; + +/** + * Parses value for argument config. + * @param {ArgumentConfig} argConfig processing instructions + * @param {Value} value the value + * @returns {ParsedValue | undefined} parsed value + */ +const parseValueForArgumentConfig = (argConfig, value) => { + switch (argConfig.type) { + case "string": + if (typeof value === "string") { + return value; + } + break; + case "path": + if (typeof value === "string") { + return path.resolve(value); + } + break; + case "number": + if (typeof value === "number") return value; + if (typeof value === "string" && DECIMAL_NUMBER_REGEXP.test(value)) { + const n = Number(value); + if (!Number.isNaN(n)) return n; + } + break; + case "boolean": + if (typeof value === "boolean") return value; + if (value === "true") return true; + if (value === "false") return false; + break; + case "RegExp": + if (value instanceof RegExp) return value; + if (typeof value === "string") { + // cspell:word yugi + const match = /^\/(.*)\/([yugi]*)$/.exec(value); + if (match && !/[^\\]\//.test(match[1])) { + return new RegExp(match[1], match[2]); + } + } + break; + case "enum": { + const values = + /** @type {EnumValue[]} */ + (argConfig.values); + if (values.includes(/** @type {Exclude} */ (value))) { + return value; + } + for (const item of values) { + if (`${item}` === value) return item; + } + break; + } + case "reset": + if (value === true) return []; + break; + } +}; + +/** @typedef {Record} Values */ + +/** + * Processes the provided arg. + * @param {Flags} args object of arguments + * @param {ObjectConfiguration} config configuration + * @param {Values} values object with values + * @returns {Problem[] | null} problems or null for success + */ +const processArguments = (args, config, values) => { + /** @type {Problem[]} */ + const problems = []; + for (const key of Object.keys(values)) { + const arg = args[key]; + if (!arg) { + problems.push({ + type: "unknown-argument", + path: "", + argument: key + }); + continue; + } + /** + * Processes the provided value. + * @param {Value} value value + * @param {number | undefined} i index + */ + const processValue = (value, i) => { + /** @type {Problem[]} */ + const currentProblems = []; + for (const argConfig of arg.configs) { + const problem = processArgumentConfig(argConfig, config, value, i); + if (!problem) { + return; + } + currentProblems.push({ + ...problem, + argument: key, + value, + index: i + }); + } + problems.push(...currentProblems); + }; + const value = values[key]; + if (Array.isArray(value)) { + for (let i = 0; i < value.length; i++) { + processValue(value[i], i); + } + } else { + processValue(value, undefined); + } + } + if (problems.length === 0) return null; + return problems; +}; + +/** + * Checks whether this object is color supported. + * @returns {boolean} true when colors supported, otherwise false + */ +const isColorSupported = () => { + const { env = {}, argv = [], platform = "" } = process; + + const isDisabled = "NO_COLOR" in env || argv.includes("--no-color"); + const isForced = "FORCE_COLOR" in env || argv.includes("--color"); + const isWindows = platform === "win32"; + const isDumbTerminal = env.TERM === "dumb"; + + const isCompatibleTerminal = tty.isatty(1) && env.TERM && !isDumbTerminal; + + const isCI = + "CI" in env && + ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env); + + return ( + !isDisabled && + (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI) + ); +}; + +/** + * Returns result. + * @param {number} index index + * @param {string} string string + * @param {string} close close + * @param {string=} replace replace + * @param {string=} head head + * @param {string=} tail tail + * @param {number=} next next + * @returns {string} result + */ +const replaceClose = ( + index, + string, + close, + replace, + head = string.slice(0, Math.max(0, index)) + replace, + tail = string.slice(Math.max(0, index + close.length)), + next = tail.indexOf(close) +) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace)); + +/** + * Returns result. + * @param {number} index index to replace + * @param {string} string string + * @param {string} open open string + * @param {string} close close string + * @param {string=} replace extra replace + * @returns {string} result + */ +const clearBleed = (index, string, open, close, replace) => + index < 0 + ? open + string + close + : open + replaceClose(index, string, close, replace) + close; + +/** @typedef {(value: EXPECTED_ANY) => string} PrintFunction */ + +/** + * Returns function to create color. + * @param {string} open open string + * @param {string} close close string + * @param {string=} replace extra replace + * @param {number=} at at + * @returns {PrintFunction} function to create color + */ +const filterEmpty = + (open, close, replace = open, at = open.length + 1) => + (string) => + string || !(string === "" || string === undefined) + ? clearBleed(`${string}`.indexOf(close, at), string, open, close, replace) + : ""; + +/** + * Returns result. + * @param {number} open open code + * @param {number} close close code + * @param {string=} replace extra replace + * @returns {PrintFunction} result + */ +const init = (open, close, replace) => + filterEmpty(`\u001B[${open}m`, `\u001B[${close}m`, replace); + +/** + * Defines the colors type used by this module. + * @typedef {{ reset: PrintFunction, bold: PrintFunction, dim: PrintFunction, italic: PrintFunction, underline: PrintFunction, inverse: PrintFunction, hidden: PrintFunction, strikethrough: PrintFunction, black: PrintFunction, red: PrintFunction, green: PrintFunction, yellow: PrintFunction, blue: PrintFunction, magenta: PrintFunction, cyan: PrintFunction, white: PrintFunction, gray: PrintFunction, bgBlack: PrintFunction, bgRed: PrintFunction, bgGreen: PrintFunction, bgYellow: PrintFunction, bgBlue: PrintFunction, bgMagenta: PrintFunction, bgCyan: PrintFunction, bgWhite: PrintFunction, blackBright: PrintFunction, redBright: PrintFunction, greenBright: PrintFunction, yellowBright: PrintFunction, blueBright: PrintFunction, magentaBright: PrintFunction, cyanBright: PrintFunction, whiteBright: PrintFunction, bgBlackBright: PrintFunction, bgRedBright: PrintFunction, bgGreenBright: PrintFunction, bgYellowBright: PrintFunction, bgBlueBright: PrintFunction, bgMagentaBright: PrintFunction, bgCyanBright: PrintFunction, bgWhiteBright: PrintFunction }} Colors + */ + +/** + * Defines the colors options type used by this module. + * @typedef {object} ColorsOptions + * @property {boolean=} useColor force use colors + */ + +/** + * Creates a colors from the provided colors option. + * @param {ColorsOptions=} options options + * @returns {Colors} colors + */ +const createColors = ({ useColor = isColorSupported() } = {}) => ({ + reset: useColor ? init(0, 0) : String, + bold: useColor ? init(1, 22, "\u001B[22m\u001B[1m") : String, + dim: useColor ? init(2, 22, "\u001B[22m\u001B[2m") : String, + italic: useColor ? init(3, 23) : String, + underline: useColor ? init(4, 24) : String, + inverse: useColor ? init(7, 27) : String, + hidden: useColor ? init(8, 28) : String, + strikethrough: useColor ? init(9, 29) : String, + black: useColor ? init(30, 39) : String, + red: useColor ? init(31, 39) : String, + green: useColor ? init(32, 39) : String, + yellow: useColor ? init(33, 39) : String, + blue: useColor ? init(34, 39) : String, + magenta: useColor ? init(35, 39) : String, + cyan: useColor ? init(36, 39) : String, + white: useColor ? init(37, 39) : String, + gray: useColor ? init(90, 39) : String, + bgBlack: useColor ? init(40, 49) : String, + bgRed: useColor ? init(41, 49) : String, + bgGreen: useColor ? init(42, 49) : String, + bgYellow: useColor ? init(43, 49) : String, + bgBlue: useColor ? init(44, 49) : String, + bgMagenta: useColor ? init(45, 49) : String, + bgCyan: useColor ? init(46, 49) : String, + bgWhite: useColor ? init(47, 49) : String, + blackBright: useColor ? init(90, 39) : String, + redBright: useColor ? init(91, 39) : String, + greenBright: useColor ? init(92, 39) : String, + yellowBright: useColor ? init(93, 39) : String, + blueBright: useColor ? init(94, 39) : String, + magentaBright: useColor ? init(95, 39) : String, + cyanBright: useColor ? init(96, 39) : String, + whiteBright: useColor ? init(97, 39) : String, + bgBlackBright: useColor ? init(100, 49) : String, + bgRedBright: useColor ? init(101, 49) : String, + bgGreenBright: useColor ? init(102, 49) : String, + bgYellowBright: useColor ? init(103, 49) : String, + bgBlueBright: useColor ? init(104, 49) : String, + bgMagentaBright: useColor ? init(105, 49) : String, + bgCyanBright: useColor ? init(106, 49) : String, + bgWhiteBright: useColor ? init(107, 49) : String +}); + +module.exports.createColors = createColors; +module.exports.getArguments = getArguments; +module.exports.isColorSupported = isColorSupported; +module.exports.processArguments = processArguments; Index: frontend/node_modules/webpack/lib/config/browserslistTargetHandler.js =================================================================== --- frontend/node_modules/webpack/lib/config/browserslistTargetHandler.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/config/browserslistTargetHandler.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,390 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sergey Melyukov @smelukov +*/ + +"use strict"; + +const path = require("path"); +const browserslist = require("browserslist"); + +/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */ +/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */ +/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */ + +// [[C:]/path/to/config][:env] +const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i; + +/** + * Returns selected browsers. + * @param {string | null | undefined} input input string + * @param {string} context the context directory + * @returns {string[] | undefined} selected browsers + */ +const load = (input, context) => { + // browserslist:path-to-config + // browserslist:path-to-config:env + if (input && path.isAbsolute(input)) { + const [, configPath, env] = inputRx.exec(input) || []; + + const config = browserslist.loadConfig({ + config: configPath, + env + }); + + return browserslist(config, { env }); + } + + const env = input || undefined; + + const config = browserslist.loadConfig({ + path: context, + env + }); + + // browserslist + // browserslist:env + if (config) { + try { + return browserslist(config, { env, throwOnMissing: true }); + } catch (_err) { + // Nothing, no `env` was found in browserslist, maybe input is `queries` + } + } + + // browserslist:query + if (env) { + return browserslist(env); + } +}; + +/** + * Returns target properties. + * @param {string[]} browsers supported browsers list + * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties + */ +const resolve = (browsers) => { + /** + * Checks all against a version number + * @param {Record} versions first supported version + * @returns {boolean} true if supports + */ + const rawChecker = (versions) => + browsers.every((v) => { + const [name, parsedVersion] = v.split(" "); + if (!name) return false; + const requiredVersion = versions[name]; + if (!requiredVersion) return false; + const [parsedMajor, parserMinor] = + // safari TP supports all features for normal safari + parsedVersion === "TP" + ? [Infinity, Infinity] + : parsedVersion.includes("-") + ? parsedVersion.split("-")[0].split(".") + : parsedVersion.split("."); + if (typeof requiredVersion === "number") { + return Number(parsedMajor) >= requiredVersion; + } + return requiredVersion[0] === Number(parsedMajor) + ? Number(parserMinor) >= requiredVersion[1] + : Number(parsedMajor) > requiredVersion[0]; + }); + const anyNode = browsers.some((b) => b.startsWith("node ")); + const anyBrowser = browsers.some((b) => /^(?!node)/.test(b)); + const browserProperty = !anyBrowser ? false : anyNode ? null : true; + const nodeProperty = !anyNode ? false : anyBrowser ? null : true; + + return { + /* eslint-disable camelcase */ + const: rawChecker({ + chrome: 49, + and_chr: 49, + edge: 12, + // Prior to Firefox 13, const is implemented, but re-assignment is not failing. + // Prior to Firefox 46, a TypeError was thrown on redeclaration instead of a SyntaxError. + firefox: 36, + and_ff: 36, + // Not supported in for-in and for-of loops + // ie: Not supported + opera: 36, + op_mob: 36, + safari: [10, 0], + ios_saf: [10, 0], + // Before 5.0 supported correctly in strict mode, otherwise supported without block scope + samsung: [5, 0], + android: 37, + and_qq: [10, 4], + // Supported correctly in strict mode, otherwise supported without block scope + baidu: [13, 18], + and_uc: [12, 12], + kaios: [2, 5], + node: [6, 0] + }), + methodShorthand: rawChecker({ + chrome: 47, + and_chr: 47, + edge: 12, + firefox: 34, + and_ff: 34, + // ie: Not supported, + opera: 34, + op_mob: 34, + safari: 9, + ios_saf: 9, + samsung: 5, + android: 47, + // baidu: Not tracked, + and_qq: [14, 9], + and_uc: [15, 5], + kaios: [2, 5], + node: [4, 9] + }), + arrowFunction: rawChecker({ + chrome: 45, + and_chr: 45, + edge: 12, + // The initial implementation of arrow functions in Firefox made them automatically strict. This has been changed as of Firefox 24. The use of 'use strict'; is now required. + // Prior to Firefox 39, a line terminator (\\n) was incorrectly allowed after arrow function arguments. This has been fixed to conform to the ES2015 specification and code like () \\n => {} will now throw a SyntaxError in this and later versions. + firefox: 39, + and_ff: 39, + // ie: Not supported, + opera: 32, + op_mob: 32, + safari: 10, + ios_saf: 10, + samsung: [5, 0], + android: 45, + and_qq: [10, 4], + baidu: [7, 12], + and_uc: [12, 12], + kaios: [2, 5], + node: [6, 0] + }), + forOf: rawChecker({ + chrome: 38, + and_chr: 38, + edge: 12, + // Prior to Firefox 51, using the for...of loop construct with the const keyword threw a SyntaxError ("missing = in const declaration"). + firefox: 51, + and_ff: 51, + // ie: Not supported, + opera: 25, + op_mob: 25, + safari: 7, + ios_saf: 7, + samsung: [3, 0], + android: 38, + and_qq: [10, 4], + // baidu: Unknown support + and_uc: [12, 12], + kaios: [3, 0], + node: [0, 12] + }), + destructuring: rawChecker({ + chrome: 49, + and_chr: 49, + edge: 14, + firefox: 41, + and_ff: 41, + // ie: Not supported, + opera: 36, + op_mob: 36, + safari: 8, + ios_saf: 8, + samsung: [5, 0], + android: 49, + and_qq: [10, 4], + // baidu: Unknown support + and_uc: [12, 12], + kaios: [2, 5], + node: [6, 0] + }), + bigIntLiteral: rawChecker({ + chrome: 67, + and_chr: 67, + edge: 79, + firefox: 68, + and_ff: 68, + // ie: Not supported, + opera: 54, + op_mob: 48, + safari: 14, + ios_saf: 14, + samsung: [9, 2], + android: 67, + and_qq: [13, 1], + baidu: [13, 18], + and_uc: [15, 5], + kaios: [3, 0], + node: [10, 4] + }), + // Support syntax `import` and `export` and no limitations and bugs on Node.js + // Not include `export * as namespace` + module: rawChecker({ + chrome: 61, + and_chr: 61, + edge: 16, + firefox: 60, + and_ff: 60, + // ie: Not supported, + opera: 48, + op_mob: 45, + safari: [10, 1], + ios_saf: [10, 3], + samsung: [8, 0], + android: 61, + and_qq: [10, 4], + baidu: [13, 18], + and_uc: [15, 5], + kaios: [3, 0], + node: [12, 17] + }), + dynamicImport: rawChecker({ + chrome: 63, + and_chr: 63, + edge: 79, + firefox: 67, + and_ff: 67, + // ie: Not supported + opera: 50, + op_mob: 46, + safari: [11, 1], + ios_saf: [11, 3], + samsung: [8, 2], + android: 63, + and_qq: [10, 4], + baidu: [13, 18], + and_uc: [15, 5], + kaios: [3, 0], + node: [12, 17] + }), + dynamicImportInWorker: rawChecker({ + chrome: 80, + and_chr: 80, + edge: 80, + firefox: 114, + and_ff: 114, + // ie: Not supported + opera: 67, + op_mob: 57, + safari: [15, 0], + ios_saf: [15, 0], + samsung: [13, 0], + android: 80, + and_qq: [10, 4], + baidu: [13, 18], + and_uc: [15, 5], + kaios: [3, 0], + node: [12, 17] + }), + // browserslist does not have info about globalThis + // so this is based on mdn-browser-compat-data + globalThis: rawChecker({ + chrome: 71, + and_chr: 71, + edge: 79, + firefox: 65, + and_ff: 65, + // ie: Not supported, + opera: 58, + op_mob: 50, + safari: [12, 1], + ios_saf: [12, 2], + samsung: [10, 1], + android: 71, + and_qq: [13, 1], + // baidu: Unknown support + and_uc: [15, 5], + kaios: [3, 0], + node: 12 + }), + optionalChaining: rawChecker({ + chrome: 80, + and_chr: 80, + edge: 80, + firefox: 74, + and_ff: 79, + // ie: Not supported, + opera: 67, + op_mob: 64, + safari: [13, 1], + ios_saf: [13, 4], + samsung: 13, + android: 80, + and_qq: [13, 1], + // baidu: Not supported + and_uc: [15, 5], + kaios: [3, 0], + node: 14 + }), + templateLiteral: rawChecker({ + chrome: 41, + and_chr: 41, + edge: 13, + firefox: 34, + and_ff: 34, + // ie: Not supported, + opera: 29, + op_mob: 64, + safari: [9, 1], + ios_saf: 9, + samsung: 4, + android: 41, + and_qq: [10, 4], + baidu: [7, 12], + and_uc: [12, 12], + kaios: [2, 5], + node: 4 + }), + asyncFunction: rawChecker({ + chrome: 55, + and_chr: 55, + edge: 15, + firefox: 52, + and_ff: 52, + // ie: Not supported, + opera: 42, + op_mob: 42, + safari: 11, + ios_saf: 11, + samsung: [6, 2], + android: 55, + and_qq: [10, 4], + baidu: [13, 18], + and_uc: [12, 12], + kaios: 3, + node: [7, 6] + }), + /* eslint-enable camelcase */ + browser: browserProperty, + electron: false, + node: nodeProperty, + nwjs: false, + web: browserProperty, + webworker: false, + + document: browserProperty, + fetchWasm: browserProperty, + global: nodeProperty, + importScripts: false, + importScriptsInWorker: Boolean(browserProperty), + nodeBuiltins: nodeProperty, + nodePrefixForCoreModules: + nodeProperty && + !browsers.some((b) => b.startsWith("node 15")) && + rawChecker({ + node: [14, 18] + }), + importMetaDirnameAndFilename: + nodeProperty && + rawChecker({ + node: [22, 16] + }), + require: nodeProperty + }; +}; + +module.exports = { + load, + resolve +}; Index: frontend/node_modules/webpack/lib/config/defaults.js =================================================================== --- frontend/node_modules/webpack/lib/config/defaults.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/config/defaults.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2320 @@ +/* + 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 { cleverMerge } = require("../util/cleverMerge"); +const { + getDefaultTarget, + getTargetProperties, + getTargetsProperties +} = require("./target"); + +/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptionsNormalized */ +/** @typedef {import("../../declarations/WebpackOptions").Context} Context */ +/** @typedef {import("../../declarations/WebpackOptions").DevTool} Devtool */ +/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */ +/** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */ +/** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */ +/** @typedef {import("../../declarations/WebpackOptions").Environment} Environment */ +/** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */ +/** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */ +/** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */ +/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */ +/** @typedef {import("../../declarations/WebpackOptions").FileCacheOptions} FileCacheOptions */ +/** @typedef {import("../../declarations/WebpackOptions").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */ +/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */ +/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */ +/** @typedef {import("../../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */ +/** @typedef {import("../../declarations/WebpackOptions").Library} Library */ +/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */ +/** @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").HashDigest} HashDigest */ +/** @typedef {import("../../declarations/WebpackOptions").HashDigestLength} HashDigestLength */ +/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */ +/** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */ +/** @typedef {import("../../declarations/WebpackOptions").OptimizationNormalized} Optimization */ +/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */ +/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */ +/** @typedef {import("../../declarations/WebpackOptions").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */ +/** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */ +/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */ +/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */ +/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */ +/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */ +/** @typedef {import("../Module")} Module */ +/** @typedef {import("../javascript/EnableChunkLoadingPlugin").ChunkLoadingTypes} ChunkLoadingTypes */ +/** @typedef {import("../wasm/EnableWasmLoadingPlugin").WasmLoadingTypes} WasmLoadingTypes */ +/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */ +/** @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 }} RecursiveNonNullable + */ + +/** + * Defines the shared type used by this module. + * @typedef {Output & { + * uniqueName: NonNullable, + * filename: NonNullable, + * cssFilename: NonNullable, + * chunkFilename: NonNullable, + * cssChunkFilename: NonNullable, + * hotUpdateChunkFilename: NonNullable, + * hotUpdateGlobal: NonNullable, + * assetModuleFilename: NonNullable, + * webassemblyModuleFilename: NonNullable, + * sourceMapFilename: NonNullable, + * hotUpdateMainFilename: NonNullable, + * devtoolNamespace: NonNullable, + * publicPath: NonNullable, + * workerPublicPath: NonNullable, + * workerWasmLoading: NonNullable, + * workerChunkLoading: NonNullable, + * chunkFormat: NonNullable, + * module: NonNullable, + * asyncChunks: NonNullable, + * charset: NonNullable, + * iife: NonNullable, + * globalObject: NonNullable, + * scriptType: NonNullable, + * path: NonNullable, + * pathinfo: NonNullable, + * hashFunction: NonNullable, + * hashDigest: NonNullable, + * hashDigestLength: NonNullable, + * chunkLoadTimeout: NonNullable, + * chunkLoading: NonNullable, + * chunkLoadingGlobal: NonNullable, + * compareBeforeEmit: NonNullable, + * strictModuleErrorHandling: NonNullable, + * strictModuleExceptionHandling: NonNullable, + * importFunctionName: NonNullable, + * importMetaName: NonNullable, + * environment: RecursiveNonNullable, + * crossOriginLoading: NonNullable, + * wasmLoading: NonNullable, + * }} OutputNormalizedWithDefaults + */ + +/** + * Defines the shared type used by this module. + * @typedef {SnapshotOptions & { + * managedPaths: NonNullable, + * unmanagedPaths: NonNullable, + * immutablePaths: NonNullable, + * resolveBuildDependencies: NonNullable, + * buildDependencies: NonNullable, + * module: NonNullable, + * resolve: NonNullable, + * }} SnapshotNormalizedWithDefaults + */ + +/** + * Defines the shared type used by this module. + * @typedef {Optimization & { + * runtimeChunk: NonNullable, + * splitChunks: NonNullable, + * mergeDuplicateChunks: NonNullable, + * removeAvailableModules: NonNullable, + * removeEmptyChunks: NonNullable, + * flagIncludedChunks: NonNullable, + * moduleIds: NonNullable, + * chunkIds: NonNullable, + * sideEffects: NonNullable, + * providedExports: NonNullable, + * usedExports: NonNullable, + * mangleExports: NonNullable, + * innerGraph: NonNullable, + * concatenateModules: NonNullable, + * avoidEntryIife: NonNullable, + * emitOnErrors: NonNullable, + * checkWasmTypes: NonNullable, + * mangleWasmImports: NonNullable, + * portableRecords: NonNullable, + * realContentHash: NonNullable, + * minimize: NonNullable, + * minimizer: NonNullable>, + * nodeEnv: NonNullable, + * }} OptimizationNormalizedWithDefaults + */ + +/** + * Defines the shared type used by this module. + * @typedef {ExternalsPresets & { + * web: NonNullable, + * node: NonNullable, + * nwjs: NonNullable, + * electron: NonNullable, + * electronMain: NonNullable, + * electronPreload: NonNullable, + * electronRenderer: NonNullable, + * }} ExternalsPresetsNormalizedWithDefaults + */ + +/** + * Defines the shared type used by this module. + * @typedef {InfrastructureLogging & { + * stream: NonNullable, + * level: NonNullable, + * debug: NonNullable, + * colors: NonNullable, + * appendOnly: NonNullable, + * }} InfrastructureLoggingNormalizedWithDefaults + */ + +/** + * Defines the webpack options normalized with base defaults type used by this module. + * @typedef {WebpackOptionsNormalized & { context: NonNullable } & { infrastructureLogging: InfrastructureLoggingNormalizedWithDefaults }} WebpackOptionsNormalizedWithBaseDefaults + */ + +/** + * Defines the webpack options normalized with defaults type used by this module. + * @typedef {WebpackOptionsNormalizedWithBaseDefaults & { target: NonNullable } & { output: OutputNormalizedWithDefaults } & { optimization: OptimizationNormalizedWithDefaults } & { devtool: NonNullable } & { stats: NonNullable } & { node: NonNullable } & { profile: NonNullable } & { parallelism: NonNullable } & { snapshot: SnapshotNormalizedWithDefaults } & { externalsPresets: ExternalsPresetsNormalizedWithDefaults } & { externalsType: NonNullable } & { watch: NonNullable } & { performance: NonNullable } & { recordsInputPath: NonNullable } & { recordsOutputPath: NonNullable } & { dotenv: NonNullable }} 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"]) + ); + } + } + + F( + options, + "devtool", + () => + /** @type {Devtool} */ ( + development + ? [ + options.experiments.css + ? { + type: "css", + use: "source-map" + } + : undefined, + { + type: "javascript", + use: "eval" + } + ].filter(Boolean) + : false + ) + ); + + D(options, "watch", false); + D(options, "profile", false); + D(options, "parallelism", 100); + D(options, "recordsInputPath", false); + D(options, "recordsOutputPath", false); + + applyExperimentsDefaults(options.experiments, { + production, + development, + targetProperties + }); + + const futureDefaults = + /** @type {NonNullable} */ + (options.experiments.futureDefaults); + + F(options, "validate", () => !(futureDefaults === true && production)); + + 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} */ + (options.experiments.outputModule), + development, + entry: options.entry, + futureDefaults, + asyncWebAssembly: + /** @type {NonNullable} */ + (options.experiments.asyncWebAssembly) + }); + + applyModuleDefaults(options.module, { + cache, + hashSalt: /** @type {NonNullable} */ ( + options.output.hashSalt + ), + hashFunction: /** @type {NonNullable} */ ( + options.output.hashFunction + ), + syncWebAssembly: + /** @type {NonNullable} */ + (options.experiments.syncWebAssembly), + asyncWebAssembly: + /** @type {NonNullable} */ + (options.experiments.asyncWebAssembly), + css: + /** @type {NonNullable} */ + (options.experiments.css), + html: + /** @type {NonNullable} */ + (options.experiments.html), + typescript: + /** @type {NonNullable} */ + (options.experiments.typescript), + deferImport: + /** @type {NonNullable} */ + (options.experiments.deferImport), + sourceImport: + /** @type {NonNullable} */ + (options.experiments.sourceImport), + futureDefaults, + isNode: targetProperties && targetProperties.node === true, + uniqueName: /** @type {string} */ (options.output.uniqueName), + targetProperties, + mode: options.mode, + outputModule: + /** @type {NonNullable} */ + (options.output.module), + library: options.output.library + }); + + applyExternalsPresetsDefaults(options.externalsPresets, { + targetProperties, + buildHttp: Boolean(options.experiments.buildHttp), + outputModule: + /** @type {NonNullable} */ + (options.output.module) + }); + + applyLoaderDefaults( + /** @type {NonNullable} */ ( + options.loader + ), + { targetProperties, environment: options.output.environment } + ); + + 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} */ + (options.experiments.futureDefaults), + outputModule: + /** @type {NonNullable} */ + (options.output.module), + targetProperties + }); + + F(options, "performance", () => + production && + targetProperties && + (targetProperties.browser || targetProperties.browser === null) + ? {} + : false + ); + applyPerformanceDefaults( + /** @type {NonNullable} */ + (options.performance), + { + production + } + ); + + applyOptimizationDefaults(options.optimization, { + development, + production, + css: + /** @type {NonNullable} */ + (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 {NonNullable} */ + (options.experiments.css), + typescript: + /** @type {NonNullable} */ + (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, + nwjs: targetProperties.nwjs, + electron: targetProperties.electron + } + }; +}; + +/** + * 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 + * @returns {void} + */ +const applyExperimentsDefaults = ( + experiments, + { production, development, targetProperties } +) => { + D(experiments, "futureDefaults", false); + D(experiments, "backCompat", !experiments.futureDefaults); + // TODO do we need sync web assembly in webpack@6? + D(experiments, "syncWebAssembly", false); + D(experiments, "asyncWebAssembly", experiments.futureDefaults); + D(experiments, "outputModule", false); + D(experiments, "lazyCompilation", undefined); + D(experiments, "buildHttp", undefined); + D(experiments, "cacheUnaffected", experiments.futureDefaults); + D(experiments, "deferImport", false); + D(experiments, "sourceImport", false); + F(experiments, "css", () => (experiments.futureDefaults ? true : undefined)); + F(experiments, "html", () => (experiments.futureDefaults ? true : undefined)); + F(experiments, "typescript", () => + experiments.futureDefaults ? true : undefined + ); + + 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} */ + (cache.cacheDirectory), + /** @type {NonNullable} */ (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} */ + (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, "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} */ + (module.parser[ASSET_MODULE_TYPE]), + "dataUrlCondition", + () => ({}) + ); + if ( + typeof ( + /** @type {NonNullable} */ + (module.parser[ASSET_MODULE_TYPE]).dataUrlCondition + ) === "object" + ) { + D( + /** @type {NonNullable} */ + (module.parser[ASSET_MODULE_TYPE]).dataUrlCondition, + "maxSize", + 8096 + ); + } + + F(module.parser, "javascript", () => ({})); + F(module.parser, JSON_MODULE_TYPE, () => ({})); + D( + /** @type {NonNullable} */ + (module.parser[JSON_MODULE_TYPE]), + "exportsDepth", + mode === "development" ? 1 : Infinity + ); + + applyJavascriptParserOptionsDefaults( + /** @type {NonNullable} */ + (module.parser.javascript), + { + futureDefaults, + deferImport, + sourceImport, + isNode, + outputModule, + library, + typescript + } + ); + + F(module.generator, "json", () => ({})); + + applyJsonGeneratorOptionsDefaults( + /** @type {NonNullable} */ + (module.generator.json) + ); + + if (css) { + F(module.parser, CSS_MODULE_TYPE, () => ({})); + + D( + /** @type {NonNullable} */ + (module.parser[CSS_MODULE_TYPE]), + "import", + true + ); + D( + /** @type {NonNullable} */ + (module.parser[CSS_MODULE_TYPE]), + "url", + true + ); + D( + /** @type {NonNullable} */ + (module.parser[CSS_MODULE_TYPE]), + "namedExports", + true + ); + + for (const type of [ + CSS_MODULE_TYPE_AUTO, + CSS_MODULE_TYPE_MODULE, + CSS_MODULE_TYPE_GLOBAL + ]) { + F(module.parser, type, () => ({})); + + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.parser[type]), + "animation", + true + ); + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.parser[type]), + "container", + true + ); + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.parser[type]), + "customIdents", + true + ); + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.parser[type]), + "dashedIdents", + true + ); + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.parser[type]), + "function", + true + ); + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.parser[type]), + "grid", + true + ); + } + + F(module.generator, CSS_MODULE_TYPE, () => ({})); + + applyCssGeneratorOptionsDefaults( + /** @type {NonNullable} */ + (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 | NonNullable | NonNullable} */ + (module.generator[type]), + "localIdentName", + localIdentName + ); + + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.generator[type]), + "localIdentHashSalt", + localIdentHashSalt + ); + + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.generator[type]), + "localIdentHashFunction", + hashFunction + ); + + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.generator[type]), + "localIdentHashDigest", + localIdentHashDigest + ); + + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (module.generator[type]), + "localIdentHashDigestLength", + localIdentHashDigestLength + ); + + D( + /** @type {NonNullable | NonNullable | NonNullable} */ + (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, () => ({})); + } + + 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.`) — 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 + }); + if (css) { + // Inline `` block in an HTML module. The + * tag's content is fed into webpack's CSS pipeline as a virtual CSS module + * with `exportType: "text"` so `url()` and `\@import` references are + * resolved relative to the HTML file. At render time the original content + * range is replaced with the processed CSS text read from the CSS module's + * code generation data. + */ +class HtmlInlineStyleDependency extends ModuleDependency { + /** + * Creates an instance of HtmlInlineStyleDependency. + * @param {string} request virtual request resolving to the inline CSS (data URI) + * @param {Range} range range of the inline CSS content (between ``) + */ + constructor(request, range) { + super(request); + this.range = range; + } + + get type() { + return "html inline style"; + } + + get category() { + return "html-style"; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + super.deserialize(context); + } +} + +HtmlInlineStyleDependency.Template = class HtmlInlineStyleDependencyTemplate extends ( + ModuleDependency.Template +) { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Dependency} dependency the dependency for which the template should be applied + * @param {ReplaceSource} source the current replace source which can be modified + * @param {DependencyTemplateContext} templateContext the context object + * @returns {void} + */ + apply(dependency, source, { moduleGraph, runtime, codeGenerationResults }) { + const dep = /** @type {HtmlInlineStyleDependency} */ (dependency); + const module = /** @type {Module} */ (moduleGraph.getModule(dep)); + + /** @type {string} */ + let cssText = ""; + + if (module) { + const codeGen = + /** @type {CodeGenerationResults} */ + (codeGenerationResults).get(module, runtime); + const cssTextSource = codeGen.sources.get(CSS_TEXT_TYPE); + if (cssTextSource) { + cssText = /** @type {string} */ (cssTextSource.source()); + } + } + + source.replace(dep.range[0], dep.range[1] - 1, cssText); + } +}; + +makeSerializable( + HtmlInlineStyleDependency, + "webpack/lib/dependencies/HtmlInlineStyleDependency" +); + +module.exports = HtmlInlineStyleDependency; Index: frontend/node_modules/webpack/lib/dependencies/HtmlScriptSrcDependency.js =================================================================== --- frontend/node_modules/webpack/lib/dependencies/HtmlScriptSrcDependency.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/webpack/lib/dependencies/HtmlScriptSrcDependency.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,557 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php +*/ + +"use strict"; + +const { + CSS_IMPORT_TYPE, + CSS_TYPE, + JAVASCRIPT_TYPE +} = require("../ModuleSourceTypeConstants"); +const makeSerializable = require("../util/makeSerializable"); +const CssUrlDependency = require("./CssUrlDependency"); +const ModuleDependency = require("./ModuleDependency"); + +/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */ +/** @typedef {import("../Chunk")} Chunk */ +/** @typedef {import("../ChunkGraph")} ChunkGraph */ +/** @typedef {import("../Dependency")} Dependency */ +/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */ +/** @typedef {import("../Entrypoint")} Entrypoint */ +/** @typedef {import("../javascript/JavascriptParser").Range} Range */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */ +/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */ + +/** @typedef {"script-classic" | "script-module" | "modulepreload" | "stylesheet"} HtmlScriptElementKind */ + +class HtmlScriptSrcDependency extends ModuleDependency { + /** + * Creates an instance of HtmlScriptSrcDependency. + * @param {string} request request + * @param {Range} range range of the attribute value in the source + * @param {string} entryName name of the entry this script src is bundled into + * @param {string=} category dependency category used for resolving and grouping + * @param {HtmlScriptElementKind=} elementKind shape of the originating HTML element; used when expanding sibling tags for split/runtime chunks + * @param {number=} tagStart position of the opening `<` of the originating tag in the source; sibling tags emitted for additional entry chunks are inserted right before this + * @param {number=} tagOpenEnd position of the character immediately after the opening tag's `>` in the source; combined with `tagStart` this lets the template clone the original opening tag verbatim (preserving attributes like `nonce`, `crossorigin`, `referrerpolicy`, `defer`, `async`) when generating sibling tags + */ + constructor( + request, + range, + entryName, + category, + elementKind, + tagStart, + tagOpenEnd + ) { + super(request); + this.range = range; + this.entryName = entryName; + /** @type {string} */ + this._category = category || "commonjs"; + /** @type {HtmlScriptElementKind} */ + this.elementKind = elementKind || "script-classic"; + /** @type {number} */ + this.tagStart = tagStart === undefined ? -1 : tagStart; + /** @type {number} */ + this.tagOpenEnd = tagOpenEnd === undefined ? -1 : tagOpenEnd; + } + + get type() { + return "html script src"; + } + + get category() { + return this._category; + } + + /** + * Serializes this instance into the provided serializer context. + * @param {ObjectSerializerContext} context context + */ + serialize(context) { + const { write } = context; + write(this.entryName); + write(this._category); + write(this.elementKind); + write(this.tagStart); + write(this.tagOpenEnd); + super.serialize(context); + } + + /** + * Restores this instance from the provided deserializer context. + * @param {ObjectDeserializerContext} context context + */ + deserialize(context) { + const { read } = context; + this.entryName = read(); + this._category = read(); + this.elementKind = read(); + this.tagStart = read(); + this.tagOpenEnd = read(); + super.deserialize(context); + } +} + +/** + * @param {Chunk} chunk a chunk + * @param {import("../Compilation")} compilation compilation + * @param {"javascript" | "css"} contentHashType which content hash to plug into the filename template + * @returns {string} chunk filename path (no public-path prefix) + */ +const getChunkFilename = (chunk, compilation, contentHashType) => { + const outputOptions = compilation.outputOptions; + let filenameTemplate; + if (contentHashType === "css") { + // For a CSS-typed chunk, use the same template the CSS pipeline + // will use when it actually emits the `.css` file, so the `` URL we write into the HTML matches the + // asset on disk. + filenameTemplate = + require("../css/CssModulesPlugin").getChunkFilenameTemplate( + chunk, + outputOptions + ); + } else { + filenameTemplate = + chunk.filenameTemplate || + (chunk.canBeInitial() + ? outputOptions.filename + : outputOptions.chunkFilename); + } + + return compilation.getPath(filenameTemplate, { + chunk, + contentHashType + }); +}; + +/** + * @param {Entrypoint} entrypoint entrypoint + * @returns {Chunk[]} every chunk this entrypoint needs in load order: the + * runtime chunk first (when `optimization.runtimeChunk` splits it off), then + * any intermediate chunks (e.g. from `optimization.splitChunks`), and finally + * the entry chunk itself. The entry chunk is always returned last so callers + * can identify it as the tag whose `src`/`href` attribute is being rewritten + * in place. Chunks that are already loaded by an ancestor (`dependOn`) entry's + * own script tag — i.e. the parent entrypoint's entry chunk *and* its runtime + * chunk — are skipped, otherwise they would be loaded twice when the same + * HTML contains tags for both the leader and the dependant entries. + */ +const getEntrypointChunksInLoadOrder = (entrypoint) => { + const entryChunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk()); + const runtimeChunk = entrypoint.getRuntimeChunk(); + + /** @type {Set} */ + const chunksLoadedByAncestorTags = new Set(); + /** @type {Set} */ + const visitedGroups = new Set(); + const walk = (/** @type {import("../ChunkGroup")} */ group) => { + if (visitedGroups.has(group)) return; + visitedGroups.add(group); + for (const parent of group.parentsIterable) { + if ( + typeof (/** @type {Entrypoint} */ (parent).getEntrypointChunk) === + "function" + ) { + const parentEntry = + /** @type {Entrypoint} */ + (parent).getEntrypointChunk(); + if (parentEntry) chunksLoadedByAncestorTags.add(parentEntry); + const parentRuntime = + /** @type {Entrypoint} */ + (parent).getRuntimeChunk(); + if (parentRuntime) chunksLoadedByAncestorTags.add(parentRuntime); + } + walk(parent); + } + }; + walk(entrypoint); + + /** @type {Chunk[]} */ + const ordered = []; + /** @type {Set} */ + const seen = new Set(); + const push = (/** @type {Chunk | null | undefined} */ chunk) => { + if (!chunk || seen.has(chunk) || chunk === entryChunk) return; + if (chunksLoadedByAncestorTags.has(chunk)) return; + seen.add(chunk); + ordered.push(chunk); + }; + if (runtimeChunk !== entryChunk) { + push(runtimeChunk); + } + for (const chunk of entrypoint.chunks) { + push(chunk); + } + ordered.push(entryChunk); + return ordered; +}; + +/** + * Whether webpack will emit a `.js` file for this chunk that must be + * loaded with a `` for script tags) + */ +const cloneTagWithUrl = ( + originalTag, + srcStartInTag, + srcEndInTag, + newUrl, + elementKind +) => { + let body = + originalTag.slice(0, srcStartInTag) + + newUrl + + originalTag.slice(srcEndInTag); + + // Strip dangerous-to-copy attributes from the cloned tag — currently + // just `integrity`. The match handles all three quoting styles + // (`"…"`, `'…'`, unquoted) and the bare-attribute form. + body = body.replace( + /\s+integrity(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?(?=[\s/>])/gi, + "" + ); + + if (elementKind === "script-module") { + if (/\stype\s*=/i.test(body)) { + body = body.replace( + /(\stype\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s>]+)/i, + '$1"module"' + ); + } else { + body = body.replace(/^` is a void element — no closing tag. ``. + return elementKind === "modulepreload" || elementKind === "stylesheet" + ? body + : `${body}`; +}; + +HtmlScriptSrcDependency.Template = class HtmlScriptSrcDependencyTemplate extends ( + ModuleDependency.Template +) { + /** + * Applies the plugin by registering its hooks on the compiler. + * @param {Dependency} dependency the dependency for which the template should be applied + * @param {ReplaceSource} source the current replace source which can be modified + * @param {DependencyTemplateContext} templateContext the context object + * @returns {void} + */ + apply(dependency, source, templateContext) { + const { runtimeTemplate } = templateContext; + const dep = /** @type {HtmlScriptSrcDependency} */ (dependency); + const compilation = runtimeTemplate.compilation; + const { chunkGraph } = compilation; + const entrypoint = /** @type {Entrypoint | undefined} */ ( + compilation.entrypoints.get(dep.entryName) + ); + + if (!entrypoint) { + source.replace(dep.range[0], dep.range[1] - 1, "data:,"); + return; + } + + const orderedChunks = getEntrypointChunksInLoadOrder(entrypoint); + const entryChunk = orderedChunks[orderedChunks.length - 1]; + const isStylesheet = dep.elementKind === "stylesheet"; + + // Rewrite the originating tag's src/href to the entry chunk's + // primary asset for that element kind: `.css` for + // ``, `.js` for everything else. + const entryContentHashType = isStylesheet ? "css" : "javascript"; + const entryUrl = `${CssUrlDependency.PUBLIC_PATH_AUTO}${getChunkFilename( + entryChunk, + compilation, + entryContentHashType + )}`; + source.replace(dep.range[0], dep.range[1] - 1, entryUrl); + + if (dep.tagStart < 0 || dep.tagOpenEnd <= dep.tagStart) { + return; + } + + // The browser must load every chunk the entry needs, not just the + // entry chunk. For `` regex would split too early inside + // `` patterns. + /** @type {null | { contentStart: number, attrs: Map, typeAttr: AttrToken | undefined, nameEnd: number }} */ + let pendingInlineScript = null; + + // Script src / modulepreload references are collected per-category + // during the walk; HtmlModulesPlugin later turns them into real + // entries. Classic ` + const jsContent = input.slice(contentStart, contentEnd); + if (jsContent.trim() === "") return end; + + // Base64-encode the JS body so the data URI round-trips + // arbitrary JavaScript text, including non-ASCII source + // (`decodeDataURI` decodes non-base64 bodies as ASCII, + // which would corrupt Unicode string literals or + // identifiers). + const request = `data:text/javascript;base64,${Buffer.from( + jsContent, + "utf8" + ).toString("base64")}`; + + const useEsmEntry = isModuleScript(ps.attrs); + const entryName = `__html_${moduleHash}_${nextEntryIndex++}`; + /** @type {"classic" | "esm-script"} */ + const kind = useEsmEntry ? "esm-script" : "classic"; + const { line: sl, column: sc } = locConverter.get(contentStart); + const { line: el, column: ec } = locConverter.get(contentEnd); + const dep = new HtmlInlineScriptDependency( + request, + ps.nameEnd, + [contentStart, contentEnd], + entryName, + useEsmEntry ? "esm" : "commonjs" + ); + dep.setLoc(sl, sc, el, ec); + module.addPresentationalDependency(dep); + reconcileScriptTypeAttr(ps.typeAttr, ps.nameEnd, kind, input); + const collection = + kind === "classic" ? classicEntries : esmScriptEntries; + collection.push({ request, entryName, kind }); + } + } + return end; + }, + openTag: (input, start, end, nameStart, nameEnd) => { + const ignore = pendingWebpackIgnore === true; + pendingWebpackIgnore = undefined; + if (ignore) { + // For ``/`` would leave the walker stuck in + // rawtext mode, swallowing later markup. + pendingAttributes.length = 0; + return end; + } + const elementName = input.slice(nameStart, nameEnd).toLowerCase(); + + // `` position so we can slice the body; the walker is + // already in rawtext state for ``. Only `` itself. + if (!this.css) { + return end; + } + + const cssContent = input.slice(contentStart, contentEnd); + if (cssContent.trim() === "") { + return end; + } + + // URL-encode the CSS body so the data URI parser's `(.*)$` + // body group matches even when the source has newlines or + // other characters that would otherwise break the regex. + const request = `data:text/css,${encodeURIComponent(cssContent)}`; + + const { line: sl, column: sc } = locConverter.get(contentStart); + const { line: el, column: ec } = locConverter.get(contentEnd); + const dep = new HtmlInlineStyleDependency(request, [ + contentStart, + contentEnd + ]); + dep.setLoc(sl, sc, el, ec); + module.addDependency(dep); + module.addCodeGenerationDependency(dep); + return end; + } + + const sources = DEFAULT_SOURCES.get(elementName); + + if (!sources) { + pendingAttributes.length = 0; + return end; + } + + /** @type {Map | undefined} */ + let attributesMap; + const getAttributesMap = () => { + if (attributesMap) return attributesMap; + attributesMap = new Map(); + for (const attr of pendingAttributes) { + const name = input + .slice(attr.nameStart, attr.nameEnd) + .toLowerCase(); + const value = + attr.valueStart !== -1 + ? input.slice(attr.valueStart, attr.valueEnd) + : ""; + attributesMap.set(name, value); + } + return attributesMap; + }; + + for (const attr of pendingAttributes) { + const attributeName = input + .slice(attr.nameStart, attr.nameEnd) + .toLowerCase(); + const sourceItem = sources.get(attributeName); + + if (!sourceItem) continue; + + // TODO(html-entities): We should ideally decode entities here using + // `walkHtmlTokens.decodeHtmlEntities(input.slice(...))` so that URLs + // like `image.png?a=1&b=2` are correctly resolved as `&`. + // However, doing so currently breaks `srcset` parsing tests (e.g. `errors.js`) + // which explicitly expect whitespace entities like ` ` to NOT be decoded + // before the srcset parser runs. A follow-up PR should implement selective + // decoding for specific URL attributes. + const attributeValue = + attr.valueStart !== -1 + ? input.slice(attr.valueStart, attr.valueEnd) + : ""; + + if (!attributeValue) continue; + + if ( + typeof sourceItem.filter === "function" && + !sourceItem.filter(getAttributesMap()) + ) { + continue; + } + + /** @type {ParsedSource[] | undefined} */ + let parsedAttributeValue; + + try { + parsedAttributeValue = sourceItem.parse(attributeValue); + } catch (err) { + const { line: sl, column: sc } = locConverter.get(attr.valueStart); + const { line: el, column: ec } = locConverter.get(attr.valueEnd); + + module.addError( + new ModuleDependencyError( + module, + new WebpackError( + `Bad value for attribute "${attributeName}" on element "${elementName}": ${ + /** @type {Error} */ (err).message + }` + ), + { + start: { line: sl, column: sc }, + end: { line: el, column: ec } + } + ) + ); + } + + if (!parsedAttributeValue) continue; + + // `` is upgraded to an entry only when + // `experiments.css` is on — that's the mode where webpack can + // bundle the CSS into its own chunk. Without it, the + // stylesheet href stays a plain asset URL. Scope this to the + // `href` attribute only: `` also exposes + // `imagesrcset` URLs which must continue to flow through + // the regular asset rewriting path even on a stylesheet + // link. + const isStylesheetEntry = + this.css && + elementName === "link" && + attributeName === "href" && + isLinkStylesheet(getAttributesMap()); + const isEntry = + isStylesheetEntry || + sourceItem.entry === true || + (typeof sourceItem.entry === "function" && + sourceItem.entry(getAttributesMap())); + + // `` position + // even in escaped/double-escaped script-data sub-states). + // When the tag has no `src` and its body is non-empty, the + // closeTag handler bundles the inline JS as its own entry — + // the same pipeline that processes `