@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/url/URLParserPlugin.js

@@ -257,10 +257,9 @@ class URLParserPlugin {
 					relative
 				);
 				dep.loc = parser.getLocation(expr);
-				// `parser.javascript.urlHints` provides project-wide defaults
-				// (resolved per-request, with `test` / `include` / `exclude`
-				// matching); a per-URL magic comment for the same hint wins
-				// when both are set.
+				// `parser.javascript.urlHints` gives the project-wide defaults,
+				// resolved per request; a per-URL magic comment for the same hint
+				// wins where both are set.
 				ResourceHintPlugin.applyResourceHints(
 					dep,
 					this.options.urlHints,
@@ -270,10 +269,9 @@ class URLParserPlugin {
 					parser.getLocation(expr)
 				);
 				parser.state.current.addDependency(dep);
-				// For ESM module output the template embeds the asset's resolved
-				// filename, so the asset must be code-generated first. Only added in
-				// that mode — a code-gen dependency on an asset that a later watch
-				// rebuild leaves unaffected can otherwise deadlock the scheduler.
+				// The ESM template embeds the asset's resolved filename, so the asset
+				// must be code-generated first. Added in that mode only: elsewhere the
+				// extra code-gen dependency can deadlock a watch rebuild.
 				if (parser.state.compilation.options.output.module) {
 					parser.state.module.addCodeGenerationDependency(dep);
 				}

package/lib/util/ArrayQueue.js

@@ -90,11 +90,11 @@ class ArrayQueue {
 	[Symbol.iterator]() {
 		return {
 			next: () => {
-				const item = this.dequeue();
-				if (item) {
+				// length, not truthiness: a queued `0`/`false`/`undefined` is a value
+				if (this.length > 0) {
 					return {
 						done: false,
-						value: item
+						value: /** @type {T} */ (this.dequeue())
 					};
 				}
 				return {

package/lib/util/LocConverter.js

@@ -63,13 +63,10 @@ class LocConverter {
 				// Retreat on line 1: no `\n` precedes `pos`, the cache stays valid.
 				this.column = pos;
 			} else {
-				// Retreat: count newlines crossed in (pos, this.pos), i.e.
-				// exclude the newline at `this.pos` itself. By convention a
-				// `\n` is the last column of its line, so when `this.pos`
-				// sits on one we're already on the line containing it; only
-				// newlines strictly **before** `this.pos` and at-or-after
-				// `pos` represent crossed line boundaries. The smallest
-				// crossed one is the next newline after the new position.
+				// WHY: A `\n` counts as the last column of its own line here, so a
+				// `this.pos` sitting on one is already on that line. Retreating
+				// therefore crosses only the newlines at or after `pos` and strictly
+				// before `this.pos` — the newline at `this.pos` is not one of them.
 				let i = input.lastIndexOf("\n", this.pos - 1);
 				while (i >= pos) {
 					this._nextNewline = i;

package/lib/util/SourceProcessor.js

@@ -99,6 +99,23 @@ const expandDeferredWrites = (text, resolve, infix) => {
 	return out + text.slice(from);
 };
 
+/**
+ * The text this print spells with every deferred write declined: each marker
+ * replaced by what would stand there had no renderer answered. What a print
+ * verifying itself by re-parsing has to read, since a marker otherwise parses
+ * as text where its node stood. `build` rather than `source` so a write inside
+ * an attribute comes back escaped for where it sits.
+ * @param {string} text the printed output, holding this print's markers
+ * @param {DeferredWrite[]} writes what the print deferred, indexed by id
+ * @returns {string} the text with every marker put back
+ */
+const declineDeferredWrites = (text, writes) =>
+	expandDeferredWrites(
+		text,
+		(id) => (id < writes.length ? writes[id].build(undefined) : undefined),
+		deferredInfix
+	);
+
 /**
  * Babel-style visitor map keyed by a numeric node-type discriminator; a bucket
  * is a function (enter-only) or `{ enter?, exit? }`.
@@ -244,20 +261,20 @@ class PrintContext {
 		/** @type {NodePrinter<TPath, TNode, TPrintOptions>} */
 		this._printer = printer;
 		// Printed text by node handle, in two columns rather than one `Map`: the
-		// handles are dense integers, and a stylesheet prints ~300k nodes through
-		// a store that never holds more than a few dozen of them at once.
+		// handles are dense integers, and `_moveEpoch` keeps the live set small.
 		/** @type {string[]} each finished node's printed text */
 		this._storeText = [];
 		/** @type {Int32Array} the epoch each slot was written in */
 		this._storeGen = new Int32Array(0);
 		/** @type {number} current epoch; a slot from an older one reads as absent */
 		this._gen = 1;
-		// Output accumulates into `_tail`, a plain string append, so printing that
-		// never takes anything back costs exactly what appending to one string
-		// costs. A piece is cut off into `_chunks` only for text that may still be
-		// taken back ({@link emitRetractable}) — that is what lets a printer emit
-		// before it knows a later sibling overrides it, without every other emit
-		// paying for the ability. The output is `_chunks` joined, then `_tail`.
+		/** @type {number} lowest slot written since the epoch last moved */
+		this._storeLow = 0x7fffffff;
+		/** @type {number} highest slot written since the epoch last moved */
+		this._storeHigh = -1;
+		// Output is `_chunks` joined, then `_tail`. Printing that never takes
+		// anything back only appends to `_tail`; a piece is cut off into `_chunks`
+		// for retractable text alone, so no other emit pays for that ability.
 		/** @type {string[]} pieces already cut off, in output order */
 		this._chunks = [];
 		/** @type {string} output after the last cut piece */
@@ -268,7 +285,7 @@ class PrintContext {
 		this._flattened = 0;
 		/** @type {[number, number, number, number][]} `[chunkIndex, offsetInChunk, srcLine, srcCol]`, output-ordered; a `srcLine` of -1 is one {@link retract} took back with its piece */
 		this._mappings = [];
-		/** @type {Map<number, number> | null} a retractable piece -> the mapping anchored to it, so taking the piece back takes its mapping too */
+		/** @type {number[] | null} by retractable piece index, the mapping anchored to it, so taking the piece back takes its mapping too */
 		this._retractableMappings = null;
 		// A map is built only for a caller that named the input, and that is known
 		// before printing — so a print nobody asks a map of collects none.
@@ -279,10 +296,9 @@ class PrintContext {
 		this._inserts = [];
 		/** @type {number} next `_inserts` entry not yet flushed */
 		this._insertIdx = 0;
-		// Openers of the nodes being printed in pieces, innermost last, held back
-		// until one of them turns out to have content: a node whose children all
-		// print to nothing can then still be dropped whole, which is the one thing
-		// emitting an opener eagerly would give up.
+		// Openers of the nodes printed in pieces, innermost last, held back until
+		// one has content — which is what lets a node whose children all print to
+		// nothing still be dropped whole.
 		/** @type {string[]} openers not yet emitted, outermost first */
 		this._pending = [];
 		/** @type {[number | undefined, number | undefined, number | undefined] | null} anchor for the first pending opener */
@@ -389,16 +405,14 @@ class PrintContext {
 	_growStore(need) {
 		// From empty: a context that prints one inline `style=""` must not pay for
 		// a stylesheet's worth of columns.
-		const size = Math.max(need, this._storeText.length * 2, 16);
-		// Appended, which keeps the column packed for the read every composed child
-		// makes, and carries what it already holds across in the same pass.
-		const held = this._storeText;
-		const text = [];
-		for (let i = 0; i < held.length; i++) text.push(held[i]);
-		for (let i = held.length; i < size; i++) text.push("");
+		const text = this._storeText;
+		const size = Math.max(need, text.length * 2, 16);
+		// Appended in place: `push` keeps the column packed for the read every
+		// composed child makes, and what it already holds never moves — where
+		// filling a second array would copy every slot again at each growth.
+		for (let i = text.length; i < size; i++) text.push("");
 		const gen = new Int32Array(size);
 		gen.set(this._storeGen);
-		this._storeText = text;
 		this._storeGen = gen;
 	}
 
@@ -409,8 +423,25 @@ class PrintContext {
 	 * node's text.
 	 */
 	dropStore() {
-		// Bumping the epoch invalidates every slot at once, so this stays O(1) —
-		// it runs per node, and clearing a column by length would not.
+		this._moveEpoch();
+	}
+
+	/**
+	 * Move the epoch on and release the text every slot written under the old one
+	 * holds. Only the range actually written is walked, so the drop stays O(1)
+	 * per node.
+	 * @returns {void}
+	 */
+	_moveEpoch() {
+		const high = this._storeHigh;
+		if (high !== -1) {
+			// `""` rather than a hole: the column is packed, and a hole in it would
+			// cost every read after this one.
+			const text = this._storeText;
+			for (let i = this._storeLow; i <= high; i++) text[i] = "";
+			this._storeLow = 0x7fffffff;
+			this._storeHigh = -1;
+		}
 		this._gen++;
 	}
 
@@ -454,6 +485,8 @@ class PrintContext {
 		if (n >= this._storeText.length) this._growStore(n + 1);
 		this._storeText[n] = text;
 		this._storeGen[n] = this._gen;
+		if (n < this._storeLow) this._storeLow = n;
+		if (n > this._storeHigh) this._storeHigh = n;
 	}
 
 	/**
@@ -487,14 +520,12 @@ class PrintContext {
 	_emit(text) {
 		this._tail += text;
 		this._tailLength += text.length;
-		// A printer returns its text as a rope of its children's pieces, and
-		// appending a rope onto a rope keeps every fragment of every node reachable
-		// until the output is finally flattened — on a stylesheet of many top-level
-		// rules, a second copy of the whole output. So cut the tail off once it has
-		// grown past a block and force that block flat, which drops every fragment
-		// behind it. Per block rather than per piece: the flattening copy is one
-		// the result would have paid for anyway, but paying it per piece means an
-		// allocation for each, and the pieces are small.
+		// WHY: A printer returns a rope of its children's pieces, and appending a
+		// rope onto a rope keeps every fragment reachable until the output is
+		// flattened — a second copy of a large stylesheet. Cutting the tail once it
+		// passes a block forces that block flat and drops the fragments behind it.
+		// Per block rather than per piece: the copy is one the result pays anyway,
+		// while per piece it would be an allocation each, and the pieces are small.
 		if (this._tailLength >= FLATTEN_BLOCK) this._cutTail();
 	}
 
@@ -537,7 +568,7 @@ class PrintContext {
 	retract(index) {
 		this._chunks[index] = "";
 		if (this._retractableMappings === null) return;
-		const mapping = this._retractableMappings.get(index);
+		const mapping = this._retractableMappings[index];
 		if (mapping !== undefined) this._mappings[mapping][2] = -1;
 	}
 
@@ -583,12 +614,12 @@ class PrintContext {
 		this.anchor(srcOffset, srcLine, srcCol);
 		const mapping = this._mappings.length > before ? before : -1;
 		const at = this.emitRetractable(text === undefined ? this.get(node) : text);
-		this._gen++;
+		this._moveEpoch();
 		if (mapping !== -1) {
-			if (this._retractableMappings === null) {
-				this._retractableMappings = new Map();
-			}
-			this._retractableMappings.set(at, mapping);
+			// Indexed by piece rather than a `Map`: pieces are dense integers, and
+			// nearly every rule minifying goes out as one.
+			if (this._retractableMappings === null) this._retractableMappings = [];
+			this._retractableMappings[at] = mapping;
 		}
 		return at;
 	}
@@ -612,7 +643,7 @@ class PrintContext {
 		this._emit(
 			text === undefined ? this.get(/** @type {TNode} */ (node)) : text
 		);
-		this._gen++;
+		this._moveEpoch();
 	}
 
 	/**
@@ -724,68 +755,44 @@ class PrintContext {
 
 	/**
 	 * @param {SourceMapOptions} options the input's name / content
+	 * @param {string=} code the output {@link result} built, walked for its line breaks
 	 * @returns {SourceMap} the input->output source map
 	 */
-	sourceMap(options) {
+	sourceMap(options, code) {
 		let out = "";
 		let genLine = 0;
 		let genCol = 0;
 		let srcLine = 0;
 		let srcCol = 0;
 		let atLineStart = true;
-		// Where each anchor landed, walked once alongside the mappings — both are
-		// in output order, so this is one pass over the output, not a position
-		// recomputed per mapping. An anchor can sit inside a piece rather than at
-		// its start, since output accumulates into the piece it is appending to.
+		// Walked over the flat output rather than piece by piece: a piece is a rope
+		// until something reads it, and reading each one flattens each one.
+		const text = code === undefined ? this.result() : code;
 		const chunks = this._chunks;
-		const tail = this._tail;
-		/**
-		 * @param {number} i piece index, `chunks.length` being the tail
-		 * @returns {string} that piece
-		 */
-		const pieceAt = (i) => (i === chunks.length ? tail : chunks[i]);
 		let atChunk = 0;
+		let chunkStart = 0;
 		let atOffset = 0;
 		let atLine = 0;
 		let atCol = 0;
-		// Offset of the next newline at or after the cursor, `-1` for none left in
-		// this piece. Carried rather than searched for per mapping: `indexOf` has no
-		// end bound, so asking it again for each of a piece's mappings scans again to
-		// the end of the piece every time — and minified output, the case with no
-		// newlines at all, is the one where that is the whole piece.
-		let nextNewline = pieceAt(0).indexOf("\n");
-		/**
-		 * @param {string} text the piece to walk
-		 * @param {number} to offset to walk to
-		 */
-		const advanceOver = (text, to) => {
-			while (nextNewline !== -1 && nextNewline < to) {
-				atLine++;
-				atCol = 0;
-				atOffset = nextNewline + 1;
-				nextNewline = text.indexOf("\n", atOffset);
-			}
-			atCol += to - atOffset;
-			atOffset = to;
-		};
-		/**
-		 * @param {number} chunk piece index to advance to
-		 * @param {number} offset offset within it
-		 */
-		const advanceTo = (chunk, offset) => {
-			while (atChunk < chunk) {
-				const text = pieceAt(atChunk);
-				advanceOver(text, text.length);
-				atChunk++;
-				atOffset = 0;
-				nextNewline = pieceAt(atChunk).indexOf("\n");
-			}
-			if (offset > atOffset) advanceOver(pieceAt(atChunk), offset);
-		};
+		// Offset of the next newline at or after the cursor, `-1` for none left.
+		// Carried rather than searched for per mapping: `indexOf` has no end bound.
+		let nextNewline = text.indexOf("\n");
 		for (const [chunkIndex, chunkOffset, sl, sc] of this._mappings) {
 			// Its piece was taken back, so there is no output left to anchor.
 			if (sl === -1) continue;
-			advanceTo(chunkIndex, chunkOffset);
+			// A piece's length is stored, so summing them costs nothing per byte.
+			while (atChunk < chunkIndex) chunkStart += chunks[atChunk++].length;
+			const to = chunkStart + chunkOffset;
+			if (to > atOffset) {
+				while (nextNewline !== -1 && nextNewline < to) {
+					atLine++;
+					atCol = 0;
+					atOffset = nextNewline + 1;
+					nextNewline = text.indexOf("\n", atOffset);
+				}
+				atCol += to - atOffset;
+				atOffset = to;
+			}
 			const gl = atLine;
 			const gc = atCol;
 			while (genLine < gl) {
@@ -900,7 +907,11 @@ class PrintContext {
 		if (this._insertIdx < this._inserts.length) this._flushBefore(Infinity);
 		// Nothing was ever cut into its own piece, so there is nothing to join.
 		const chunks = this._chunks;
-		return chunks.length === 0 ? this._tail : chunks.join("") + this._tail;
+		if (chunks.length === 0) return this._tail;
+		// The tail joins as a piece of its own, so the output comes back flat
+		// rather than as a rope over the join that every reader flattens again.
+		this._cutTail();
+		return chunks.join("");
 	}
 }
 
@@ -1003,10 +1014,9 @@ class SourceProcessor {
 			this._grammar(input, this._visitors, undefined, opts);
 			return undefined;
 		}
-		// Handed over whole rather than copied entry by entry: which of them are
-		// print options is the language's to say, and listing them here is what
-		// made every new one an edit to this file. A grammar-only entry riding
-		// along is inert — a printer reads only what its own type declares.
+		// Handed over whole rather than copied entry by entry: which entries are
+		// print options is the language's to say, and a grammar-only one riding
+		// along is inert, since a printer reads only what its own type declares.
 		const ctx = new PrintContext(
 			/** @type {PrintOptions & TPrintOptions} */ (
 				/** @type {unknown} */ ({ ...opts, mode: asked })
@@ -1015,16 +1025,21 @@ class SourceProcessor {
 		);
 		this._grammar(input, this._visitors, ctx, opts);
 		const name = /** @type {{ source?: string, content?: string }} */ (opts);
-		const build = () => ({
-			code: ctx.result(),
-			// Built only for a caller that named the input: building one walks the
-			// whole output for its line breaks, and the minifier prints an inline
-			// `style=""` — which asks for no map — thousands of times a document.
-			map:
-				name.source === undefined
-					? undefined
-					: ctx.sourceMap({ source: name.source, content: name.content })
-		});
+		const build = () => {
+			const code = ctx.result();
+			return {
+				code,
+				// Built only for a caller that named the input: a map walks the whole
+				// output, and an inline `style=""` asks for none thousands of times a page.
+				map:
+					name.source === undefined
+						? undefined
+						: ctx.sourceMap(
+								{ source: name.source, content: name.content },
+								code
+							)
+			};
+		};
 		if (this._deferred !== null) {
 			const finish = this._deferred;
 
@@ -1142,4 +1157,5 @@ class SourceProcessor {
 SourceProcessor.PrintContext = PrintContext;
 
 module.exports = SourceProcessor;
+module.exports.declineDeferredWrites = declineDeferredWrites;
 module.exports.deferredWrite = deferredWrite;

package/lib/util/URLAbsoluteSpecifier.js

@@ -17,6 +17,7 @@ const _0CharCode = "0".charCodeAt(0);
 const _9CharCode = "9".charCodeAt(0);
 const plusCharCode = "+".charCodeAt(0);
 const hyphenCharCode = "-".charCodeAt(0);
+const dotCharCode = ".".charCodeAt(0);
 const colonCharCode = ":".charCodeAt(0);
 const hashCharCode = "#".charCodeAt(0);
 const queryCharCode = "?".charCodeAt(0);
@@ -46,7 +47,8 @@ function getScheme(specifier) {
 		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
 		(ch >= _0CharCode && ch <= _9CharCode) ||
 		ch === plusCharCode ||
-		ch === hyphenCharCode
+		ch === hyphenCharCode ||
+		ch === dotCharCode
 	) {
 		if (++i === specifier.length) return;
 		ch = specifier.charCodeAt(i);