@depup/webpack-sources 3.3.4-depup.0

package/lib/helpers/getFromStreamChunks.js

@@ -0,0 +1,159 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const createMappingsSerializer = require("./createMappingsSerializer");
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("../Source").SourceAndMap} SourceAndMap */
+/** @typedef {import("./streamChunks").Options} Options */
+/** @typedef {import("./streamChunks").StreamChunksFunction} StreamChunksFunction */
+
+/** @typedef {{ streamChunks: StreamChunksFunction }} SourceLikeWithStreamChunks */
+
+/**
+ * @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(
+		{ ...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);
+				}
+				potentialSourcesContent[sourceIndex] = sourceContent;
+			}
+		},
+		(nameIndex, name) => {
+			while (potentialNames.length < nameIndex) {
+				potentialNames.push(null);
+			}
+			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;
+};
+
+/**
+ * @param {SourceLikeWithStreamChunks} inputSource input source
+ * @param {Options=} options options
+ * @returns {SourceAndMap} map
+ */
+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 },
+		(
+			chunk,
+			generatedLine,
+			generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			nameIndex,
+		) => {
+			if (chunk !== undefined) code += chunk;
+			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);
+				}
+				potentialSourcesContent[sourceIndex] = sourceContent;
+			}
+		},
+		(nameIndex, name) => {
+			while (potentialNames.length < nameIndex) {
+				potentialNames.push(null);
+			}
+			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,
+	};
+};

package/lib/helpers/getGeneratedSourceInfo.js

@@ -0,0 +1,44 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const CHAR_CODE_NEW_LINE = "\n".charCodeAt(0);
+
+/**
+ * @typedef {object} GeneratedSourceInfo
+ * @property {number=} generatedLine generated line
+ * @property {number=} generatedColumn generated column
+ * @property {string=} source source
+ */
+
+/**
+ * @param {string | undefined} source source
+ * @returns {GeneratedSourceInfo} source info
+ */
+const getGeneratedSourceInfo = (source) => {
+	if (source === undefined) {
+		return {};
+	}
+	const lastLineStart = source.lastIndexOf("\n");
+	if (lastLineStart === -1) {
+		return {
+			generatedLine: 1,
+			generatedColumn: source.length,
+			source,
+		};
+	}
+	let generatedLine = 2;
+	for (let i = 0; i < lastLineStart; i++) {
+		if (source.charCodeAt(i) === CHAR_CODE_NEW_LINE) generatedLine++;
+	}
+	return {
+		generatedLine,
+		generatedColumn: source.length - lastLineStart - 1,
+		source,
+	};
+};
+
+module.exports = getGeneratedSourceInfo;

package/lib/helpers/getName.js

@@ -0,0 +1,21 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+
+/**
+ * @param {RawSourceMap} sourceMap source map
+ * @param {number} index index
+ * @returns {string | undefined | null} name
+ */
+const getName = (sourceMap, index) => {
+	if (index < 0) return null;
+	const { names } = sourceMap;
+	return names[index];
+};
+
+module.exports = getName;

package/lib/helpers/getSource.js

@@ -0,0 +1,24 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+
+/**
+ * @param {RawSourceMap} sourceMap source map
+ * @param {number} index index
+ * @returns {string | null} name
+ */
+const getSource = (sourceMap, index) => {
+	if (index < 0) return null;
+	const { sourceRoot, sources } = sourceMap;
+	const source = sources[index];
+	if (!sourceRoot) return source;
+	if (sourceRoot.endsWith("/")) return sourceRoot + source;
+	return `${sourceRoot}/${source}`;
+};
+
+module.exports = getSource;

package/lib/helpers/readMappings.js

