webpack 5.108.2 → 5.108.4

package/lib/javascript/JavascriptParser.js

@@ -1383,6 +1383,16 @@ class JavascriptParser extends Parser {
 				return handleConstOperation((l, r) => l <= r);
 			} else if (expr.operator === ">=") {
 				return handleConstOperation((l, r) => l >= r);
+			} else if (expr.operator === "in") {
+				// `x in y` always evaluates to a boolean, so it is never nullish
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				return new BasicEvaluatedExpression()
+					.setNullish(false)
+					.setSideEffects(
+						left.couldHaveSideEffects() || right.couldHaveSideEffects()
+					)
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
 		this.hooks.evaluate.for("UnaryExpression").tap(CLASS_NAME, (_expr) => {

package/lib/url/URLParserPlugin.js

@@ -56,6 +56,32 @@ const isMetaUrl = (parser, arg) => {
 	return true;
 };
 
+/**
+ * Whether the request points to a directory and thus can't be an asset.
+ * @param {string} request request
+ * @returns {boolean} true when the request is a directory reference
+ */
+const isDirectoryRequest = (request) =>
+	request === "." || request === ".." || request.endsWith("/");
+
+/**
+ * Replaces `import.meta.url` with the runtime base URI, leaving the
+ * `new URL(...)` construction untouched so it's evaluated at runtime.
+ * @param {JavascriptParser} parser parser
+ * @param {NewExpressionNode} expr expression
+ * @returns {void}
+ */
+const keepNewURL = (parser, expr) => {
+	const [, arg2] = expr.arguments;
+	const dep = new ConstDependency(
+		RuntimeGlobals.baseURI,
+		/** @type {Range} */ (arg2.range),
+		[RuntimeGlobals.baseURI]
+	);
+	dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+	parser.state.module.addPresentationalDependency(dep);
+};
+
 /** @type {WeakMap<NewExpressionNode, BasicEvaluatedExpression | undefined>} */
 const getEvaluatedExprCache = new WeakMap();
 
@@ -157,13 +183,7 @@ class URLParserPlugin {
 						return;
 					}
 
-					const dep = new ConstDependency(
-						RuntimeGlobals.baseURI,
-						/** @type {Range} */ (arg2.range),
-						[RuntimeGlobals.baseURI]
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addPresentationalDependency(dep);
+					keepNewURL(parser, expr);
 
 					return true;
 				}
@@ -177,6 +197,12 @@ class URLParserPlugin {
 
 			// static URL
 			if ((request = evaluatedExpr.asString())) {
+				// A directory is not an asset; keep `new URL(...)` as-is, matching Node/browsers.
+				if (isDirectoryRequest(request)) {
+					keepNewURL(parser, expr);
+					return true;
+				}
+
 				const [arg1, arg2] = expr.arguments;
 				const dep = new URLDependency(
 					request,

package/lib/util/LocConverter.js

@@ -29,17 +29,18 @@ class LocConverter {
 	get(pos) {
 		if (this.pos !== pos) {
 			if (this.pos < pos) {
-				const str = this._input.slice(this.pos, pos);
-				let i = str.lastIndexOf("\n");
-				if (i === -1) {
-					this.column += str.length;
-				} else {
-					this.column = str.length - i - 1;
-					this.line++;
-					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1) {
+				// Advance: delta-bounded scan of [this.pos, pos), allocation-free
+				// (unbounded index scans go quadratic on newline-free input).
+				const input = this._input;
+				let last = -1;
+				for (let j = this.pos; j < pos; j++) {
+					if (input.charCodeAt(j) === 10) {
 						this.line++;
+						last = j;
 					}
 				}
+				this.column =
+					last === -1 ? this.column + (pos - this.pos) : pos - last - 1;
 			} else {
 				// Retreat: count newlines crossed in (pos, this.pos), i.e.
 				// exclude the newline at `this.pos` itself. By convention a

package/lib/util/SourceProcessor.js

@@ -6,36 +6,41 @@
 
 /**
  * Babel-style visitor map keyed by a numeric node-type discriminator; a bucket
- * is a function (enter-only) or `{ enter?, exit? }`. `ctx.skipChildren()`
- * (enter only) stops the walker descending into the node's children.
- * @typedef {{ skipChildren(): void }} VisitorContext
- */
-/**
- * @template TNode
- * @typedef {(node: TNode, parent: TNode | null, ctx: VisitorContext) => void} VisitorFn
+ * is a function (enter-only) or `{ enter?, exit? }`.
+ *
+ * A visitor receives a single `path` argument (the Babel `path` shape): the
+ * language's AST accessor with the current position on it — `path.node`,
+ * `path.parent` (null at a root) — plus `path.skipChildren()` (enter only)
+ * to stop the walk descending, and every field-read method (which defaults
+ * to the current node). The path is one reused object rebound before each callback:
+ * it is only valid during the callback, and future per-node functionality
+ * lands on it without changing any visitor signature.
+ * @template TPath
+ * @typedef {(path: TPath) => void} VisitorFn
  */
 /**
- * @template TNode
- * @typedef {VisitorFn<TNode> | { enter?: VisitorFn<TNode>, exit?: VisitorFn<TNode> }} VisitorBucket
+ * @template TPath
+ * @typedef {VisitorFn<TPath> | { enter?: VisitorFn<TPath>, exit?: VisitorFn<TPath> }} VisitorBucket
  */
 /**
- * @template TNode
- * @typedef {{ [nodeType: number]: VisitorBucket<TNode> }} VisitorMap
+ * @template TPath
+ * @typedef {{ [nodeType: number]: VisitorBucket<TPath> }} VisitorMap
  */
 /**
- * @template TNode
- * @typedef {{ enter: VisitorFn<TNode>[], exit: VisitorFn<TNode>[] }} CompiledVisitorBucket
+ * @template TPath
+ * @typedef {{ enter: VisitorFn<TPath>[], exit: VisitorFn<TPath>[] }} CompiledVisitorBucket
  */
 /**
- * @template TNode
- * @typedef {CompiledVisitorBucket<TNode>[]} CompiledVisitorMap a sparse array indexed by node type
+ * @template TPath
+ * @typedef {CompiledVisitorBucket<TPath>[]} CompiledVisitorMap a sparse array indexed by node type
  */
 /**
  * A language grammar: parse `input` and fire the compiled visitors in source
- * order (the grammar owns tokenizing, parsing, and walking).
- * @template TNode
+ * order (the grammar owns tokenizing, parsing, walking — and the `path`
+ * object each visitor receives).
+ * @template TPath
  * @template TProcessOptions
- * @typedef {(input: string, visitors: CompiledVisitorMap<TNode>, options: TProcessOptions) => void} Grammar
+ * @typedef {(input: string, visitors: CompiledVisitorMap<TPath>, options: TProcessOptions) => void} Grammar
  */
 
 /**
@@ -44,28 +49,31 @@
  * binds its own grammar and node-type enum. Babel-style usage:
  *
  * ```
- * processor.use({ [NodeType.X]: (node) => {}, [NodeType.Y]: { enter, exit } });
+ * processor.use({ [NodeType.X]: (path) => {}, [NodeType.Y]: { enter, exit } });
  * processor.process(source);
  * ```
- * @template TNode
+ * @template TPath
  * @template [TProcessOptions=object]
  */
 class SourceProcessor {
 	/**
-	 * @param {Grammar<TNode, TProcessOptions>} grammar the grammar to drive over the source
+	 * @param {Grammar<TPath, TProcessOptions>} grammar the grammar to drive over the source
+	 * @param {TProcessOptions=} options default process options (e.g. `skip`) merged under each `process` call's own options
 	 */
-	constructor(grammar) {
-		/** @type {Grammar<TNode, TProcessOptions>} */
+	constructor(grammar, options) {
+		/** @type {Grammar<TPath, TProcessOptions>} */
 		this._grammar = grammar;
-		/** @type {CompiledVisitorMap<TNode>} */
+		/** @type {CompiledVisitorMap<TPath>} */
 		this._visitors = [];
+		/** @type {TProcessOptions | undefined} */
+		this._options = options;
 	}
 
 	/**
 	 * Register a Babel-style visitor map; calls accumulate per node type.
 	 * A bucket is a function (= `{ enter }`) or `{ enter?, exit? }`.
-	 * @param {VisitorMap<TNode>} map visitor map keyed by node type
-	 * @returns {SourceProcessor<TNode, TProcessOptions>} `this`, for chaining
+	 * @param {VisitorMap<TPath>} map visitor map keyed by node type
+	 * @returns {SourceProcessor<TPath, TProcessOptions>} `this`, for chaining
 	 */
 	use(map) {
 		// `map`'s keys are node-type enum members; `Object.keys` stringifies them,
@@ -90,15 +98,20 @@ class SourceProcessor {
 
 	/**
 	 * Run the grammar over `input`, firing visitors in source order. No
-	 * AST retained.
+	 * AST retained. Per-call `options` override the instance defaults.
 	 * @param {string} input source text
 	 * @param {TProcessOptions=} options grammar-specific options
 	 */
 	process(input, options) {
+		const defaults = this._options;
 		this._grammar(
 			input,
 			this._visitors,
-			options || /** @type {TProcessOptions} */ ({})
+			defaults
+				? options
+					? { ...defaults, ...options }
+					: defaults
+				: options || /** @type {TProcessOptions} */ ({})
 		);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.108.2",
+  "version": "5.108.4",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",
@@ -176,7 +176,7 @@
     "node-gyp": "^13.0.0",
     "nyc": "^18.0.0",
     "open-cli": "^9.0.0",
-    "oxc-parser": "^0.137.0",
+    "oxc-parser": "^0.138.0",
     "pkg-pr-new": "^0.0.75",
     "prettier": "^3.8.2",
     "prettier-2": "npm:prettier@^2",
@@ -197,7 +197,7 @@
     "simple-git": "^3.28.0",
     "style-loader": "^4.0.0",
     "terser": "^5.46.2",
-    "three": "^0.184.0",
+    "three": "^0.185.1",
     "tinybench": "^6.0.1",
     "toml": "^4.1.1",
     "tooling": "webpack/tooling#v1.26.4",