@depup/webpack-sources 3.3.4-depup.0 → 3.6.0-depup.0

package/lib/helpers/streamAndGetSourceAndMap.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const createMappingsSerializer = require("./createMappingsSerializer");
+const { createMappingsWriter } = require("./createMappingsSerializer");
 const streamChunks = require("./streamChunks");
 
 /** @typedef {import("../Source").RawSourceMap} RawSourceMap */
@@ -16,6 +16,20 @@ const streamChunks = require("./streamChunks");
 /** @typedef {import("./streamChunks").Options} Options */
 /** @typedef {import("./streamChunks").SourceMaybeWithStreamChunksFunction} SourceMaybeWithStreamChunksFunction */
 
+/** @type {typeof import("./scopes") | undefined} */
+let scopesHelpers;
+
+/**
+ * Loads the scopes helpers on first use. They are only reachable through the
+ * `scopes` option, so requiring them eagerly would put the encoder in the
+ * module graph of every caller that never asks for the field.
+ * @returns {ReturnType<typeof import("./scopes").createScopesWriter>} writer
+ */
+const createScopesWriter = () => {
+	if (scopesHelpers === undefined) scopesHelpers = require("./scopes");
+	return scopesHelpers.createScopesWriter();
+};
+
 /**
  * @param {SourceMaybeWithStreamChunksFunction} inputSource input source
  * @param {Options} options options
@@ -32,18 +46,26 @@ const streamAndGetSourceAndMap = (
 	onName,
 ) => {
 	let code = "";
-	let mappings = "";
 	/** @type {(string | null)[]} */
 	const potentialSources = [];
 	/** @type {(string | null)[]} */
 	const potentialSourcesContent = [];
 	/** @type {(string | null)[]} */
 	const potentialNames = [];
-	const addMapping = createMappingsSerializer({ ...options, columns: true });
+	const mappingsWriter = createMappingsWriter({ ...options, columns: true });
+	const addMapping = mappingsWriter.add;
+	const scopesWriter =
+		options && options.scopes ? createScopesWriter() : undefined;
 	const finalSource = Boolean(options && options.finalSource);
