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

package/lib/helpers/getFromStreamChunks.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const createMappingsSerializer = require("./createMappingsSerializer");
+const { createMappingsWriter } = require("./createMappingsSerializer");
 
 /** @typedef {import("../Source").RawSourceMap} RawSourceMap */
 /** @typedef {import("../Source").SourceAndMap} SourceAndMap */
@@ -14,73 +14,141 @@ const createMappingsSerializer = require("./createMappingsSerializer");
 
 /** @typedef {{ streamChunks: StreamChunksFunction }} SourceLikeWithStreamChunks */
 
+/** @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();
+};
+
+/**
+ * Assign `value` at index `i` of `arr`, padding earlier slots with `null`.
+ * Hoisted helper so `getMap` and `getSourceAndMap` share one
+ * implementation. Uses `push` rather than `arr.length = i + 1` because the
+ * latter forces V8's HOLEY_ELEMENTS kind permanently — push keeps the
+ * backing store PACKED, which the downstream source-map serializer iterates
+ * over far more efficiently.
+ * @template T
+ * @param {(T | null)[]} arr destination array
+ * @param {number} i index to assign
+ * @param {T} value value to assign
+ * @returns {void}
+ */
+const setAtIndex = (arr, i, value) => {
+	while (arr.length < i) arr.push(null);
+	// `arr[i] = value` where `i === arr.length` extends the array exactly
+	// like `push` (V8 keeps PACKED_ELEMENTS); after the while-loop
+	// `i <= arr.length` always, so the hole case that would force HOLEY is
+	// impossible here.
+	arr[i] = value;
+};
+
 /**
  * @param {SourceLikeWithStreamChunks} source source
  * @param {Options=} options options
  * @returns {RawSourceMap | null} map
  */
 module.exports.getMap = (source, options) => {
-	let mappings = "";
 	/** @type {(string | null)[]} */
 	const potentialSources = [];
 	/** @type {(string | null)[]} */
 	const potentialSourcesContent = [];
 	/** @type {(string | null)[]} */
 	const potentialNames = [];
-	const addMapping = createMappingsSerializer(options);
-	source.streamChunks(
+	const mappingsWriter = createMappingsWriter(options);
+	const addMapping = mappingsWriter.add;
+	const scopesWriter =
+		options && options.scopes ? createScopesWriter() : undefined;
+	// Chosen once rather than tested per segment: this callback is the whole of
+	// the mapping loop, so a branch in it is measurable on every map built.
+	const generated = source.streamChunks(
 		{ ...options, source: false, finalSource: true },
-		(
-			chunk,
-			generatedLine,
-			generatedColumn,
-			sourceIndex,
-			originalLine,
-			originalColumn,
-			nameIndex,
-		) => {
-			mappings += addMapping(
-				generatedLine,
-				generatedColumn,
-				sourceIndex,
-				originalLine,
-				originalColumn,
-				nameIndex,
-			);
-		},
-		(sourceIndex, source, sourceContent) => {
-			while (potentialSources.length < sourceIndex) {
-				potentialSources.push(null);
-			}
-			potentialSources[sourceIndex] = source;
-			if (sourceContent !== undefined) {
-				while (potentialSourcesContent.length < sourceIndex) {
-					potentialSourcesContent.push(null);
+		scopesWriter === undefined
+			? (
+					chunk,
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex,
+				) => {
+					addMapping(
+						generatedLine,
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn,
+						nameIndex,
+					);
 				}
-				potentialSourcesContent[sourceIndex] = sourceContent;
+			: (
+					chunk,
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex,
+				) => {
+					addMapping(
+						generatedLine,
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn,
+						nameIndex,
+					);
+					scopesWriter.add(
+						generatedLine,
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+					);
+				},
+		(sourceIndex, source, sourceContent, scopeBindings) => {
+			setAtIndex(potentialSources, sourceIndex, source);
+			if (sourceContent !== undefined) {
+				setAtIndex(potentialSourcesContent, sourceIndex, sourceContent);
+			}
+			if (scopesWriter !== undefined) {
+				scopesWriter.addSource(sourceIndex, scopeBindings);
 			}
 		},
 		(nameIndex, name) => {
-			while (potentialNames.length < nameIndex) {
-				potentialNames.push(null);
-			}
-			potentialNames[nameIndex] = name;
+			setAtIndex(potentialNames, nameIndex, name);
 		},
 	);
-	return 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;
+	const mappings = mappingsWriter.finish();
+	if (mappings.length === 0) return null;
+	/** @type {RawSourceMap} */
+	const 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,
+			generated.generatedLine,
+			generated.generatedColumn,
+		);
+	}
+	return map;
 };
 
 /**
@@ -90,16 +158,21 @@ module.exports.getMap = (source, options) => {
  */
 module.exports.getSourceAndMap = (inputSource, options) => {
 	let code = "";
-	let mappings = "";
 	/** @type {(string | null)[]} */
 	const potentialSources = [];
 	/** @type {(string | null)[]} */
 	const potentialSourcesContent = [];
 	/** @type {(string | null)[]} */
 	const potentialNames = [];
-	const addMapping = createMappingsSerializer(options);
-	const { source } = inputSource.streamChunks(
-		{ ...options, finalSource: true },
+	const mappingsWriter = createMappingsWriter(options);
+	const addMapping = mappingsWriter.add;
+	const scopesWriter =
+		options && options.scopes ? createScopesWriter() : undefined;
+	const generated = inputSource.streamChunks(
+		// `source: true` overrides any `source: false` a caller forwarded
+		// (e.g. the streamChunks fallback passing getMap options through
+		// sourceAndMap) — this helper always consumes the source.
+		{ ...options, finalSource: true, source: true },
 		(
 			chunk,
 			generatedLine,
@@ -110,7 +183,7 @@ module.exports.getSourceAndMap = (inputSource, options) => {
 			nameIndex,
 		) => {
 			if (chunk !== undefined) code += chunk;
-			mappings += addMapping(
+			addMapping(
 				generatedLine,
 				generatedColumn,
 				sourceIndex,
@@ -118,8 +191,19 @@ module.exports.getSourceAndMap = (inputSource, options) => {
 				originalColumn,
 				nameIndex,
 			);
+			if (scopesWriter !== undefined) {
+				scopesWriter.add(
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+				);
+			}
 		},
-		(sourceIndex, source, sourceContent) => {
+		(sourceIndex, source, sourceContent, scopeBindings) => {
+			if (scopesWriter !== undefined) {
+				scopesWriter.addSource(sourceIndex, scopeBindings);
+			}
 			while (potentialSources.length < sourceIndex) {
 				potentialSources.push(null);
 			}
@@ -138,22 +222,30 @@ module.exports.getSourceAndMap = (inputSource, options) => {
 			potentialNames[nameIndex] = name;
 		},
 	);
-	return {
-		source: source !== undefined ? source : code,
-		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,
-	};
+	const mappings = mappingsWriter.finish();
+	const { source } = generated;
+	/** @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,
+				generated.generatedLine,
+				generated.generatedColumn,
+			);
+		}
+	}
+	return { source: source !== undefined ? source : code, map };
 };

package/lib/helpers/getGeneratedSourceInfo.js

@@ -5,8 +5,6 @@
 
 "use strict";
 
-const CHAR_CODE_NEW_LINE = "\n".charCodeAt(0);
-
 /**
  * @typedef {object} GeneratedSourceInfo
  * @property {number=} generatedLine generated line
@@ -30,9 +28,14 @@ const getGeneratedSourceInfo = (source) => {
 			source,
 		};
 	}
+	// Use native indexOf to scan for newlines instead of charCodeAt loops.
+	// This is significantly faster on large sources since indexOf uses
+	// vectorized/native string scanning.
 	let generatedLine = 2;
-	for (let i = 0; i < lastLineStart; i++) {
-		if (source.charCodeAt(i) === CHAR_CODE_NEW_LINE) generatedLine++;
+	let idx = source.indexOf("\n");
+	while (idx !== -1 && idx < lastLineStart) {
+		generatedLine++;
+		idx = source.indexOf("\n", idx + 1);
 	}
 	return {
 		generatedLine,

package/lib/helpers/readMappings.js

@@ -35,8 +35,8 @@ const ccMax = ccToValue.length - 1;
  * @returns {void}
  */
 const readMappings = (mappings, onMapping) => {
-	// generatedColumn, [sourceIndex, originalLine, orignalColumn, [nameIndex]]
-	const currentData = new Uint32Array([0, 0, 1, 0, 0]);
+	// generatedColumn, [sourceIndex, originalLine, originalColumn, [nameIndex]]
+	const currentData = new Int32Array([0, 0, 1, 0, 0]);
 	let currentDataPos = 0;
 	// currentValue will include a sign bit at bit 0
 	let currentValue = 0;
@@ -71,7 +71,10 @@ const readMappings = (mappings, onMapping) => {
 						currentData[4],
 					);
 				}
-				[generatedColumn] = currentData;
+				// Direct typed-array index is faster here than destructuring,
+				// which would invoke the Int32Array iterator protocol.
+				// eslint-disable-next-line prefer-destructuring
+				generatedColumn = currentData[0];
 			}
 			currentDataPos = 0;
 			if (value === NEXT_LINE) {