W260426/14.webpack/node_modules/webpack/lib/asset/AssetGenerator.js

/*
	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,
	JAVASCRIPT_AND_ASSET_URL_TYPES,
	JAVASCRIPT_TYPE,
	JAVASCRIPT_TYPES,
	NO_TYPES
} = require("../ModuleSourceTypeConstants");
const { ASSET_MODULE_TYPE } = require("../ModuleTypeConstants");
const RuntimeGlobals = require("../RuntimeGlobals");
const { toTemplateSourceFileName } = require("../TemplatedPathPlugin");
const URLDependency = require("../dependencies/URLDependency");
const { getScheme } = require("../util/URLAbsoluteSpecifier");
const createHash = require("../util/createHash");
const { languageOfMediaType } = require("../util/dataURL");
const { makePathsRelative } = require("../util/identifier");
const memoize = require("../util/memoize");
const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
const {
	PUBLIC_PATH_AUTO,
	PUBLIC_PATH_FULL_HASH
} = require("../util/publicPathPlaceholder");
const { updateHashFromSource } = require("../util/source");

const getMimeTypes = memoize(() => require("../util/mimeTypes"));

/** @import { Source } from "webpack-sources" */
/**
 * @import {
 * 	AssetGeneratorDataUrlOptions,
 * 	AssetGeneratorOptions,
 * 	AssetModuleFilename,
 * 	AssetModuleOutputPath,
 * 	AssetResourceGeneratorOptions,
 * 	RawPublicPath
 * } from "../../declarations/WebpackOptions"
 */
/** @import ChunkGraph from "../ChunkGraph" */
/** @import Compilation, { AssetInfo } from "../Compilation" */
/** @import { GenerateContext, UpdateHashContext } from "../Generator" */
/**
 * @import Module, {
 * 	NameForCondition,
 * 	ConcatenationBailoutReasonContext,
 * 	SourceType,
 * 	SourceTypes
 * } from "../Module"
 */
/** @import { AssetModuleBuildInfo } from "./AssetModule" */
/** @import ModuleGraph from "../ModuleGraph" */
/** @import NormalModule from "../NormalModule" */
/** @import RuntimeTemplate from "../RuntimeTemplate" */
/** @import Hash from "../util/Hash" */
/** @import { RuntimeSpec } from "../util/runtime" */

/** @typedef {(source: string | Buffer, context: { filename: string, module: Module }) => string} DataUrlFunction */

/**
 * Merges maybe arrays.
 * @template T
 * @template U
 * @param {null | string | T[] | Set<T> | undefined} a a
 * @param {null | string | U[] | Set<U> | undefined} b b
 * @returns {T[] & U[]} array
 */
const mergeMaybeArrays = (a, b) => {
	/** @type {Set<T | U | null | undefined | string | Set<T> | Set<U>>} */
	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<T | U>} */ (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<AssetInfo["related"]>} */
						(a[key]),
						/** @type {NonNullable<AssetInfo["related"]>} */
						(b[key])
					);
					break;
				default:
					throw new Error(`Can't handle conflicting asset info for ${key}`);
			}
		}
	}
	return result;
};

