@depup/webpack-sources 3.3.4-depup.0

package/lib/helpers/streamChunksOfCombinedSourceMap.js

@@ -0,0 +1,366 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const splitIntoLines = require("./splitIntoLines");
+const streamChunksOfSourceMap = require("./streamChunksOfSourceMap");
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} onChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
+
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {string} innerSourceName inner source name
+ * @param {string} innerSource inner source
+ * @param {RawSourceMap} innerSourceMap inner source map
+ * @param {boolean | undefined} removeInnerSource do remove inner source
+ * @param {onChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @param {boolean} finalSource finalSource
+ * @param {boolean} columns columns
+ * @returns {GeneratedSourceInfo} generated source info
+ */
+const streamChunksOfCombinedSourceMap = (
+	source,
+	sourceMap,
+	innerSourceName,
+	innerSource,
+	innerSourceMap,
+	removeInnerSource,
+	onChunk,
+	onSource,
+	onName,
+	finalSource,
+	columns,
+) => {
+	/** @type {Map<string | null, number>} */
+	const sourceMapping = new Map();
+	/** @type {Map<string, number>} */
+	const nameMapping = new Map();
+	/** @type {number[]} */
+	const sourceIndexMapping = [];
+	/** @type {number[]} */
+	const nameIndexMapping = [];
+	/** @type {string[]} */
+	const nameIndexValueMapping = [];
+	let outerSourceIndex = -2;
+	/** @type {number[]} */
+	const innerSourceIndexMapping = [];
+	/** @type {[string | null, string | undefined][]} */
+	const innerSourceIndexValueMapping = [];
+	/** @type {(string | undefined)[]} */
+	const innerSourceContents = [];
+	/** @type {(null | undefined | string[])[]} */
+	const innerSourceContentLines = [];
+	/** @type {number[]} */
+	const innerNameIndexMapping = [];
+	/** @type {string[]} */
+	const innerNameIndexValueMapping = [];
+	/** @typedef {[number, number, number, number, number] | number[]} MappingsData */
+	/** @type {{ chunks: string[], mappingsData: MappingsData }[]} */
+	const innerSourceMapLineData = [];
+	/**
+	 * @param {number} line line
+	 * @param {number} column column
+	 * @returns {number} result
+	 */
+	const findInnerMapping = (line, column) => {
+		if (line > innerSourceMapLineData.length) return -1;
+		const { mappingsData } = innerSourceMapLineData[line - 1];
+		let l = 0;
+		let r = mappingsData.length / 5;
+		while (l < r) {
+			const m = (l + r) >> 1;
+			if (mappingsData[m * 5] <= column) {
+				l = m + 1;
+			} else {
+				r = m;
+			}
+		}
+		if (l === 0) return -1;
+		return l - 1;
+	};
+	return streamChunksOfSourceMap(
+		source,
+		sourceMap,
+		(
+			chunk,
+			generatedLine,
+			generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			nameIndex,
+		) => {
+			// Check if this is a mapping to the inner source
+			if (sourceIndex === outerSourceIndex) {
+				// Check if there is a mapping in the inner source
+				const idx = findInnerMapping(originalLine, originalColumn);
+				if (idx !== -1) {
+					const { chunks, mappingsData } =
+						innerSourceMapLineData[originalLine - 1];
+					const mi = idx * 5;
+					const innerSourceIndex = mappingsData[mi + 1];
+					const innerOriginalLine = mappingsData[mi + 2];
+					let innerOriginalColumn = mappingsData[mi + 3];
+					let innerNameIndex = mappingsData[mi + 4];
+					if (innerSourceIndex >= 0) {
+						// Check for an identity mapping
+						// where we are allowed to adjust the original column
+						const innerChunk = chunks[idx];
+						const innerGeneratedColumn = mappingsData[mi];
+						const locationInChunk = originalColumn - innerGeneratedColumn;
+						if (locationInChunk > 0) {
+							let originalSourceLines =
+								innerSourceIndex < innerSourceContentLines.length
+									? innerSourceContentLines[innerSourceIndex]
+									: null;
+							if (originalSourceLines === undefined) {
+								const originalSource = innerSourceContents[innerSourceIndex];
+								originalSourceLines = originalSource
+									? splitIntoLines(originalSource)
+									: null;
+								innerSourceContentLines[innerSourceIndex] = originalSourceLines;
+							}
+							if (originalSourceLines !== null) {
+								const originalChunk =
+									innerOriginalLine <= originalSourceLines.length
+										? originalSourceLines[innerOriginalLine - 1].slice(
+												innerOriginalColumn,
+												innerOriginalColumn + locationInChunk,
+											)
+										: "";
+								if (innerChunk.slice(0, locationInChunk) === originalChunk) {
+									innerOriginalColumn += locationInChunk;
+									innerNameIndex = -1;
+								}
+							}
+						}
+
+						// We have a inner mapping to original source
+
+						// emit source when needed and compute global source index
+						let sourceIndex =
+							innerSourceIndex < innerSourceIndexMapping.length
+								? innerSourceIndexMapping[innerSourceIndex]
+								: -2;
+						if (sourceIndex === -2) {
+							const [source, sourceContent] =
+								innerSourceIndex < innerSourceIndexValueMapping.length
+									? innerSourceIndexValueMapping[innerSourceIndex]
+									: [null, undefined];
+							let globalIndex = sourceMapping.get(source);
+							if (globalIndex === undefined) {
+								sourceMapping.set(source, (globalIndex = sourceMapping.size));
+								onSource(globalIndex, source, sourceContent);
+							}
+							sourceIndex = globalIndex;
+							innerSourceIndexMapping[innerSourceIndex] = sourceIndex;
+						}
+
+						// emit name when needed and compute global name index
+						let finalNameIndex = -1;
+						if (innerNameIndex >= 0) {
+							// when we have a inner name
+							finalNameIndex =
+								innerNameIndex < innerNameIndexMapping.length
+									? innerNameIndexMapping[innerNameIndex]
+									: -2;
+							if (finalNameIndex === -2) {
+								const name =
+									innerNameIndex < innerNameIndexValueMapping.length
+										? innerNameIndexValueMapping[innerNameIndex]
+										: undefined;
+								if (name) {
+									let globalIndex = nameMapping.get(name);
+									if (globalIndex === undefined) {
+										nameMapping.set(name, (globalIndex = nameMapping.size));
+										onName(globalIndex, name);
+									}
+									finalNameIndex = globalIndex;
+								} else {
+									finalNameIndex = -1;
+								}
+								innerNameIndexMapping[innerNameIndex] = finalNameIndex;
+							}
+						} else if (nameIndex >= 0) {
+							// when we don't have an inner name,
+							// but we have an outer name
+							// it can be used when inner original code equals to the name
+							let originalSourceLines =
+								innerSourceContentLines[innerSourceIndex];
+							if (originalSourceLines === undefined) {
+								const originalSource = innerSourceContents[innerSourceIndex];
+								originalSourceLines = originalSource
+									? splitIntoLines(originalSource)
+									: null;
+								innerSourceContentLines[innerSourceIndex] = originalSourceLines;
+							}
+							if (originalSourceLines !== null) {
+								const name = nameIndexValueMapping[nameIndex];
+								const originalName =
+									innerOriginalLine <= originalSourceLines.length
+										? originalSourceLines[innerOriginalLine - 1].slice(
+												innerOriginalColumn,
+												innerOriginalColumn + name.length,
+											)
+										: "";
+								if (name === originalName) {
+									finalNameIndex =
+										nameIndex < nameIndexMapping.length
+											? nameIndexMapping[nameIndex]
+											: -2;
+									if (finalNameIndex === -2) {
+										const name = nameIndexValueMapping[nameIndex];
+										if (name) {
+											let globalIndex = nameMapping.get(name);
+											if (globalIndex === undefined) {
+												nameMapping.set(name, (globalIndex = nameMapping.size));
+												onName(globalIndex, name);
+											}
+											finalNameIndex = globalIndex;
+										} else {
+											finalNameIndex = -1;
+										}
+										nameIndexMapping[nameIndex] = finalNameIndex;
+									}
+								}
+							}
+						}
+						onChunk(
+							chunk,
+							generatedLine,
+							generatedColumn,
+							sourceIndex,
+							innerOriginalLine,
+							innerOriginalColumn,
+							finalNameIndex,
+						);
+						return;
+					}
+				}
+
+				// We have a mapping to the inner source, but no inner mapping
+				if (removeInnerSource) {
+					onChunk(chunk, generatedLine, generatedColumn, -1, -1, -1, -1);
+					return;
+				}
+				if (sourceIndexMapping[sourceIndex] === -2) {
+					let globalIndex = sourceMapping.get(innerSourceName);
+					if (globalIndex === undefined) {
+						sourceMapping.set(source, (globalIndex = sourceMapping.size));
+						onSource(globalIndex, innerSourceName, innerSource);
+					}
+					sourceIndexMapping[sourceIndex] = globalIndex;
+				}
+			}
+
+			const finalSourceIndex =
+				sourceIndex < 0 || sourceIndex >= sourceIndexMapping.length
+					? -1
+					: sourceIndexMapping[sourceIndex];
+			if (finalSourceIndex < 0) {
+				// no source, so we make it a generated chunk
+				onChunk(chunk, generatedLine, generatedColumn, -1, -1, -1, -1);
+			} else {
+				// Pass through the chunk with mapping
+				let finalNameIndex = -1;
+				if (nameIndex >= 0 && nameIndex < nameIndexMapping.length) {
+					finalNameIndex = nameIndexMapping[nameIndex];
+					if (finalNameIndex === -2) {
+						const name = nameIndexValueMapping[nameIndex];
+						let globalIndex = nameMapping.get(name);
+						if (globalIndex === undefined) {
+							nameMapping.set(name, (globalIndex = nameMapping.size));
+							onName(globalIndex, name);
+						}
+						finalNameIndex = globalIndex;
+						nameIndexMapping[nameIndex] = finalNameIndex;
+					}
+				}
+				onChunk(
+					chunk,
+					generatedLine,
+					generatedColumn,
+					finalSourceIndex,
+					originalLine,
+					originalColumn,
+					finalNameIndex,
+				);
+			}
+		},
+		(i, source, sourceContent) => {
+			if (source === innerSourceName) {
+				outerSourceIndex = i;
+				if (innerSource !== undefined) sourceContent = innerSource;
+				else innerSource = /** @type {string} */ (sourceContent);
+				sourceIndexMapping[i] = -2;
+				streamChunksOfSourceMap(
+					/** @type {string} */
+					(sourceContent),
+					innerSourceMap,
+					(
+						chunk,
+						generatedLine,
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn,
+						nameIndex,
+					) => {
+						while (innerSourceMapLineData.length < generatedLine) {
+							innerSourceMapLineData.push({
+								mappingsData: [],
+								chunks: [],
+							});
+						}
+						const data = innerSourceMapLineData[generatedLine - 1];
+						data.mappingsData.push(
+							generatedColumn,
+							sourceIndex,
+							originalLine,
+							originalColumn,
+							nameIndex,
+						);
+						data.chunks.push(/** @type {string} */ (chunk));
+					},
+					(i, source, sourceContent) => {
+						innerSourceContents[i] = sourceContent;
+						innerSourceContentLines[i] = undefined;
+						innerSourceIndexMapping[i] = -2;
+						innerSourceIndexValueMapping[i] = [source, sourceContent];
+					},
+					(i, name) => {
+						innerNameIndexMapping[i] = -2;
+						innerNameIndexValueMapping[i] = name;
+					},
+					false,
+					columns,
+				);
+			} else {
+				let globalIndex = sourceMapping.get(source);
+				if (globalIndex === undefined) {
+					sourceMapping.set(source, (globalIndex = sourceMapping.size));
+					onSource(globalIndex, source, sourceContent);
+				}
+				sourceIndexMapping[i] = globalIndex;
+			}
+		},
+		(i, name) => {
+			nameIndexMapping[i] = -2;
+			nameIndexValueMapping[i] = name;
+		},
+		finalSource,
+		columns,
+	);
+};
+
+module.exports = streamChunksOfCombinedSourceMap;

package/lib/helpers/streamChunksOfRawSource.js

@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const getGeneratedSourceInfo = require("./getGeneratedSourceInfo");
+const splitIntoLines = require("./splitIntoLines");
+
+/** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} OnChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
+
+/**
+ * @param {string} source source
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} _onSource on source
+ * @param {OnName} _onName on name
+ * @returns {GeneratedSourceInfo} source info
+ */
+const streamChunksOfRawSource = (source, onChunk, _onSource, _onName) => {
+	let line = 1;
+	const matches = splitIntoLines(source);
+	/** @type {undefined | string} */
+	let match;
+	for (match of matches) {
+		onChunk(match, line, 0, -1, -1, -1, -1);
+		line++;
+	}
+	return matches.length === 0 || /** @type {string} */ (match).endsWith("\n")
+		? {
+				generatedLine: matches.length + 1,
+				generatedColumn: 0,
+			}
+		: {
+				generatedLine: matches.length,
+				generatedColumn: /** @type {string} */ (match).length,
+			};
+};
+
+/**
+ * @param {string} source source
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @param {boolean} finalSource is final source
+ * @returns {GeneratedSourceInfo} source info
+ */
+module.exports = (source, onChunk, onSource, onName, finalSource) =>
+	finalSource
+		? getGeneratedSourceInfo(source)
+		: streamChunksOfRawSource(source, onChunk, onSource, onName);