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

package/lib/util/dataURL.js

@@ -5,6 +5,9 @@
 
 "use strict";
 
+const path = require("path");
+const memoize = require("./memoize");
+
 // data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
 // http://www.ietf.org/rfc/rfc2397.txt
 const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64)?)?,(.*)$/i;
@@ -34,7 +37,228 @@ const decodeDataURI = (uri) => {
 	}
 };
 
+/**
+ * A `data:` URI split into the parts a caller has to put back together.
+ * `payload` is the text after the comma, still in the form it was written.
+ * @typedef {{ mediaType: string, base64: boolean, payload: string }} ParsedDataURI
+ */
+
+// `URIRegEx`'s `.` stops at a newline, which a raw `<svg>` payload carries, and
+// its `base64` group is optional in a way that reads `;charset=utf8` as one.
+// This one is the strict split a rewriter needs; that one stays as the matcher
+// module requests are recognized by.
+const STRICT_URI_REGEXP = /^data:([^,;]*)((?:;[^,;]*)*),([\s\S]*)$/i;
+
+const JSON_TYPE = "json";
+const SVG_TYPE = "svg";
+const CSS_TYPE = "css";
+const HTML_TYPE = "html";
+const JAVASCRIPT_TYPE = "javascript";
+
+/**
+ * Every language `languageOfMediaType` can name, for a consumer that has to say
+ * up front which of them it handles. Stated here rather than at each such
+ * consumer: adding one below adds it to every ability that names this.
+ * @type {string[]}
+ */
+const EMBEDDED_LANGUAGES = [
+	SVG_TYPE,
+	CSS_TYPE,
+	HTML_TYPE,
+	JSON_TYPE,
+	JAVASCRIPT_TYPE
+];
+
+/**
+ * The language name a media type carries, for a consumer that dispatches on it
+ * — a `renderEmbeddedSource` renderer today. Not a grammar table read out of a
+ * dataset: it is the handful of essences webpack itself has a notion of, so an
+ * unknown one declines rather than guessing. The `+json` structured suffix is
+ * read off the subtype.
+ * @param {string} mediaType a media type, e.g. `image/svg+xml`
+ * @returns {string | undefined} the language, or undefined when it names none
+ */
+const languageOfMediaType = (mediaType) => {
+	const essence = mediaType.toLowerCase().trim();
+	if (essence === "") return undefined;
+	if (essence === "image/svg+xml") return SVG_TYPE;
+	if (essence === "text/css") return CSS_TYPE;
+	if (essence === "text/html") return HTML_TYPE;
+	if (essence === "application/json" || essence.endsWith("+json")) {
+		return JSON_TYPE;
+	}
+	if (/^(?:text|application)\/(?:x-)?(?:ecma|java)script$/.test(essence)) {
+		return JAVASCRIPT_TYPE;
+	}
+	return undefined;
+};
+
+const getMimeTypes = memoize(() => require("./mimeTypes"));
+
+/**
+ * The language a file's name says it holds, for a module that embeds the file's
+ * text rather than a `data:` URI — the same question `languageOfMediaType`
+ * answers, read off the extension through webpack's own mime lookup.
+ * @param {string | null} filename the file's name, or null when it has none
+ * @returns {string | undefined} the language, or undefined when it names none
+ */
+const languageOfFilename = (filename) => {
+	if (!filename) return undefined;
+	const mediaType = getMimeTypes().lookup(path.extname(filename));
+	return typeof mediaType === "string"
+		? languageOfMediaType(mediaType)
+		: undefined;
+};
+
+/**
+ * Split a `data:` URI, or `null` when it is not one.
+ * @param {string} uri the URI, unquoted and unescaped
+ * @returns {ParsedDataURI | null} its parts
+ */
+const parseDataURI = (uri) => {
+	const match = STRICT_URI_REGEXP.exec(uri);
+	if (match === null) return null;
+	return {
+		mediaType: match[1],
+		base64: /;base64$/i.test(match[2]),
+		payload: match[3]
+	};
+};
+
+/**
+ * The payload as text, or `null` when reading it would not round-trip. A
+ * percent-escaped payload is declined rather than decoded: how much of it the
+ * author escaped is not recorded anywhere in the URI, so re-escaping would
+ * rewrite bytes nothing asked to change.
+ * @param {ParsedDataURI} parsed the split URI
+ * @returns {string | null} the payload as text
+ */
+const decodeDataURIPayload = (parsed) => {
+	if (!parsed.base64) {
+		return parsed.payload.includes("%") ? null : parsed.payload;
+	}
+	// Decoding is lenient rather than throwing, so garbage decodes to something
+	// that does not round-trip, which is the same answer: leave it alone.
+	const text = Buffer.from(parsed.payload, "base64").toString("utf8");
+	return Buffer.from(text, "utf8").toString("base64") === parsed.payload
+		? text
+		: null;
+};
+
+/**
+ * Rebuild a `data:` URI around a new payload, in the form it was written in.
+ * @param {ParsedDataURI} parsed the split URI
+ * @param {string} text the new payload as text
+ * @returns {string} the rebuilt URI
+ */
+const buildDataURI = (parsed, text) => {
+	const head = `data:${parsed.mediaType}${parsed.base64 ? ";base64" : ""},`;
+	if (parsed.base64) {
+		return head + Buffer.from(text, "utf8").toString("base64");
+	}
+	// Only the two that would change what the URI means: `%` starts an escape and
+	// `#` starts a fragment. Everything else stays as the renderer wrote it, and
+	// the url token's own quoting is the caller's to apply.
+	return head + text.replace(/%/g, "%25").replace(/#/g, "%23");
+};
+
+/**
+ * The minified text a renderer answered with, for one that may answer with a
+ * whole result instead. `undefined` is a renderer that declined.
+ * @param {string | { code?: string } | undefined} answer what it answered
+ * @returns {string | undefined} the text, or undefined
+ */
+const embeddedText = (answer) =>
+	answer === undefined || typeof answer === "string" ? answer : answer.code;
+
+/**
+ * Everything a run's renderers reported, in the shape a minifier returns —
+ * an empty list is left off, so a run nothing was reported over is exactly
+ * what it always was.
+ * @param {{ warnings?: (Error | string)[], errors?: (Error | string)[] }[]} reported what each answered with
+ * @returns {{ warnings?: (Error | string)[], errors?: (Error | string)[] }} the collected diagnostics
+ */
+const collectEmbeddedDiagnostics = (reported) => {
+	/** @type {(Error | string)[]} */
+	const warnings = [];
+	/** @type {(Error | string)[]} */
+	const errors = [];
+
+	for (const entry of reported) {
+		if (entry.warnings !== undefined) warnings.push(...entry.warnings);
+		if (entry.errors !== undefined) errors.push(...entry.errors);
+	}
+
+	/** @type {{ warnings?: (Error | string)[], errors?: (Error | string)[] }} */
+	const out = {};
+
+	if (warnings.length !== 0) out.warnings = warnings;
+	if (errors.length !== 0) out.errors = errors;
+
+	return out;
+};
+
+/**
+ * One embedded body a print offered but could not wait for, and the text to
+ * print around the answer once it is in: {@link import("./SourceProcessor").DeferredWrite},
+ * plus what the grammar has to say about what it offered. `as` names which of
+ * that language's productions the body is, where it has more than one — an HTML
+ * `style=""` is `"block-contents"` rather than a whole stylesheet.
+ * @typedef {import("./SourceProcessor").DeferredWrite & { type: string, hostType: string, as?: string }} DeferredEmbeddedSource
+ */
+
+/**
+ * What a renderer made of one embedded body: the minified text, and anything it
+ * has to report about it. A bare string is the text alone, `undefined` a
+ * renderer that declined.
+ * @typedef {{ code?: string, warnings?: (Error | string)[], errors?: (Error | string)[] }} EmbeddedSourceResult
+ */
+
+/**
+ * Ask a renderer for one embedded body and keep what it reported. Anything it
+ * throws is a renderer that did not answer rather than an asset that fails to
+ * serialize: the rest of the print stands, the body is spelled as an untapped
+ * run spells it, and why it was is not lost.
+ * @param {(source: string, info: { type: string, hostType: string, as?: string }) => Promise<string | EmbeddedSourceResult | undefined> | string | EmbeddedSourceResult | undefined} render the caller's renderer
+ * @param {{ source: string, type: string, hostType: string, as?: string }} hole the body to offer
+ * @param {EmbeddedSourceResult[]} reported collects what each says about them
+ * @returns {Promise<string | EmbeddedSourceResult | undefined>} what it answered, or undefined where it declined or threw
+ */
+const askEmbeddedRenderer = async (render, hole, reported) => {
+	const { source, type, hostType, as } = hole;
+
+	try {
+		const answer = await render(source, {
+			type,
+			hostType,
+			...(as === undefined ? undefined : { as })
+		});
+
+		if (
+			answer !== undefined &&
+			typeof answer !== "string" &&
+			(answer.warnings !== undefined || answer.errors !== undefined)
+		) {
+			reported.push(answer);
+		}
+
+		return answer;
+	} catch (error) {
+		reported.push({ errors: [/** @type {Error} */ (error)] });
+		return undefined;
+	}
+};
+
 module.exports = {
+	EMBEDDED_LANGUAGES,
 	URIRegEx,
-	decodeDataURI
+	askEmbeddedRenderer,
+	buildDataURI,
+	collectEmbeddedDiagnostics,
+	decodeDataURI,
+	decodeDataURIPayload,
+	embeddedText,
+	languageOfFilename,
+	languageOfMediaType,
+	parseDataURI
 };

package/lib/util/extractSourceMap.js

@@ -9,10 +9,10 @@ const path = require("path");
 const urlUtils = require("url");
 const { isAbsolute, join } = require("./fs");
 
-/** @typedef {import("./fs").InputFileSystem} InputFileSystem */
+/** @import { InputFileSystem } from "./fs" */
 /** @typedef {string | Buffer<ArrayBufferLike>} StringOrBuffer */
 /** @typedef {(input: StringOrBuffer, resourcePath: string, fs: InputFileSystem) => Promise<{ source: StringOrBuffer, sourceMap: string | RawSourceMap | undefined, fileDependencies: string[] }>} SourceMapExtractorFunction */
-/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
+/** @import { RawSourceMap } from "webpack-sources" */
 /** @typedef {(resourcePath: string) => Promise<StringOrBuffer>} ReadResource */
 
 /**
@@ -315,5 +315,6 @@ async function extractSourceMap(stringOrBuffer, resourcePath, readResource) {
 	};
 }
 
+extractSourceMap.getSourceMappingURL = getSourceMappingURL;
+
 module.exports = extractSourceMap;
-module.exports.getSourceMappingURL = getSourceMappingURL;

package/lib/util/findCaseMismatch.js

@@ -0,0 +1,139 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { dirname, join } = require("./fs");
+
+/** @import { InputFileSystem } from "./fs" */
+
+/** @typedef {[string, string]} CaseCorrection wrongly cased segment paired with its real name */
+/** @typedef {{ corrections: CaseCorrection[], path: string }} CaseMismatch */
+
+/** Bounds the walk for a path pointing far outside any existing directory. */
+const MAX_MISSING_SEGMENTS = 20;
+
+/**
+ * @param {InputFileSystem} fs input file system
+ * @param {string} absolutePath absolute path
+ * @returns {string} the last segment of the path, or an empty string at the root
+ */
+const basename = (fs, absolutePath) => {
+	const parent = dirname(fs, absolutePath);
+	if (parent === absolutePath) return "";
+	let start = parent.length;
+	const charCode = absolutePath.charCodeAt(start);
+	if (charCode === 47 /* "/" */ || charCode === 92 /* "\\" */) start++;
+	return absolutePath.slice(start);
+};
+
+/**
+ * Finds an existing path that differs from `missingPath` only in the casing of
+ * its segments, by listing the directories the path walks through.
+ * @param {InputFileSystem} fs input file system
+ * @param {string} missingPath absolute path that does not exist
+ * @param {(mismatch?: CaseMismatch) => void} callback receives the real path and the wrongly cased segments, outermost first, or nothing when the path does not exist under any casing
+ * @returns {void}
+ */
+const findCaseMismatch = (fs, missingPath, callback) => {
+	/** @type {string[]} */
+	const segments = [];
+	/** @type {CaseCorrection[]} */
+	const corrections = [];
+
+	/**
+	 * @param {string} directory existing directory the remaining segments start from
+	 * @param {string[]} entries its entries
+	 * @param {number} index index into `segments`
+	 * @returns {void}
+	 */
+	const walkDown = (directory, entries, index) => {
+		const name = segments[index];
+		let realName = name;
+		if (!entries.includes(name)) {
+			const lowerCasedName = name.toLowerCase();
+			const matches = entries.filter((e) => e.toLowerCase() === lowerCasedName);
+			// More than one match means the real name is not knowable from the request alone
+			if (matches.length !== 1) return callback();
+			realName = matches[0];
+			corrections.push([name, realName]);
+		}
+		const next = join(fs, directory, realName);
+		if (index === segments.length - 1) {
+			return callback(
+				corrections.length > 0 ? { corrections, path: next } : undefined
+			);
+		}
+		fs.readdir(next, (err, nextEntries) => {
+			if (err || !nextEntries) return callback();
+			walkDown(next, /** @type {string[]} */ (nextEntries), index + 1);
+		});
+	};
+
+	let current = missingPath;
+
+	/**
+	 * @returns {void}
+	 */
+	const walkUp = () => {
+		const parent = dirname(fs, current);
+		const name = basename(fs, current);
+		if (parent === current || name === "") return callback();
+		segments.push(name);
+		if (segments.length > MAX_MISSING_SEGMENTS) return callback();
+		fs.readdir(parent, (err, entries) => {
+			if (err || !entries) {
+				current = parent;
+				return walkUp();
+			}
+			segments.reverse();
+			walkDown(parent, /** @type {string[]} */ (entries), 0);
+		});
+	};
+
+	walkUp();
+};
+
+/**
+ * Rewrites a request with the real casing found on disk. Corrections are
+ * case-only, so each one keeps the length and position of what it replaces —
+ * a request that omitted the extension spells a prefix of the segment.
+ * @param {string} request request as written
+ * @param {CaseCorrection[]} corrections corrections, outermost first
+ * @returns {string | undefined} the corrected request, or undefined when a correction is not spelled out in the request
+ */
+const applyCaseCorrections = (request, corrections) => {
+	let result = request;
+	let cursor = 0;
+	for (const [wrongName, realName] of corrections) {
+		let index = result.indexOf(wrongName, cursor);
+		let length = wrongName.length;
+		if (index === -1) {
+			length = 0;
+			for (let i = wrongName.length - 1; i > 0; i--) {
+				// A prefix that is already correctly cased identifies nothing — the
+				// request would come back unchanged and the hint would repeat it
+				if (
+					result.endsWith(wrongName.slice(0, i)) &&
+					realName.slice(0, i) !== wrongName.slice(0, i)
+				) {
+					index = result.length - i;
+					length = i;
+					break;
+				}
+			}
+			if (length === 0) return undefined;
+		}
+		result =
+			result.slice(0, index) +
+			realName.slice(0, length) +
+			result.slice(index + length);
+		cursor = index + length;
+	}
+	return result;
+};
+
+module.exports.applyCaseCorrections = applyCaseCorrections;
+module.exports.findCaseMismatch = findCaseMismatch;

package/lib/util/formatLocation.js

@@ -5,8 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/** @import { DependencyLocation, SourcePosition } from "../Dependency" */
 
 /**
  * Returns formatted position.

package/lib/util/fs.js

@@ -9,9 +9,13 @@ const path = require("path");
 const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
 
 /** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("watchpack").Entry} Entry */
-/** @typedef {import("watchpack").OnlySafeTimeEntry} OnlySafeTimeEntry */
-/** @typedef {import("watchpack").ExistenceOnlyTimeEntry} ExistenceOnlyTimeEntry */
+/**
+ * @import {
+ * 	Entry,
+ * 	OnlySafeTimeEntry,
+ * 	ExistenceOnlyTimeEntry
+ * } from "watchpack"
+ */
 
 /**
  * Defines the i stats base type used by this module.
@@ -652,7 +656,16 @@ const mkdirpSync = (fs, p) => {
 					throw err;
 				}
 				mkdirpSync(fs, dir);
-				fs.mkdirSync(p);
+				try {
+					fs.mkdirSync(p);
+				} catch (retryErr) {
+					// EEXIST: parent already created it; EISDIR: memfs/BSD for an
+					// existing dir such as the root "/" (#10544)
+					const code = /** @type {NodeJS.ErrnoException} */ (retryErr).code;
+					if (code !== "EEXIST" && code !== "EISDIR") {
+						throw retryErr;
+					}
+				}
 				return;
 			} else if (
 				/** @type {NodeJS.ErrnoException} */ (err).code === "EEXIST" ||
@@ -709,7 +722,11 @@ const lstatReadlinkAbsolute = (fs, p, callback) => {
 			}
 			if (err) return callback(err);
 			const value = /** @type {string} */ (target).toString();
-			callback(null, join(fs, dirname(fs, p), value));
+			// An absolute target must not be joined onto the link's directory (#21636)
+			callback(
+				null,
+				isAbsolute(value) ? value : join(fs, dirname(fs, p), value)
+			);
 		});
 	};
 	const doStat = () => {