@@ -0,0 +1,120 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ALPHABET =
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+const CONTINUATION_BIT = 0x20;
+const END_SEGMENT_BIT = 0x40;
+const NEXT_LINE = END_SEGMENT_BIT | 0x01;
+const INVALID = END_SEGMENT_BIT | 0x02;
+const DATA_MASK = 0x1f;
+
+const ccToValue = new Uint8Array("z".charCodeAt(0) + 1);
+
+ccToValue.fill(INVALID);
+
+for (let i = 0; i < ALPHABET.length; i++) {
+	ccToValue[ALPHABET.charCodeAt(i)] = i;
+}
+
+ccToValue[",".charCodeAt(0)] = END_SEGMENT_BIT;
+ccToValue[";".charCodeAt(0)] = NEXT_LINE;
+
+const ccMax = ccToValue.length - 1;
+
+/** @typedef {(generatedLine: number, generatedColumn: number, sourceIndex: number, originalLine: number, originalColumn: number, nameIndex: number) => void} OnMapping */
+
+/**
+ * @param {string} mappings the mappings string
+ * @param {OnMapping} onMapping called for each mapping
+ * @returns {void}
+ */
+const readMappings = (mappings, onMapping) => {
+	// generatedColumn, [sourceIndex, originalLine, orignalColumn, [nameIndex]]
+	const currentData = new Uint32Array([0, 0, 1, 0, 0]);
+	let currentDataPos = 0;
+	// currentValue will include a sign bit at bit 0
+	let currentValue = 0;
+	let currentValuePos = 0;
+	let generatedLine = 1;
+	let generatedColumn = -1;
+	for (let i = 0; i < mappings.length; i++) {
+		const cc = mappings.charCodeAt(i);
+		if (cc > ccMax) continue;
+		const value = ccToValue[cc];
+		if ((value & END_SEGMENT_BIT) !== 0) {
+			// End current segment
+			if (currentData[0] > generatedColumn) {
+				if (currentDataPos === 1) {
+					onMapping(generatedLine, currentData[0], -1, -1, -1, -1);
+				} else if (currentDataPos === 4) {
+					onMapping(
+						generatedLine,
+						currentData[0],
+						currentData[1],
+						currentData[2],
+						currentData[3],
+						-1,
+					);
+				} else if (currentDataPos === 5) {
+					onMapping(
+						generatedLine,
+						currentData[0],
+						currentData[1],
+						currentData[2],
+						currentData[3],
+						currentData[4],
+					);
+				}
+				[generatedColumn] = currentData;
+			}
+			currentDataPos = 0;
+			if (value === NEXT_LINE) {
+				// Start new line
+				generatedLine++;
+				currentData[0] = 0;
+				generatedColumn = -1;
+			}
+		} else if ((value & CONTINUATION_BIT) === 0) {
+			// last sextet
+			currentValue |= value << currentValuePos;
+			const finalValue =
+				currentValue & 1 ? -(currentValue >> 1) : currentValue >> 1;
+			currentData[currentDataPos++] += finalValue;
+			currentValuePos = 0;
+			currentValue = 0;
+		} else {
+			currentValue |= (value & DATA_MASK) << currentValuePos;
+			currentValuePos += 5;
+		}
+	}
+	// End current segment
+	if (currentDataPos === 1) {
+		onMapping(generatedLine, currentData[0], -1, -1, -1, -1);
+	} else if (currentDataPos === 4) {
+		onMapping(
+			generatedLine,
+			currentData[0],
+			currentData[1],
+			currentData[2],
+			currentData[3],
+			-1,
+		);
+	} else if (currentDataPos === 5) {
+		onMapping(
+			generatedLine,
+			currentData[0],
+			currentData[1],
+			currentData[2],
+			currentData[3],
+			currentData[4],
+		);
+	}
+};
+
+module.exports = readMappings;

package/lib/helpers/splitIntoLines.js

@@ -0,0 +1,33 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @param {string} str string
+ * @returns {string[]} array of string separated by lines
+ */
+const splitIntoLines = (str) => {
+	const results = [];
+	const len = str.length;
+	let i = 0;
+	while (i < len) {
+		const cc = str.charCodeAt(i);
+		// 10 is "\n".charCodeAt(0)
+		if (cc === 10) {
+			results.push("\n");
+			i++;
+		} else {
+			let j = i + 1;
+			// 10 is "\n".charCodeAt(0)
+			while (j < len && str.charCodeAt(j) !== 10) j++;
+			results.push(str.slice(i, j + 1));
+			i = j + 1;
+		}
+	}
+	return results;
+};
+
+module.exports = splitIntoLines;

package/lib/helpers/splitIntoPotentialTokens.js