+	// The caller may have passed `source: false` (getMap does), but this
+	// helper caches the source text, so the inner stream must produce it.
+	const innerOptions =
+		options && options.source === false
+			? { ...options, source: true }
+			: options;
 	const { generatedLine, generatedColumn, source } = streamChunks(
 		inputSource,
-		options,
+		innerOptions,
 		(
 			chunk,
 			generatedLine,
@@ -54,7 +76,7 @@ const streamAndGetSourceAndMap = (
 			nameIndex,
 		) => {
 			if (chunk !== undefined) code += chunk;
-			mappings += addMapping(
+			addMapping(
 				generatedLine,
 				generatedColumn,
 				sourceIndex,
@@ -62,6 +84,14 @@ const streamAndGetSourceAndMap = (
 				originalColumn,
 				nameIndex,
 			);
+			if (scopesWriter !== undefined) {
+				scopesWriter.add(
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+				);
+			}
 			return onChunk(
 				finalSource ? undefined : chunk,
 				generatedLine,
@@ -72,7 +102,7 @@ const streamAndGetSourceAndMap = (
 				nameIndex,
 			);
 		},
-		(sourceIndex, source, sourceContent) => {
+		(sourceIndex, source, sourceContent, scopeBindings) => {
 			while (potentialSources.length < sourceIndex) {
 				potentialSources.push(null);
 			}
@@ -83,7 +113,10 @@ const streamAndGetSourceAndMap = (
 				}
 				potentialSourcesContent[sourceIndex] = sourceContent;
 			}
-			return onSource(sourceIndex, source, sourceContent);
+			if (scopesWriter !== undefined) {
+				scopesWriter.addSource(sourceIndex, scopeBindings);
+			}
+			return onSource(sourceIndex, source, sourceContent, scopeBindings);
 		},
 		(nameIndex, name) => {
 			while (potentialNames.length < nameIndex) {
@@ -94,6 +127,26 @@ const streamAndGetSourceAndMap = (
 		},
 	);
 	const resultSource = source !== undefined ? source : code;
+	const mappings = mappingsWriter.finish();
+	/** @type {RawSourceMap | null} */
+	let map = null;
+	if (mappings.length > 0) {
+		map = {
+			version: 3,
+			file: "x",
+			mappings,
+			// We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
+			sources: /** @type {string[]} */ (potentialSources),
+			sourcesContent:
+				potentialSourcesContent.length > 0
+					? /** @type {string[]} */ (potentialSourcesContent)
+					: undefined,
+			names: /** @type {string[]} */ (potentialNames),
+		};
+		if (scopesWriter !== undefined) {
+			scopesWriter.finish(map, generatedLine || 0, generatedColumn || 0);
+		}
+	}
 
 	return {
 		result: {
@@ -102,21 +155,7 @@ const streamAndGetSourceAndMap = (
 			source: finalSource ? resultSource : undefined,
 		},
 		source: resultSource,
-		map:
-			mappings.length > 0
-				? {
-						version: 3,
-						file: "x",
-						mappings,
-						// We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
-						sources: /** @type {string[]} */ (potentialSources),
-						sourcesContent:
-							potentialSourcesContent.length > 0
-								? /** @type {string[]} */ (potentialSourcesContent)
-								: undefined,
-						names: /** @type {string[]} */ (potentialNames),
-					}
-				: null,
+		map,
 	};
 };
 

package/lib/helpers/streamChunks.js

@@ -11,10 +11,11 @@ const streamChunksOfSourceMap = require("./streamChunksOfSourceMap");
 /** @typedef {import("../Source")} Source */
 /** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
 /** @typedef {(chunk: string | undefined, generatedLine: number, generatedColumn: number, sourceIndex: number, originalLine: number, originalColumn: number, nameIndex: number) => void} OnChunk */
-/** @typedef {(sourceIndex: number, source: string | null, sourceContent: string | undefined) => void} OnSource */
+/** @typedef {Map<string, string>} ScopeBindings */
+/** @typedef {(sourceIndex: number, source: string | null, sourceContent: string | undefined, scopeBindings?: ScopeBindings) => void} OnSource */
 /** @typedef {(nameIndex: number, name: string) => void} OnName */
 
-/** @typedef {{ source?: boolean, finalSource?: boolean, columns?: boolean }} Options */
+/** @typedef {{ source?: boolean, finalSource?: boolean, columns?: boolean, scopes?: boolean }} Options */
 
 /**
  * @callback StreamChunksFunction

package/lib/helpers/streamChunksOfCombinedSourceMap.js

@@ -76,7 +76,11 @@ const streamChunksOfCombinedSourceMap = (
 		if (line > innerSourceMapLineData.length) return -1;
 		const { mappingsData } = innerSourceMapLineData[line - 1];
 		let l = 0;
-		let r = mappingsData.length / 5;
+		// `mappingsData.length` is always a multiple of 5 (five values pushed
+		// per mapping), so dividing is exact. Coerce the bound to an int32 so
+		// the binary-search loop stays on V8's fast small-int path instead of
+		// comparing an int against a float.
+		let r = (mappingsData.length / 5) | 0;
 		while (l < r) {
 			const m = (l + r) >> 1;
 			if (mappingsData[m * 5] <= column) {
@@ -297,7 +301,7 @@ const streamChunksOfCombinedSourceMap = (
 				);
 			}
 		},
-		(i, source, sourceContent) => {
+		(i, source, sourceContent, scopeBindings) => {
 			if (source === innerSourceName) {
 				outerSourceIndex = i;
 				if (innerSource !== undefined) sourceContent = innerSource;
@@ -349,7 +353,7 @@ const streamChunksOfCombinedSourceMap = (
 				let globalIndex = sourceMapping.get(source);
 				if (globalIndex === undefined) {
 					sourceMapping.set(source, (globalIndex = sourceMapping.size));
-					onSource(globalIndex, source, sourceContent);
+					onSource(globalIndex, source, sourceContent, scopeBindings);
 				}
 				sourceIndexMapping[i] = globalIndex;
 			}

package/lib/helpers/streamChunksOfRawSource.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const getGeneratedSourceInfo = require("./getGeneratedSourceInfo");
-const splitIntoLines = require("./splitIntoLines");
 
 /** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
 /** @typedef {import("./streamChunks").OnChunk} OnChunk */
@@ -19,25 +18,34 @@ const splitIntoLines = require("./splitIntoLines");
  * @param {OnSource} _onSource on source
  * @param {OnName} _onName on name
  * @returns {GeneratedSourceInfo} source info
+ *
+ * Single-pass equivalent of `splitIntoLines(source).forEach(emit)` — emits
+ * each line via onChunk while scanning for newlines, so we never allocate
+ * the intermediate array of lines.
  */
 const streamChunksOfRawSource = (source, onChunk, _onSource, _onName) => {
+	const len = source.length;
+	if (len === 0) {
+		return { generatedLine: 1, generatedColumn: 0 };
+	}
 	let line = 1;
-	const matches = splitIntoLines(source);
-	/** @type {undefined | string} */
-	let match;
-	for (match of matches) {
-		onChunk(match, line, 0, -1, -1, -1, -1);
+	let i = 0;
+	while (i < len) {
+		const n = source.indexOf("\n", i);
+		if (n === -1) {
+			// Trailing partial line (no \n). Emit and return its length as the
+			// final column.
+			const lastLine = i === 0 ? source : source.slice(i);
+			onChunk(lastLine, line, 0, -1, -1, -1, -1);
+			return { generatedLine: line, generatedColumn: lastLine.length };
+		}
+		const chunk = n === i ? "\n" : source.slice(i, n + 1);
+		onChunk(chunk, line, 0, -1, -1, -1, -1);
 		line++;
+		i = n + 1;
 	}
-	return matches.length === 0 || /** @type {string} */ (match).endsWith("\n")
-		? {
-				generatedLine: matches.length + 1,
-				generatedColumn: 0,
-			}
-		: {
-				generatedLine: matches.length,
-				generatedColumn: /** @type {string} */ (match).length,
-			};
+	// Source ended with a newline — the next "logical" line is empty.
+	return { generatedLine: line, generatedColumn: 0 };
 };
 
 /**

package/lib/helpers/streamChunksOfSourceMap.js

@@ -32,7 +32,8 @@ const streamChunksOfSourceMapFull = (
 	onName,
 ) => {
 	const lines = splitIntoLines(source);
-	if (lines.length === 0) {
+	const linesLength = lines.length;
+	if (linesLength === 0) {
 		return {
 			generatedLine: 1,
 			generatedColumn: 0,
@@ -52,9 +53,9 @@ const streamChunksOfSourceMapFull = (
 		}
 	}
 
-	const lastLine = lines[lines.length - 1];
+	const lastLine = lines[linesLength - 1];
 	const lastNewLine = lastLine.endsWith("\n");
-	const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+	const finalLine = lastNewLine ? linesLength + 1 : linesLength;
 	const finalColumn = lastNewLine ? 0 : lastLine.length;
 
 	let currentGeneratedLine = 1;
@@ -83,7 +84,7 @@ const streamChunksOfSourceMapFull = (
 		originalColumn,
 		nameIndex,
 	) => {
-		if (mappingActive && currentGeneratedLine <= lines.length) {
+		if (mappingActive && currentGeneratedLine <= linesLength) {
 			let chunk;
 			const mappingLine = currentGeneratedLine;
 			const mappingColumn = currentGeneratedColumn;
@@ -110,7 +111,7 @@ const streamChunksOfSourceMapFull = (
 			mappingActive = false;
 		}
 		if (generatedLine > currentGeneratedLine && currentGeneratedColumn > 0) {
-			if (currentGeneratedLine <= lines.length) {
+			if (currentGeneratedLine <= linesLength) {
 				const chunk = lines[currentGeneratedLine - 1].slice(
 					currentGeneratedColumn,
 				);
@@ -127,22 +128,29 @@ const streamChunksOfSourceMapFull = (
 			currentGeneratedLine++;
 			currentGeneratedColumn = 0;
 		}
-		while (generatedLine > currentGeneratedLine) {
-			if (currentGeneratedLine <= lines.length) {
-				onChunk(
-					lines[currentGeneratedLine - 1],
-					currentGeneratedLine,
-					0,
-					-1,
-					-1,
-					-1,
-					-1,
-				);
-			}
+		// Emit each fully-passed generated line. Once we move past the last
+		// available line we stop emitting, but still need to advance the
+		// counter to `generatedLine` so subsequent state matches the caller.
+		while (
+			generatedLine > currentGeneratedLine &&
+			currentGeneratedLine <= linesLength
+		) {
+			onChunk(
+				lines[currentGeneratedLine - 1],
+				currentGeneratedLine,
+				0,
+				-1,
+				-1,
+				-1,
+				-1,
+			);
 			currentGeneratedLine++;
 		}
+		if (currentGeneratedLine < generatedLine) {
+			currentGeneratedLine = generatedLine;
+		}
 		if (generatedColumn > currentGeneratedColumn) {
-			if (currentGeneratedLine <= lines.length) {
+			if (currentGeneratedLine <= linesLength) {
 				const chunk = lines[currentGeneratedLine - 1].slice(
 					currentGeneratedColumn,
 					generatedColumn,
@@ -195,7 +203,8 @@ const streamChunksOfSourceMapLinesFull = (
 	_onName,
 ) => {
 	const lines = splitIntoLines(source);
-	if (lines.length === 0) {
+	const linesLength = lines.length;
+	if (linesLength === 0) {
 		return {
 			generatedLine: 1,
 			generatedColumn: 0,
@@ -232,39 +241,38 @@ const streamChunksOfSourceMapLinesFull = (
 		if (
 			sourceIndex < 0 ||
 			generatedLine < currentGeneratedLine ||
-			generatedLine > lines.length
+			generatedLine > linesLength
 		) {
 			return;
 		}
+		// `generatedLine <= linesLength` is guaranteed by the guard above, so
+		// every line we iterate over is in bounds — no per-iteration length
+		// check needed.
 		while (generatedLine > currentGeneratedLine) {
-			if (currentGeneratedLine <= lines.length) {
-				onChunk(
-					lines[currentGeneratedLine - 1],
-					currentGeneratedLine,
-					0,
-					-1,
-					-1,
-					-1,
-					-1,
-				);
-			}
-			currentGeneratedLine++;
-		}
-		if (generatedLine <= lines.length) {
 			onChunk(
-				lines[generatedLine - 1],
-				generatedLine,
+				lines[currentGeneratedLine - 1],
+				currentGeneratedLine,
 				0,
-				sourceIndex,
-				originalLine,
-				originalColumn,
+				-1,
+				-1,
+				-1,
 				-1,
 			);
 			currentGeneratedLine++;
 		}
+		onChunk(
+			lines[generatedLine - 1],
+			generatedLine,
+			0,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			-1,
+		);
+		currentGeneratedLine++;
 	};
 	readMappings(mappings, onMapping);
-	for (; currentGeneratedLine <= lines.length; currentGeneratedLine++) {
+	for (; currentGeneratedLine <= linesLength; currentGeneratedLine++) {
 		onChunk(
 			lines[currentGeneratedLine - 1],
 			currentGeneratedLine,
@@ -276,10 +284,10 @@ const streamChunksOfSourceMapLinesFull = (
 		);
 	}
 
-	const lastLine = lines[lines.length - 1];
+	const lastLine = lines[linesLength - 1];
 	const lastNewLine = lastLine.endsWith("\n");
 
-	const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+	const finalLine = lastNewLine ? linesLength + 1 : linesLength;
 	const finalColumn = lastNewLine ? 0 : lastLine.length;
 
 	return {

package/lib/index.js

@@ -112,6 +112,9 @@ module.exports = mergeExports(
 			return require("./CompatSource");
 		},
 		util: {
+			get scopes() {
+				return require("./helpers/scopes");
+			},
 			get stringBufferUtils() {
 				return require("./helpers/stringBufferUtils");
 			},

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@depup/webpack-sources",
-  "version": "3.3.4-depup.0",
-  "description": "[DepUp] Source code handling classes for webpack",
+  "version": "3.6.0-depup.0",
+  "description": "Source code handling classes for webpack (with updated dependencies)",
   "keywords": [
-    "depup",
-    "dependency-bumped",
-    "updated-deps",
     "webpack-sources",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
     "webpack",
     "source-map"
   ],
@@ -24,38 +26,47 @@
   "types": "types.d.ts",
   "files": [
     "lib/",
+    "types/",
     "types.d.ts",
     "changes.json",
     "README.md"
   ],
   "scripts": {
-    "lint": "npm run lint:code && npm run lint:types && npm run lint:types-test && npm run lint:special",
+    "lint": "npm run lint:code && npm run lint:types && npm run lint:types-test",
     "lint:code": "eslint --cache .",
-    "lint:special": "node node_modules/tooling/inherit-types && node node_modules/tooling/format-file-header && node node_modules/tooling/generate-types",
     "lint:types": "tsc",
     "lint:types-test": "tsc -p tsconfig.types.test.json",
     "fmt": "npm run fmt:base -- --loglevel warn --write",
     "fmt:check": "npm run fmt:base -- --check",
     "fmt:base": "prettier --cache --ignore-unknown .",
-    "fix": "npm run fix:code && npm run fix:special",
+    "fix": "npm run fix:code && npm run build:types",
     "fix:code": "npm run lint:code -- --fix",
-    "fix:special": "node node_modules/tooling/inherit-types --write && node node_modules/tooling/format-file-header --write && node node_modules/tooling/generate-types --write",
+    "build:types": "del-cli types && tsc -p tsconfig.types.json && prettier --log-level warn --write types",
     "pretest": "npm run lint",
-    "test": "jest",
-    "cover": "jest --coverage"
+    "test": "node --require ./test/helpers/validate-mappings.js --test --test-reporter=dot \"test/*.js\"",
+    "test:coverage": "node --require ./test/helpers/validate-mappings.js --test --experimental-test-coverage --test-coverage-include=\"lib/**\" --test-reporter=dot --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=lcov.info \"test/*.js\"",
+    "test:update-snapshots": "node --require ./test/helpers/validate-mappings.js --test --test-reporter=dot --test-update-snapshots \"test/*.js\"",
+    "test:legacy": "jest",
+    "test:legacy:coverage": "jest --coverage",
+    "benchmark": "node --max-old-space-size=4096 --hash-seed=1 --random-seed=1 --no-opt --predictable --predictable-gc-schedule --interpreted-frames-native-stack --allow-natives-syntax --expose-gc --no-concurrent-sweeping ./benchmark/run.mjs cases",
+    "benchmark:memory": "node --expose-gc --max-old-space-size=4096 ./benchmark/run.mjs memory",
+    "version": "changeset version && npm run fmt",
+    "release": "changeset publish"
   },
   "devDependencies": {
-    "@types/jest": "^27.5.2",
-    "eslint": "^9.28.0",
-    "eslint-config-webpack": "^4.0.8",
-    "jest": "^27.5.1",
-    "prettier": "^3.5.3",
-    "prettier-2": "npm:prettier@^2",
-    "source-map": "^0.7.3",
+    "@changesets/cli": "^3.0.3",
+    "@changesets/get-github-info": "^1.0.1",
+    "@codspeed/core": "^5.5.0",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.39.5",
+    "eslint-config-webpack": "^4.14.0",
+    "jest": "^30.5.2",
+    "prettier": "^3.9.9",
+    "source-map": "^0.8.0",
     "sourcemap-validator": "^2.1.0",
-    "tooling": "webpack/tooling#v1.24.4",
-    "typescript": "^5.3.3",
-    "webpack": "^5.99.9"
+    "tinybench": "^6.0.0",
+    "typescript": "^6.0.2",
+    "webpack": "^5.107.2"
   },
   "engines": {
     "node": ">=10.13.0"
@@ -64,8 +75,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "webpack-sources",
-    "originalVersion": "3.3.4",
-    "processedAt": "2026-03-17T16:39:45.942Z",
+    "originalVersion": "3.6.0",
+    "processedAt": "2026-09-27T01:03:20.180Z",
     "smokeTest": "passed"
   }
 }