webpack 5.108.2 → 5.108.4

package/lib/html/HtmlParser.js

@@ -35,14 +35,13 @@ const {
 	webpackCommentRegExp
 } = require("../util/magicComment");
 const {
+	NS_HTML,
 	NS_SVG,
 	NodeType,
 	SVG_TAG_ADJUST,
 	SourceProcessor,
-	buildHtmlAst,
 	decodeHtmlEntities,
 	decodeHtmlEntitiesWithMap,
-	findAttr,
 	parseSrcset
 } = require("./syntax");
 
@@ -113,6 +112,10 @@ const FUNC_IRI_URL_REGEXP = /url\(/i;
 // formatting/text markup (`<p>hi</p>`) rewrites to itself, so skip it.
 const SRCDOC_ASSET_REGEXP = /[=]|url\(|@import/i;
 
+// A URL carrying its own scheme (`https:`, `data:`, …) ignores the document
+// base per the URL spec, so `<base href>` never rewrites it.
+const ABSOLUTE_URL_SCHEME_REGEXP = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+
 // CSP/fetch attributes copied verbatim onto a synthesized sibling `<link>` /
 // `<script>` (`HtmlEntryDependency`). Fixed output order, independent of
 // source order.
@@ -120,24 +123,28 @@ const COPYABLE_SIBLING_ATTRS = ["nonce", "crossorigin", "referrerpolicy"];
 
 const CC_QUOTATION = '"'.charCodeAt(0);
 const CC_APOSTROPHE = "'".charCodeAt(0);
+const CC_SLASH = "/".charCodeAt(0);
 
 /**
  * Byte-exact source span of an attribute including the single leading
  * whitespace (` name`, ` name=value`, ` name="value"`), mirroring the
  * tokenizer's end-of-attribute rule (`valueEnd + 1` past the closing quote).
+ * @param {import("./syntax").HtmlPath} path walk path (used only for attribute-ref reads)
  * @param {string} source HTML source
- * @param {import("./syntax").HtmlAttribute} attr attribute
+ * @param {import("./syntax").HtmlAttributeRef} attr attribute ref
  * @returns {string} the attribute's source slice
  */
-const attrSourceSpan = (source, attr) => {
+const attrSourceSpan = (path, source, attr) => {
+	const valueStart = path.attributeValueStart(attr);
+	const valueEnd = path.attributeValueEnd(attr);
 	const end =
-		attr.valueStart === -1
-			? attr.nameEnd
-			: source.charCodeAt(attr.valueStart - 1) === CC_QUOTATION ||
-				  source.charCodeAt(attr.valueStart - 1) === CC_APOSTROPHE
-				? attr.valueEnd + 1
-				: attr.valueEnd;
-	return source.slice(attr.nameStart - 1, end);
+		valueStart === -1
+			? path.attributeNameEnd(attr)
+			: source.charCodeAt(valueStart - 1) === CC_QUOTATION ||
+				  source.charCodeAt(valueStart - 1) === CC_APOSTROPHE
+				? valueEnd + 1
+				: valueEnd;
+	return source.slice(path.attributeNameStart(attr) - 1, end);
 };
 
 // eslint-disable-next-line no-control-regex
@@ -909,6 +916,23 @@ class HtmlParser extends Parser {
 
 		let nextEntryIndex = 0;
 
+		// `<base href>` resolves the relative URLs that follow it. A relative base
+		// (`./assets/`) rewrites them into a subdirectory — still bundled; a
+		// root-relative or absolute base (`/`, `https://cdn/`) points them outside
+		// the build, so those URLs are left untouched. Resolved in the walk below
+		// from the first `<base href>` seen (`documentBase` undefined until then).
+		/** @type {string | undefined} */
+		let documentBase;
+		/** @type {string | undefined} */
+		let baseDir;
+		let baseIsExternal = false;
+		// Prepended to the emitted URLs' auto-public-path undo path so the base
+		// doesn't misdirect them: the browser resolves rewritten (relative)
+		// output URLs against the base dir, so one `../` per base segment cancels
+		// it. Undefined for absolute publicPath (no undo path is emitted).
+		/** @type {string | undefined} */
+		let baseUrlPrefix;
+
 		/**
 		 * Tracks the `webpackIgnore` value from the most recent comment that
 		 * appears before the next tag. Reset whenever a tag is emitted or a
@@ -920,41 +944,39 @@ class HtmlParser extends Parser {
 		const magicCommentContext = this.magicCommentContext;
 
 		/**
-		 * @param {import("./syntax").HtmlAttribute | undefined} typeAttr type attribute
+		 * @param {import("./syntax").HtmlPath} path walk path (used only for attribute-ref reads)
+		 * @param {import("./syntax").HtmlAttributeRef} typeAttr type attribute ref (0 = none)
 		 * @param {number} nameEnd end offset of the tag name
 		 * @param {string} type type of the script
 		 * @param {string} input source string
 		 */
-		const reconcileScriptTypeAttr = (typeAttr, nameEnd, type, input) => {
+		const reconcileScriptTypeAttr = (path, typeAttr, nameEnd, type, input) => {
+			const valueStart =
+				typeAttr !== 0 ? path.attributeValueStart(typeAttr) : -1;
+			const valueEnd = typeAttr !== 0 ? path.attributeValueEnd(typeAttr) : -1;
 			if (outputModule && type === "script") {
 				// Chunk is an ES module; upgrade the tag.
-				if (typeAttr && typeAttr.valueStart !== -1) {
+				if (typeAttr !== 0 && valueStart !== -1) {
 					module.addPresentationalDependency(
-						new ConstDependency("module", [
-							typeAttr.valueStart,
-							typeAttr.valueEnd
-						])
+						new ConstDependency("module", [valueStart, valueEnd])
 					);
 				} else {
 					module.addPresentationalDependency(
 						new ConstDependency(' type="module"', nameEnd)
 					);
 				}
-			} else if (!outputModule && type === "script-module" && typeAttr) {
+			} else if (!outputModule && type === "script-module" && typeAttr !== 0) {
 				// Chunk is a classic IIFE; drop `type="module"` so the
 				// browser doesn't load it under module semantics.
 				let attrEnd;
-				if (typeAttr.valueStart === -1) {
-					attrEnd = typeAttr.nameEnd;
-				} else if (
-					input[typeAttr.valueEnd] === '"' ||
-					input[typeAttr.valueEnd] === "'"
-				) {
-					attrEnd = typeAttr.valueEnd + 1;
+				if (valueStart === -1) {
+					attrEnd = path.attributeNameEnd(typeAttr);
+				} else if (input[valueEnd] === '"' || input[valueEnd] === "'") {
+					attrEnd = valueEnd + 1;
 				} else {
-					attrEnd = typeAttr.valueEnd;
+					attrEnd = valueEnd;
 				}
-				let attrStart = typeAttr.nameStart;
+				let attrStart = path.attributeNameStart(typeAttr);
 				if (
 					attrStart > 0 &&
 					isASCIIWhitespace(input.charCodeAt(attrStart - 1))
@@ -986,29 +1008,102 @@ class HtmlParser extends Parser {
 			dep.setLoc(s.line, s.column, e.line, e.column);
 		};
 
+		/**
+		 * Classifies the first `<base href>` seen in the walk, setting
+		 * `documentBase`/`baseDir`/`baseIsExternal`/`baseUrlPrefix` for the URLs
+		 * that follow it.
+		 * @param {import("./syntax").HtmlPath} path walk path (for attribute reads)
+		 * @param {import("./syntax").HtmlAttributeRef} hrefAttr the base's href attribute
+		 */
+		const resolveDocumentBase = (path, hrefAttr) => {
+			documentBase = decodeHtmlEntities(
+				path.attributeValue(hrefAttr),
+				true
+			).trim();
+			if (!documentBase) return;
+			if (
+				ABSOLUTE_URL_SCHEME_REGEXP.test(documentBase) ||
+				documentBase.charCodeAt(0) === CC_SLASH
+			) {
+				baseIsExternal = true;
+				return;
+			}
+			// Normalize the base path into its descending directory segments,
+			// resolving `.`/`..` like the URL spec. The final segment is the
+			// referenced file (dropped) unless the href ends with `/` or a
+			// dot-segment; `up` counts `..`s that climb above the document dir.
+			const parts = documentBase.split("/");
+			/** @type {string[]} */
+			const dirs = [];
+			let up = 0;
+			for (let i = 0; i < parts.length; i++) {
+				const part = parts[i];
+				if (part === "" || part === ".") continue;
+				if (part === "..") {
+					if (dirs.length > 0) dirs.pop();
+					else up++;
+					continue;
+				}
+				// A trailing plain segment (no following `/`) is the file, not a dir.
+				if (i === parts.length - 1) continue;
+				dirs.push(part);
+			}
+			baseDir = `${"../".repeat(up)}${dirs.length > 0 ? `${dirs.join("/")}/` : ""}`;
+			// A base above the document dir can't be cancelled with `../` (the
+			// document's own dir name is unknown) — leave the output URLs
+			// un-prefixed; they still resolve under an absolute publicPath.
+			if (up === 0 && dirs.length > 0) {
+				baseUrlPrefix = "../".repeat(dirs.length);
+			}
+		};
+
+		// Lazy decoded-attribute map for the current element — parse-scoped
+		// to avoid a closure and memo slot per element.
+		/** @type {import("./syntax").HtmlPath | undefined} */
+		let attrMapPath;
+		let attrMapCount = 0;
+		/** @type {Map<string, string> | undefined} */
+		let currentAttributesMap;
+		const getAttributesMap = () => {
+			if (currentAttributesMap) return currentAttributesMap;
+			currentAttributesMap = new Map();
+			const path = /** @type {import("./syntax").HtmlPath} */ (attrMapPath);
+			for (let i = 0; i < attrMapCount; i++) {
+				const attr = path.attributeAt(i);
+				// Decoded values — filters and type resolvers compare what
+				// the browser sees (e.g. `rel="&#105;con"` means `icon`)
+				currentAttributesMap.set(
+					path.attributeName(attr),
+					decodeHtmlEntities(path.attributeValue(attr), true)
+				);
+			}
+			return currentAttributesMap;
+		};
+
 		// TODO implement full HTML parser (WASM)
 		// The walker descends into children (and `<template>` content) itself;
 		// the Element `exit` clears a pending `webpackIgnore` once an element's
 		// children are done (the old `walkChildren` behaviour).
 		new SourceProcessor()
 			.use({
-				[NodeType.Comment]: (n) => {
-					const node = /** @type {import("./syntax").HtmlComment} */ (n);
+				[NodeType.Comment]: (path) => {
+					const start = path.start();
+					const end = path.end();
 					// Only proper `<!-- ... -->` comments carry magic comments.
 					if (
-						node.end - node.start < 7 ||
-						source.charCodeAt(node.start) !== 0x3c ||
-						source.charCodeAt(node.start + 1) !== 0x21 ||
-						source.charCodeAt(node.start + 2) !== 0x2d ||
-						source.charCodeAt(node.start + 3) !== 0x2d ||
-						source.charCodeAt(node.end - 1) !== 0x3e ||
-						source.charCodeAt(node.end - 2) !== 0x2d ||
-						source.charCodeAt(node.end - 3) !== 0x2d
+						end - start < 7 ||
+						source.charCodeAt(start) !== 0x3c ||
+						source.charCodeAt(start + 1) !== 0x21 ||
+						source.charCodeAt(start + 2) !== 0x2d ||
+						source.charCodeAt(start + 3) !== 0x2d ||
+						source.charCodeAt(end - 1) !== 0x3e ||
+						source.charCodeAt(end - 2) !== 0x2d ||
+						source.charCodeAt(end - 3) !== 0x2d
 					) {
 						pendingWebpackIgnore = undefined;
 						return;
 					}
-					const value = node.data;
+					const value = path.data();
 					if (!webpackCommentRegExp.test(value)) {
 						pendingWebpackIgnore = undefined;
 						return;
@@ -1018,8 +1113,8 @@ class HtmlParser extends Parser {
 					try {
 						options = parseMagicComment(value, magicCommentContext);
 					} catch (err) {
-						const { line: sl, column: sc } = locConverter.get(node.start);
-						const { line: el, column: ec } = locConverter.get(node.end);
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(end);
 						module.addWarning(
 							new CommentCompilationWarning(
 								`Compilation error while processing magic comment(-s): /*${value}*/: ${
@@ -1039,8 +1134,8 @@ class HtmlParser extends Parser {
 						return;
 					}
 					if (typeof options.webpackIgnore !== "boolean") {
-						const { line: sl, column: sc } = locConverter.get(node.start);
-						const { line: el, column: ec } = locConverter.get(node.end);
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(end);
 						module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackIgnore\` expected a boolean, but received: ${options.webpackIgnore}.`,
@@ -1062,8 +1157,7 @@ class HtmlParser extends Parser {
 					// Children (and `<template>` content) are walked by the
 					// processor after `enter`; `exit` clears a pending
 					// `webpackIgnore` once they're done.
-					enter: (n) => {
-						const node = /** @type {import("./syntax").HtmlElement} */ (n);
+					enter: (path) => {
 						const ignore = pendingWebpackIgnore === true;
 						pendingWebpackIgnore = undefined;
 
@@ -1071,24 +1165,26 @@ class HtmlParser extends Parser {
 							return;
 						}
 
-						const elementName = node.tagName;
-						const attrs = node.attributes;
-
-						/** @type {Map<string, string> | undefined} */
-						let attributesMap;
-						const getAttributesMap = () => {
-							if (attributesMap) return attributesMap;
-							attributesMap = new Map();
-							for (const attr of attrs) {
-								// Decoded values — filters and type resolvers compare what
-								// the browser sees (e.g. `rel="&#105;con"` means `icon`)
-								attributesMap.set(
-									attr.name,
-									decodeHtmlEntities(attr.value, true)
-								);
-							}
-							return attributesMap;
-						};
+						const elementName = path.tagName();
+						const attributeCount = path.attributeCount();
+						const elementStart = path.start();
+						const tagEnd = path.tagEnd();
+						const nameEnd = path.nameEnd();
+
+						// The first `<base href>` freezes the base for later URLs.
+						if (
+							documentBase === undefined &&
+							elementName === "base" &&
+							path.namespace() === NS_HTML
+						) {
+							const hrefAttr = path.findAttribute("href");
+							if (hrefAttr !== 0) resolveDocumentBase(path, hrefAttr);
+						}
+
+						// Rebind the parse-scoped lazy attribute map to this element.
+						attrMapPath = path;
+						attrMapCount = attributeCount;
+						currentAttributesMap = undefined;
 
 						// Each matched attribute is a source; the element body (inline
 						// `<style>`/`<script>`) is one more — content rather than an attribute.
@@ -1097,10 +1193,10 @@ class HtmlParser extends Parser {
 							this.sourcesByTag[elementName] || this.sourcesByTag[ANY_TAG];
 						const bodyItem = CONTENT_SOURCES[elementName];
 						// Iterate the attributes, then one extra step for the element
-						// body (`i === attrs.length`); `attrs[i]` is only read on the
-						// attribute steps, so the access stays in bounds.
-						for (let i = 0; i < attrs.length + 1; i++) {
-							const content = i === attrs.length;
+						// body (`i === attributeCount`); the attribute ref is only read on the
+						// attribute steps, so it stays in bounds.
+						for (let i = 0; i < attributeCount + 1; i++) {
+							const content = i === attributeCount;
 							/** @type {SourceType} */
 							let type;
 							/** @type {string} */
@@ -1109,23 +1205,18 @@ class HtmlParser extends Parser {
 							let start;
 							/** @type {number} */
 							let end;
-							/** @type {import("./syntax").HtmlAttribute | undefined} */
-							let attr;
+							/** @type {import("./syntax").HtmlAttributeRef} */
+							let attr = 0;
 							if (content) {
 								if (!bodyItem) continue;
 								if (bodyItem.filter && !bodyItem.filter(getAttributesMap())) {
 									continue;
 								}
-								/** @type {number | undefined} */
-								let bodyStart;
-								let bodyEnd = node.tagEnd;
-								for (const child of node.children) {
-									if (child.type === NodeType.Text) {
-										if (bodyStart === undefined) bodyStart = child.start;
-										bodyEnd = child.end;
-									}
-								}
-								if (bodyStart === undefined) continue;
+								// `skip.text` drops the body `Text` node; the raw content
+								// span is [`tagEnd`, `contentEnd`] on the element.
+								const bodyStart = tagEnd;
+								const bodyEnd = path.contentEnd();
+								if (bodyEnd <= bodyStart) continue;
 								value = source.slice(bodyStart, bodyEnd);
 								if (value.trim() === "") continue;
 								start = bodyStart;
@@ -1135,20 +1226,20 @@ class HtmlParser extends Parser {
 										? bodyItem.type(getAttributesMap(), css)
 										: bodyItem.type;
 							} else {
-								attr = attrs[i];
-								const item = sources[attr.name];
+								attr = path.attributeAt(i);
+								const item = sources[path.attributeName(attr)];
 								if (!item) continue;
 								if (
 									item.namespace !== undefined &&
-									node.namespace !== item.namespace
+									path.namespace() !== item.namespace
 								) {
 									continue;
 								}
 								// Adoption-agency clones carry no offsets; skip blank values.
-								if (attr.valueStart === undefined || attr.valueStart === -1) {
+								if (path.attributeValueStart(attr) === -1) {
 									continue;
 								}
-								value = attr.value;
+								value = path.attributeValue(attr);
 								if (!value || !/\S/.test(value)) continue;
 								const filter = item.filter;
 								if (filter) {
@@ -1159,8 +1250,8 @@ class HtmlParser extends Parser {
 										: value;
 									if (!filter(getAttributesMap(), decoded)) continue;
 								}
-								start = attr.valueStart;
-								end = attr.valueEnd;
+								start = path.attributeValueStart(attr);
+								end = path.attributeValueEnd(attr);
 								type =
 									typeof item.type === "function"
 										? item.type(getAttributesMap(), css)
@@ -1225,7 +1316,7 @@ class HtmlParser extends Parser {
 										const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
 										const dep = new HtmlInlineScriptDependency(
 											request,
-											node.nameEnd,
+											nameEnd,
 											[start, end],
 											entryName,
 											scriptType === "script-module" ? "esm" : "commonjs"
@@ -1233,8 +1324,9 @@ class HtmlParser extends Parser {
 										setLoc(dep, start, end);
 										module.addPresentationalDependency(dep);
 										reconcileScriptTypeAttr(
-											findAttr(attrs, "type"),
-											node.nameEnd,
+											path,
+											path.findAttribute("type"),
+											nameEnd,
 											scriptType,
 											source
 										);
@@ -1258,9 +1350,6 @@ class HtmlParser extends Parser {
 									// Parse the value into one or more URLs (decoding character
 									// references, mapping spans back to raw offsets), then emit a plain
 									// asset reference or an entry chunk per URL.
-									const a = /** @type {import("./syntax").HtmlAttribute} */ (
-										attr
-									);
 									const parse =
 										type === "srcset"
 											? parseSrcset
@@ -1287,9 +1376,9 @@ class HtmlParser extends Parser {
 											new ModuleDependencyError(
 												module,
 												new WebpackError(
-													`Bad value for attribute "${
-														a.name
-													}" on element "${elementName}": ${
+													`Bad value for attribute "${path.attributeName(
+														attr
+													)}" on element "${elementName}": ${
 														/** @type {Error} */ (err).message
 													}`
 												),
@@ -1305,6 +1394,18 @@ class HtmlParser extends Parser {
 									for (const [url, us, ue] of parsed) {
 										// Internal `url(#id)` / fragment-only refs aren't assets.
 										if (!url || url.startsWith("#")) continue;
+										// Resolve the request against `<base href>`. Only relative
+										// URLs are affected (scheme / `//` / `/` URLs ignore the
+										// base); an external base drops them from the build.
+										let request = url;
+										if (
+											documentBase &&
+											url.charCodeAt(0) !== CC_SLASH &&
+											!ABSOLUTE_URL_SCHEME_REGEXP.test(url)
+										) {
+											if (baseIsExternal) continue;
+											request = baseDir + url;
+										}
 										const s = start + (map ? map[us] : us);
 										const e = start + (map ? map[ue] : ue);
 										// `src`/`srcset`/`css-url`/`msapplication-task` are plain assets;
@@ -1345,11 +1446,12 @@ class HtmlParser extends Parser {
 											// CSP/fetch attributes the template copies onto siblings.
 											let copyableAttrsText = "";
 											let hasOwnCrossOrigin = false;
-											if (node.start >= 0) {
+											if (elementStart >= 0) {
 												for (const copyableName of COPYABLE_SIBLING_ATTRS) {
-													const copyableAttr = findAttr(attrs, copyableName);
-													if (copyableAttr) {
+													const copyableAttr = path.findAttribute(copyableName);
+													if (copyableAttr !== 0) {
 														copyableAttrsText += attrSourceSpan(
+															path,
 															source,
 															copyableAttr
 														);
@@ -1363,7 +1465,7 @@ class HtmlParser extends Parser {
 												firstScriptStart === -1 &&
 												(type === "script" || type === "script-module")
 											) {
-												firstScriptStart = node.start;
+												firstScriptStart = elementStart;
 											}
 											// Sibling-clone attribute edits, captured from the parsed
 											// attributes (offsets relative to the tag) so the template
@@ -1374,10 +1476,13 @@ class HtmlParser extends Parser {
 											let integrityRange = null;
 											/** @type {Range | null} */
 											let typeValueRange = null;
-											if (node.start >= 0 && elementName === nativeTag) {
-												const integrityAttr = findAttr(attrs, "integrity");
-												if (integrityAttr && integrityAttr.nameStart >= 0) {
-													let rs = integrityAttr.nameStart;
+											if (elementStart >= 0 && elementName === nativeTag) {
+												const integrityAttr = path.findAttribute("integrity");
+												if (
+													integrityAttr !== 0 &&
+													path.attributeNameStart(integrityAttr) >= 0
+												) {
+													let rs = path.attributeNameStart(integrityAttr);
 													while (
 														rs > 0 &&
 														isASCIIWhitespace(source.charCodeAt(rs - 1))
@@ -1385,40 +1490,46 @@ class HtmlParser extends Parser {
 														rs--;
 													}
 													let re;
-													if (integrityAttr.valueStart === -1) {
-														re = integrityAttr.nameEnd;
+													const ivs = path.attributeValueStart(integrityAttr);
+													if (ivs === -1) {
+														re = path.attributeNameEnd(integrityAttr);
 													} else {
-														const q = source.charCodeAt(
-															integrityAttr.valueStart - 1
-														);
+														const q = source.charCodeAt(ivs - 1);
+														const ive = path.attributeValueEnd(integrityAttr);
 														re =
 															q === CC_QUOTATION || q === CC_APOSTROPHE
-																? integrityAttr.valueEnd + 1
-																: integrityAttr.valueEnd;
+																? ive + 1
+																: ive;
 													}
-													integrityRange = [rs - node.start, re - node.start];
+													integrityRange = [
+														rs - elementStart,
+														re - elementStart
+													];
 												}
 												if (elementKind === "script-module") {
-													const typeAttr = findAttr(attrs, "type");
-													if (typeAttr && typeAttr.valueStart >= 0) {
+													const typeAttr = path.findAttribute("type");
+													if (
+														typeAttr !== 0 &&
+														path.attributeValueStart(typeAttr) >= 0
+													) {
 														typeValueRange = [
-															typeAttr.valueStart - node.start,
-															typeAttr.valueEnd - node.start
+															path.attributeValueStart(typeAttr) - elementStart,
+															path.attributeValueEnd(typeAttr) - elementStart
 														];
 													}
 												}
 											}
 											const dep = new HtmlEntryDependency(
-												url,
+												request,
 												[s, e],
 												entryName,
 												entryCategory,
 												elementKind,
-												node.start,
-												node.tagEnd,
+												elementStart,
+												tagEnd,
 												elementName === nativeTag,
 												copyableAttrsText,
-												node.nameEnd,
+												nameEnd,
 												hasOwnCrossOrigin,
 												firstScriptStart,
 												integrityRange,
@@ -1431,8 +1542,9 @@ class HtmlParser extends Parser {
 												(type === "script" || type === "script-module")
 											) {
 												reconcileScriptTypeAttr(
-													findAttr(attrs, "type"),
-													node.nameEnd,
+													path,
+													path.findAttribute("type"),
+													nameEnd,
 													type,
 													source
 												);
@@ -1444,9 +1556,9 @@ class HtmlParser extends Parser {
 													: type === "stylesheet"
 														? stylesheetEntries
 														: modulePreloadEntries
-											).push({ request: url, entryName, type });
+											).push({ request, entryName, type });
 										} else {
-											const dep = new HtmlSourceDependency(url, [s, e]);
+											const dep = new HtmlSourceDependency(request, [s, e]);
 											setLoc(dep, s, e);
 											module.addDependency(dep);
 											module.addCodeGenerationDependency(dep);
@@ -1462,10 +1574,14 @@ class HtmlParser extends Parser {
 					}
 				}
 			})
-			.process(source, { ast: buildHtmlAst(source) });
+			// Skip AST output this walk never reads: `text` (script/style bodies are
+			// read by offset via `contentEnd`) and `doctype`; keep `comments` for
+			// magic comments (`webpackIgnore`).
+			.process(source, { skip: { text: true, doctype: true } });
 
 		const buildInfo = /** @type {HtmlModuleBuildInfo} */ (module.buildInfo);
 		buildInfo.strict = true;
+		if (baseUrlPrefix !== undefined) buildInfo.baseUrlPrefix = baseUrlPrefix;
 		// Hand off the collected entries to HtmlModulesPlugin; it creates the
 		// real compilation entries during the finishMake hook. The `script`
 		// and `script-module` groups are chained via a leader-only dependOn