/**
 * Merges related info.
 * @param {NonNullable<AssetInfo["related"]>} a a
 * @param {NonNullable<AssetInfo["related"]>} b b
 * @returns {NonNullable<AssetInfo["related"]>} 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();

			encodedContent =
				typeof content === "string" ? content : content.toString("utf8");

			encodedContent = encodeURIComponent(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), "utf8");
	} catch (_) {
		return Buffer.from(content, "utf8");
	}
};

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
	 * @param {Compilation=} compilation the compilation (`getTypes` has no generate context, so the analyzable-output decision reads `output.module`/`output.publicPath` from here)
	 */
	constructor(
		moduleGraph,
		dataUrlOptions,
		filename,
		publicPath,
		outputPath,
		emit,
		compilation
	) {
		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 {Compilation | undefined} */
		this._compilation = compilation;
		/** @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 the source file name as seen by a filename template. With
	 * `experiments.futureDefaults` (webpack 6 default) `[path]` and `[file]` of a
	 * module outside of `context` behave like `[containedpath]`/`[containedfile]`,
	 * so they can't emit the asset outside of `output.path`.
	 * @param {NormalModule} module module
	 * @param {RuntimeTemplate} runtimeTemplate runtime template
	 * @returns {string} source file name for the filename template
	 */
	static getTemplateSourceFileName(module, runtimeTemplate) {
		return toTemplateSourceFileName(
			AssetGenerator.getSourceFileName(module, runtimeTemplate),
			runtimeTemplate.compilation
		);
	}

	/**
	 * 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<AssetResourceGeneratorOptions, "filename" | "outputPath">} generatorOptions generator options
	 * @param {{ runtime: RuntimeSpec, runtimeTemplate: RuntimeTemplate, chunkGraph: ChunkGraph }} generateContext context for generate
	 * @param {string} contentHash the content hash
	 * @param {string=} fullContentHash untruncated content hash, so `[contenthash:<digest>]` re-encodes from full entropy
	 * @returns {{ filename: string, originalFilename: string, assetInfo: AssetInfo }} info
	 */
	static getFilenameWithInfo(
		module,
		generatorOptions,
		{ runtime, runtimeTemplate, chunkGraph },
		contentHash,
		fullContentHash
	) {
		const assetModuleFilename =
			generatorOptions.filename ||
			runtimeTemplate.outputOptions.assetModuleFilename;

		// Both templates decide where the asset is written, so they see the
		// contained path.
		const templateSourceFilename = AssetGenerator.getTemplateSourceFileName(
			module,
			runtimeTemplate
		);
		let { path: filename, info: assetInfo } =
			runtimeTemplate.compilation.getAssetPathWithInfo(assetModuleFilename, {
				module,
				runtime,
				filename: templateSourceFilename,
				chunkGraph,
				contentHash,
				contentHashFull: fullContentHash
			});

		const originalFilename = filename;

		if (generatorOptions.outputPath) {
			const { path: outputPath, info } =
				runtimeTemplate.compilation.getAssetPathWithInfo(
					generatorOptions.outputPath,
					{
						module,
						runtime,
						filename: templateSourceFilename,
						chunkGraph,
						contentHash,
						contentHashFull: fullContentHash
					}
				);
			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<AssetResourceGeneratorOptions, "publicPath">} 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
	 * @param {string=} fullContentHash untruncated content hash, so `[contenthash:<digest>]` re-encodes from full entropy
	 * @returns {{ assetPath: string, assetInfo: AssetInfo }} asset path and info
	 */
	static getAssetPathWithInfo(
		module,
		generatorOptions,
		{ runtime, runtimeTemplate, type, chunkGraph, runtimeRequirements },
		filename,
		assetInfo,
		contentHash,
		fullContentHash
	) {
		// A public path is a url prefix, it doesn't decide where the asset is
		// written, so `[path]` stays the real path of the source file here.
		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,
					contentHashFull: fullContentHash
				}
			);
			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,
					contentHashFull: fullContentHash
				}
			);
			assetInfo = mergeAssetInfo(assetInfo, info);
			assetPath = path + filename;
		} else if (type === JAVASCRIPT_TYPE) {
			// `auto` reads `.p` as this asset's own directory url, which the absolute
			// `href` spells too; a complete url of its own is already the whole string.
			const constant = runtimeTemplate.constantPublicPath();
			const whole =
				constant !== undefined &&
				(constant.startsWith("//") || getScheme(constant) !== undefined);
			const analyzable =
				(runtimeTemplate.outputOptions.publicPath === "auto" || whole) &&
				runtimeTemplate.supportsAnalyzable("url", chunkGraph, module)
					? runtimeTemplate.getAnalyzableAssetUrl(
							module,
							chunkGraph,
							filename,
							runtime
						)
					: null;
			if (analyzable !== null) {
				assetPath = whole
					? analyzable
					: `${runtimeTemplate.importMetaUrl(analyzable)}.href`;
			} else {
				// 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"
					? PUBLIC_PATH_AUTO
					: compilation.getAssetPath(compilation.outputOptions.publicPath, {
							hash: compilation.hash || `${PUBLIC_PATH_FULL_HASH}0__`,
							hashWithLength: (length) =>
								compilation.hash
									? compilation.hash.slice(0, length)
									: `${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);
	}

	/**
	 * Offer the payload to `renderEmbeddedSource` before it is encoded, so the
	 * encoding covers what came back. Declines what names no language, and a
	 * `dataUrl` function, which is handed the source itself.
	 * @param {NormalModule} module the module holding the payload
	 * @param {GenerateContext["runtimeTemplate"]} runtimeTemplate runtime template
	 * @returns {Source | undefined} the rendered payload, when one came back
	 */
	_renderEmbedded(module, runtimeTemplate) {
		if (!runtimeTemplate || typeof this.dataUrlOptions === "function") {
			return undefined;
		}
		// Untapped, nothing can change: no mime lookup and no copy of the payload.
		const { compilation } = runtimeTemplate;
		if (compilation.hooks.renderEmbeddedSource.taps.length === 0) {
			return undefined;
		}
		const type = languageOfMediaType(this.getMimeType(module));
		if (type === undefined) return undefined;
		// An asset's source holds bytes; the hook is offered text, and the language
		// above is only ever one written as text.
		const content = /** @type {Source} */ (module.originalSource()).source();
		return compilation._resolveEmbeddedSource(
			new RawSource(
				typeof content === "string" ? content : content.toString("utf8")
			),
			{ type, hostType: JAVASCRIPT_TYPE, module }
		);
	}

	/**
	 * Generates data uri.
	 * @param {NormalModule} module module for which the code should be generated
	 * @param {Source=} renderedSource the payload to encode, when a hook rendered it
	 * @returns {string} DataURI
	 */
	generateDataUri(module, renderedSource) {
		const source =
			renderedSource || /** @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 {AssetModuleBuildInfo} */
			(module.buildInfo).dataUrl &&
			needContent
		) {
			// A payload bound for CSS or HTML is offered by their serializers, which
			// see the `url()` it ends up in; only the JavaScript one is ours.
			const encodedSource = this.generateDataUri(
				module,
				type === JAVASCRIPT_TYPE
					? this._renderEmbedded(module, runtimeTemplate)
					: undefined
			);
			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 {AssetModuleBuildInfo} */
			(module.buildInfo).fullContentHash = fullContentHash;

			const { originalFilename, filename, assetInfo } =
				AssetGenerator.getFilenameWithInfo(
					module,
					{ filename: this.filename, outputPath: this.outputPath },
					generateContext,
					contentHash,
					fullContentHash
				);

			if (data) {
				data.set("filename", filename);
			}

			let { assetPath, assetInfo: newAssetInfo } =
				AssetGenerator.getAssetPathWithInfo(
					module,
					{ publicPath: this.publicPath },
					generateContext,
					originalFilename,
					assetInfo,
					contentHash,
					fullContentHash
				);

			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 {AssetModuleBuildInfo} */
			(module.buildInfo).filename = filename;

			/** @type {AssetModuleBuildInfo} */
			(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(Generator.throwBuildErrorCode(error));
			}
			default:
				return null;
		}
	}

	/**
	 * Returns whether the effective publicPath yields a chunk-independent absolute
	 * url (scheme-relative, protocol-absolute, or root-absolute) with no hash tokens.
	 * Only then is a `new URL` literal correct for every chunk the asset is shared by,
	 * so the `module.exports` wrapper can be dropped in favor of the `asset-url` type.
	 * @returns {boolean} true when the publicPath is a token-free absolute string
	 */
	_hasAbsolutePublicPath() {
		const publicPath =
			this.publicPath !== undefined
				? this.publicPath
				: this._compilation && this._compilation.outputOptions.publicPath;
		return (
			typeof publicPath === "string" &&
			!publicPath.includes("[") &&
			(publicPath.startsWith("/") ||
				/^[a-z][a-z\d+\-.]*:\/\//i.test(publicPath))
		);
	}

	/**
	 * Returns the source types available for this module.
	 * @param {NormalModule} module fresh module
	 * @returns {SourceTypes} available types (do not mutate)
	 */
	getTypes(module) {
		const connections = this._moduleGraph.getIncomingConnections(module);

		// One that emits nothing has no name to build a literal from, so expose its url.
		const emits =
			!(
				module.buildInfo &&
				/** @type {AssetModuleBuildInfo} */ (module.buildInfo).dataUrl
			) && this.emit !== false;

		// Only analyzable ESM output can drop a bare `new URL()` to an asset-url; without
		// it every JS consumer needs the wrapper, so skip the per-connection dependency
		// probe entirely and keep the pre-existing cheap path. Must match the condition
		// `URLDependency` uses to emit the literal, or the wrapper is dropped while the
		// call site still requires the module — except where the fallback spells the name
		// itself (`.p + <file>`), which needs no wrapper to read it out of.
		// Build-time execution instead emulates the wrapper (`AssetModulesPlugin`).
		const isModule = Boolean(
			this._compilation &&
			this._compilation.runtimeTemplate.supportsAnalyzable(
				emits ? "url-inline" : "url"
			)
		);

		// Collapse the incoming origin types into flags instead of a Set of prefixes:
		// on assets shared by many modules this loop runs millions of times, so avoid
		// the per-connection `split("/")` allocation and stop early when the result is fixed.
		let hasOrigin = false;
		// JS origin that needs the `module.exports = …` wrapper (not a `new URL` ref).
		let hasOtherJs = false;
		// JS origin via `new URL(…, import.meta.url)` — droppable to `asset-url` in ESM.
		let hasUrlJs = false;
		// A manifest embeds a bare URL string (like css/html), so its icons must
		// resolve to `ASSET_URL_TYPE` rather than the JS runtime form.
		let hasUrl = false;
		for (const connection of connections) {
			const originModule = connection.originModule;
			if (!originModule) {
				continue;
			}
			hasOrigin = true;
			// The dependency says how the asset is read, so a reference added later answers
			// for itself; concatenation re-points the origin module, so it cannot.
			const dependency = connection.dependency;
			if (dependency && dependency.referencedSourceType === ASSET_URL_TYPE) {
				hasUrl = true;
			} else if (
				// Only a bare `new URL()` becomes the analyzable literal; a relative ref
				// keeps the runtime form and still needs the wrapper. Prefetch/preload
				// refs don't: their `<link>` is emitted at chunk startup, which resolves
				// the href from the asset filename when there is no wrapper.
				isModule &&
				dependency instanceof URLDependency &&
				!dependency.relative
			) {
				hasUrlJs = true;
			} else {
				hasOtherJs = true;
			}
			// Once a non-URL JS consumer and a url consumer coexist the result is fixed.
			if (hasOtherJs && hasUrl) break;
		}

		// Every javascript consumer names the file itself, so nothing reads the wrapper.
		// Only an absolute public path settles one url for all of them to share.
		const jsWrapperUnused = isModule && hasUrlJs && !hasOtherJs;
		const jsAsAssetUrl =
			jsWrapperUnused && (!emits || this._hasAbsolutePublicPath());
		// JS wrapper is needed for non-URL JS consumers, or URL consumers still reading it.
		const wantJs = hasOtherJs || (hasUrlJs && !jsWrapperUnused);
		const wantUrl = hasUrl || jsAsAssetUrl;

		if (!emits) {
			if (hasOrigin) {
				if (wantJs && wantUrl) {
					return JAVASCRIPT_AND_ASSET_URL_TYPES;
				} else if (wantUrl) {
					return ASSET_URL_TYPES;
				}
				return JAVASCRIPT_TYPES;
			}

			return NO_TYPES;
		}

		if (hasOrigin) {
			if (wantJs && wantUrl) {
				return ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES;
			} else if (wantUrl) {
				return ASSET_AND_ASSET_URL_TYPES;
			} else if (jsWrapperUnused) {
				// Every javascript consumer names the file itself, so nothing reads it.
				return ASSET_TYPES;
			}
			return ASSET_AND_JAVASCRIPT_TYPES;
		}

		return ASSET_TYPES;
	}

	/**
	 * @returns {boolean} whether getTypes() depends on the module's incoming connections
	 */
	getTypesDependOnIncomingConnections() {
		return true;
	}

	/**
	 * 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 &&
					/** @type {AssetModuleBuildInfo} */ (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 {AssetModuleBuildInfo} */
			(module.buildInfo).dataUrl
		) {
			hash.update("data-url");
			// What a tap varies on has to reach the key, or a changed option replays.
			const { runtimeTemplate } = updateHashContext;
			if (
				runtimeTemplate &&
				runtimeTemplate.compilation.hooks.renderEmbeddedSource.taps.length > 0
			) {
				runtimeTemplate.compilation.hooks.embeddedSourceHash.call(module, hash);
			}
			// 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"]>} */
				(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;
			// Hash what generation emits: the filename template sees the contained
			// path, unlike the public path above.
			const { path: filename, info } =
				runtimeTemplate.compilation.getAssetPathWithInfo(assetModuleFilename, {
					module,
					runtime,
					filename: AssetGenerator.getTemplateSourceFileName(
						module,
						runtimeTemplate
					),
					chunkGraph,
					contentHash: runtimeTemplate.contentHashReplacement
				});
			hash.update(filename);
			hash.update(JSON.stringify(info));
		}
	}
}

module.exports = AssetGenerator;