@@ -0,0 +1,53 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+// \n = 10
+// ; = 59
+// { = 123
+// } = 125
+// <space> = 32
+// \r = 13
+// \t = 9
+
+/**
+ * @param {string} str string
+ * @returns {string[] | null} array of string separated by potential tokens
+ */
+const splitIntoPotentialTokens = (str) => {
+	const len = str.length;
+	if (len === 0) return null;
+	const results = [];
+	let i = 0;
+	while (i < len) {
+		const start = i;
+		block: {
+			let cc = str.charCodeAt(i);
+			while (cc !== 10 && cc !== 59 && cc !== 123 && cc !== 125) {
+				if (++i >= len) break block;
+				cc = str.charCodeAt(i);
+			}
+			while (
+				cc === 59 ||
+				cc === 32 ||
+				cc === 123 ||
+				cc === 125 ||
+				cc === 13 ||
+				cc === 9
+			) {
+				if (++i >= len) break block;
+				cc = str.charCodeAt(i);
+			}
+			if (cc === 10) {
+				i++;
+			}
+		}
+		results.push(str.slice(start, i));
+	}
+	return results;
+};
+
+module.exports = splitIntoPotentialTokens;

package/lib/helpers/streamAndGetSourceAndMap.js

@@ -0,0 +1,123 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const createMappingsSerializer = require("./createMappingsSerializer");
+const streamChunks = require("./streamChunks");
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./streamChunks").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} OnChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
+/** @typedef {import("./streamChunks").Options} Options */
+/** @typedef {import("./streamChunks").SourceMaybeWithStreamChunksFunction} SourceMaybeWithStreamChunksFunction */
+
+/**
+ * @param {SourceMaybeWithStreamChunksFunction} inputSource input source
+ * @param {Options} options options
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {{ result: GeneratedSourceInfo, source: string, map: RawSourceMap | null }} result
+ */
+const streamAndGetSourceAndMap = (
+	inputSource,
+	options,
+	onChunk,
+	onSource,
+	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 finalSource = Boolean(options && options.finalSource);
+	const { generatedLine, generatedColumn, source } = streamChunks(
+		inputSource,
+		options,
+		(
+			chunk,
+			generatedLine,
+			generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			nameIndex,
+		) => {
+			if (chunk !== undefined) code += chunk;
+			mappings += addMapping(
+				generatedLine,
+				generatedColumn,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				nameIndex,
+			);
+			return onChunk(
+				finalSource ? undefined : chunk,
+				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);
+				}
+				potentialSourcesContent[sourceIndex] = sourceContent;
+			}
+			return onSource(sourceIndex, source, sourceContent);
+		},
+		(nameIndex, name) => {
+			while (potentialNames.length < nameIndex) {
+				potentialNames.push(null);
+			}
+			potentialNames[nameIndex] = name;
+			return onName(nameIndex, name);
+		},
+	);
+	const resultSource = source !== undefined ? source : code;
+
+	return {
+		result: {
+			generatedLine,
+			generatedColumn,
+			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,
+	};
+};
+
+module.exports = streamAndGetSourceAndMap;

package/lib/helpers/streamChunks.js

@@ -0,0 +1,62 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const streamChunksOfRawSource = require("./streamChunksOfRawSource");
+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 {(nameIndex: number, name: string) => void} OnName */
+
+/** @typedef {{ source?: boolean, finalSource?: boolean, columns?: boolean }} Options */
+
+/**
+ * @callback StreamChunksFunction
+ * @param {Options} options options
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ */
+
+/** @typedef {Source & { streamChunks?: StreamChunksFunction }} SourceMaybeWithStreamChunksFunction */
+
+/**
+ * @param {SourceMaybeWithStreamChunksFunction} source source
+ * @param {Options} options options
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {GeneratedSourceInfo} generated source info
+ */
+module.exports = (source, options, onChunk, onSource, onName) => {
+	if (typeof source.streamChunks === "function") {
+		return source.streamChunks(options, onChunk, onSource, onName);
+	}
+	const sourceAndMap = source.sourceAndMap(options);
+	if (sourceAndMap.map) {
+		return streamChunksOfSourceMap(
+			/** @type {string} */
+			(sourceAndMap.source),
+			sourceAndMap.map,
+			onChunk,
+			onSource,
+			onName,
+			Boolean(options && options.finalSource),
+			Boolean(options && options.columns !== false),
+		);
+	}
+	return streamChunksOfRawSource(
+		/** @type {string} */
+		(sourceAndMap.source),
+		onChunk,
+		onSource,
+		onName,
+		Boolean(options && options.finalSource),
+	);
+};