feat: initial commit

node_modules/webpack-sources/lib/helpers/createMappingsSerializer.js

@@ -0,0 +1,206 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(
+	""
+);
+
+const CONTINUATION_BIT = 0x20;
+
+const createMappingsSerializer = options => {
+	const linesOnly = options && options.columns === false;
+	return linesOnly
+		? createLinesOnlyMappingsSerializer()
+		: createFullMappingsSerializer();
+};
+
+const createFullMappingsSerializer = () => {
+	let currentLine = 1;
+	let currentColumn = 0;
+	let currentSourceIndex = 0;
+	let currentOriginalLine = 1;
+	let currentOriginalColumn = 0;
+	let currentNameIndex = 0;
+	let activeMapping = false;
+	let activeName = false;
+	let initial = true;
+	return (
+		generatedLine,
+		generatedColumn,
+		sourceIndex,
+		originalLine,
+		originalColumn,
+		nameIndex
+	) => {
+		if (activeMapping && currentLine === generatedLine) {
+			// A mapping is still active
+			if (
+				sourceIndex === currentSourceIndex &&
+				originalLine === currentOriginalLine &&
+				originalColumn === currentOriginalColumn &&
+				!activeName &&
+				nameIndex < 0
+			) {
+				// avoid repeating the same original mapping
+				return "";
+			}
+		} else {
+			// No mapping is active
+			if (sourceIndex < 0) {
+				// avoid writing unneccessary generated mappings
+				return "";
+			}
+		}
+
+		let str;
+		if (currentLine < generatedLine) {
+			str = ";".repeat(generatedLine - currentLine);
+			currentLine = generatedLine;
+			currentColumn = 0;
+			initial = false;
+		} else if (initial) {
+			str = "";
+			initial = false;
+		} else {
+			str = ",";
+		}
+
+		const writeValue = value => {
+			const sign = (value >>> 31) & 1;
+			const mask = value >> 31;
+			const absValue = (value + mask) ^ mask;
+			let data = (absValue << 1) | sign;
+			for (;;) {
+				const sextet = data & 0x1f;
+				data >>= 5;
+				if (data === 0) {
+					str += ALPHABET[sextet];
+					break;
+				} else {
+					str += ALPHABET[sextet | CONTINUATION_BIT];
+				}
+			}
+		};
+		writeValue(generatedColumn - currentColumn);
+		currentColumn = generatedColumn;
+		if (sourceIndex >= 0) {
+			activeMapping = true;
+			if (sourceIndex === currentSourceIndex) {
+				str += "A";
+			} else {
+				writeValue(sourceIndex - currentSourceIndex);
+				currentSourceIndex = sourceIndex;
+			}
+			writeValue(originalLine - currentOriginalLine);
+			currentOriginalLine = originalLine;
+			if (originalColumn === currentOriginalColumn) {
+				str += "A";
+			} else {
+				writeValue(originalColumn - currentOriginalColumn);
+				currentOriginalColumn = originalColumn;
+			}
+			if (nameIndex >= 0) {
+				writeValue(nameIndex - currentNameIndex);
+				currentNameIndex = nameIndex;
+				activeName = true;
+			} else {
+				activeName = false;
+			}
+		} else {
+			activeMapping = false;
+		}
+		return str;
+	};
+};
+
+const createLinesOnlyMappingsSerializer = () => {
+	let lastWrittenLine = 0;
+	let currentLine = 1;
+	let currentSourceIndex = 0;
+	let currentOriginalLine = 1;
+	return (
+		generatedLine,
+		_generatedColumn,
+		sourceIndex,
+		originalLine,
+		_originalColumn,
+		_nameIndex
+	) => {
+		if (sourceIndex < 0) {
+			// avoid writing generated mappings at all
+			return "";
+		}
+		if (lastWrittenLine === generatedLine) {
+			// avoid writing multiple original mappings per line
+			return "";
+		}
+		let str;
+		const writeValue = value => {
+			const sign = (value >>> 31) & 1;
+			const mask = value >> 31;
+			const absValue = (value + mask) ^ mask;
+			let data = (absValue << 1) | sign;
+			for (;;) {
+				const sextet = data & 0x1f;
+				data >>= 5;
+				if (data === 0) {
+					str += ALPHABET[sextet];
+					break;
+				} else {
+					str += ALPHABET[sextet | CONTINUATION_BIT];
+				}
+			}
+		};
+		lastWrittenLine = generatedLine;
+		if (generatedLine === currentLine + 1) {
+			currentLine = generatedLine;
+			if (sourceIndex === currentSourceIndex) {
+				currentSourceIndex = sourceIndex;
+				if (originalLine === currentOriginalLine + 1) {
+					currentOriginalLine = originalLine;
+					return ";AACA";
+				} else {
+					str = ";AA";
+					writeValue(originalLine - currentOriginalLine);
+					currentOriginalLine = originalLine;
+					return str + "A";
+				}
+			} else {
+				str = ";A";
+				writeValue(sourceIndex - currentSourceIndex);
+				currentSourceIndex = sourceIndex;
+				writeValue(originalLine - currentOriginalLine);
+				currentOriginalLine = originalLine;
+				return str + "A";
+			}
+		} else {
+			str = ";".repeat(generatedLine - currentLine);
+			currentLine = generatedLine;
+			if (sourceIndex === currentSourceIndex) {
+				currentSourceIndex = sourceIndex;
+				if (originalLine === currentOriginalLine + 1) {
+					currentOriginalLine = originalLine;
+					return str + "AACA";
+				} else {
+					str += "AA";
+					writeValue(originalLine - currentOriginalLine);
+					currentOriginalLine = originalLine;
+					return str + "A";
+				}
+			} else {
+				str += "A";
+				writeValue(sourceIndex - currentSourceIndex);
+				currentSourceIndex = sourceIndex;
+				writeValue(originalLine - currentOriginalLine);
+				currentOriginalLine = originalLine;
+				return str + "A";
+			}
+		}
+	};
+};
+
+module.exports = createMappingsSerializer;

node_modules/webpack-sources/lib/helpers/getFromStreamChunks.js

@@ -0,0 +1,129 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const createMappingsSerializer = require("./createMappingsSerializer");
+
+exports.getSourceAndMap = (inputSource, options) => {
+	let code = "";
+	let mappings = "";
+	let sources = [];
+	let sourcesContent = [];
+	let names = [];
+	const addMapping = createMappingsSerializer(options);
+	const { source } = inputSource.streamChunks(
+		Object.assign({}, 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 (sources.length < sourceIndex) {
+				sources.push(null);
+			}
+			sources[sourceIndex] = source;
+			if (sourceContent !== undefined) {
+				while (sourcesContent.length < sourceIndex) {
+					sourcesContent.push(null);
+				}
+				sourcesContent[sourceIndex] = sourceContent;
+			}
+		},
+		(nameIndex, name) => {
+			while (names.length < nameIndex) {
+				names.push(null);
+			}
+			names[nameIndex] = name;
+		}
+	);
+	return {
+		source: source !== undefined ? source : code,
+		map:
+			mappings.length > 0
+				? {
+						version: 3,
+						file: "x",
+						mappings,
+						sources,
+						sourcesContent:
+							sourcesContent.length > 0 ? sourcesContent : undefined,
+						names
+				  }
+				: null
+	};
+};
+
+exports.getMap = (source, options) => {
+	let mappings = "";
+	let sources = [];
+	let sourcesContent = [];
+	let names = [];
+	const addMapping = createMappingsSerializer(options);
+	source.streamChunks(
+		Object.assign({}, options, { source: false, finalSource: true }),
+		(
+			chunk,
+			generatedLine,
+			generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			nameIndex
+		) => {
+			mappings += addMapping(
+				generatedLine,
+				generatedColumn,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				nameIndex
+			);
+		},
+		(sourceIndex, source, sourceContent) => {
+			while (sources.length < sourceIndex) {
+				sources.push(null);
+			}
+			sources[sourceIndex] = source;
+			if (sourceContent !== undefined) {
+				while (sourcesContent.length < sourceIndex) {
+					sourcesContent.push(null);
+				}
+				sourcesContent[sourceIndex] = sourceContent;
+			}
+		},
+		(nameIndex, name) => {
+			while (names.length < nameIndex) {
+				names.push(null);
+			}
+			names[nameIndex] = name;
+		}
+	);
+	return mappings.length > 0
+		? {
+				version: 3,
+				file: "x",
+				mappings,
+				sources,
+				sourcesContent: sourcesContent.length > 0 ? sourcesContent : undefined,
+				names
+		  }
+		: null;
+};

node_modules/webpack-sources/lib/helpers/getGeneratedSourceInfo.js

@@ -0,0 +1,33 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const CHAR_CODE_NEW_LINE = "\n".charCodeAt(0);
+
+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;

node_modules/webpack-sources/lib/helpers/getName.js

@@ -0,0 +1,14 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const getName = (sourceMap, index) => {
+	if (index < 0) return null;
+	const { names } = sourceMap;
+	return names[index];
+};
+
+module.exports = getName;

node_modules/webpack-sources/lib/helpers/getSource.js

@@ -0,0 +1,17 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+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;

node_modules/webpack-sources/lib/helpers/readMappings.js

@@ -0,0 +1,116 @@
+/*
+	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;
+
+/**
+ * @param {string} mappings the mappings string
+ * @param {function(number, number, number, number, number, number): void} 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[0];
+			}
+			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;

node_modules/webpack-sources/lib/helpers/splitIntoLines.js

@@ -0,0 +1,21 @@
+const splitIntoLines = str => {
+	const results = [];
+	const len = str.length;
+	let i = 0;
+	for (; 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;

node_modules/webpack-sources/lib/helpers/splitIntoPotentialTokens.js

@@ -0,0 +1,41 @@
+// \n = 10
+// ; = 59
+// { = 123
+// } = 125
+// <space> = 32
+// \r = 13
+// \t = 9
+
+const splitIntoPotentialTokens = str => {
+	const len = str.length;
+	if (len === 0) return null;
+	const results = [];
+	let i = 0;
+	for (; i < len; ) {
+		const s = 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(s, i));
+	}
+	return results;
+};
+module.exports = splitIntoPotentialTokens;

node_modules/webpack-sources/lib/helpers/streamAndGetSourceAndMap.js

@@ -0,0 +1,102 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const createMappingsSerializer = require("./createMappingsSerializer");
+const streamChunks = require("./streamChunks");
+
+const streamAndGetSourceAndMap = (
+	inputSource,
+	options,
+	onChunk,
+	onSource,
+	onName
+) => {
+	let code = "";
+	let mappings = "";
+	let sources = [];
+	let sourcesContent = [];
+	let names = [];
+	const addMapping = createMappingsSerializer(
+		Object.assign({}, options, { columns: true })
+	);
+	const finalSource = !!(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 (sources.length < sourceIndex) {
+				sources.push(null);
+			}
+			sources[sourceIndex] = source;
+			if (sourceContent !== undefined) {
+				while (sourcesContent.length < sourceIndex) {
+					sourcesContent.push(null);
+				}
+				sourcesContent[sourceIndex] = sourceContent;
+			}
+			return onSource(sourceIndex, source, sourceContent);
+		},
+		(nameIndex, name) => {
+			while (names.length < nameIndex) {
+				names.push(null);
+			}
+			names[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,
+						sources,
+						sourcesContent:
+							sourcesContent.length > 0 ? sourcesContent : undefined,
+						names
+				  }
+				: null
+	};
+};
+
+module.exports = streamAndGetSourceAndMap;

node_modules/webpack-sources/lib/helpers/streamChunks.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const streamChunksOfRawSource = require("./streamChunksOfRawSource");
+const streamChunksOfSourceMap = require("./streamChunksOfSourceMap");
+
+module.exports = (source, options, onChunk, onSource, onName) => {
+	if (typeof source.streamChunks === "function") {
+		return source.streamChunks(options, onChunk, onSource, onName);
+	} else {
+		const sourceAndMap = source.sourceAndMap(options);
+		if (sourceAndMap.map) {
+			return streamChunksOfSourceMap(
+				sourceAndMap.source,
+				sourceAndMap.map,
+				onChunk,
+				onSource,
+				onName,
+				!!(options && options.finalSource),
+				!!(options && options.columns !== false)
+			);
+		} else {
+			return streamChunksOfRawSource(
+				sourceAndMap.source,
+				onChunk,
+				onSource,
+				onName,
+				!!(options && options.finalSource)
+			);
+		}
+	}
+};

node_modules/webpack-sources/lib/helpers/streamChunksOfCombinedSourceMap.js

@@ -0,0 +1,329 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const streamChunksOfSourceMap = require("./streamChunksOfSourceMap");
+const splitIntoLines = require("./splitIntoLines");
+
+const streamChunksOfCombinedSourceMap = (
+	source,
+	sourceMap,
+	innerSourceName,
+	innerSource,
+	innerSourceMap,
+	removeInnerSource,
+	onChunk,
+	onSource,
+	onName,
+	finalSource,
+	columns
+) => {
+	let sourceMapping = new Map();
+	let nameMapping = new Map();
+	const sourceIndexMapping = [];
+	const nameIndexMapping = [];
+	const nameIndexValueMapping = [];
+	let innerSourceIndex = -2;
+	const innerSourceIndexMapping = [];
+	const innerSourceIndexValueMapping = [];
+	const innerSourceContents = [];
+	const innerSourceContentLines = [];
+	const innerNameIndexMapping = [];
+	const innerNameIndexValueMapping = [];
+	const innerSourceMapLineData = [];
+	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) {
+			let 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 === innerSourceIndex) {
+				// 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;
+				} else {
+					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) {
+				innerSourceIndex = i;
+				if (innerSource !== undefined) sourceContent = innerSource;
+				else innerSource = sourceContent;
+				sourceIndexMapping[i] = -2;
+				streamChunksOfSourceMap(
+					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(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;

node_modules/webpack-sources/lib/helpers/streamChunksOfRawSource.js

@@ -0,0 +1,34 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const getGeneratedSourceInfo = require("./getGeneratedSourceInfo");
+const splitIntoLines = require("./splitIntoLines");
+
+const streamChunksOfRawSource = (source, onChunk, onSource, onName) => {
+	let line = 1;
+	const matches = splitIntoLines(source);
+	let match;
+	for (match of matches) {
+		onChunk(match, line, 0, -1, -1, -1, -1);
+		line++;
+	}
+	return matches.length === 0 || match.endsWith("\n")
+		? {
+				generatedLine: matches.length + 1,
+				generatedColumn: 0
+		  }
+		: {
+				generatedLine: matches.length,
+				generatedColumn: match.length
+		  };
+};
+
+module.exports = (source, onChunk, onSource, onName, finalSource) => {
+	return finalSource
+		? getGeneratedSourceInfo(source)
+		: streamChunksOfRawSource(source, onChunk, onSource, onName);
+};

node_modules/webpack-sources/lib/helpers/streamChunksOfSourceMap.js

@@ -0,0 +1,412 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const getGeneratedSourceInfo = require("./getGeneratedSourceInfo");
+const getSource = require("./getSource");
+const readMappings = require("./readMappings");
+const splitIntoLines = require("./splitIntoLines");
+
+const streamChunksOfSourceMapFull = (
+	source,
+	sourceMap,
+	onChunk,
+	onSource,
+	onName
+) => {
+	const lines = splitIntoLines(source);
+	if (lines.length === 0) {
+		return {
+			generatedLine: 1,
+			generatedColumn: 0
+		};
+	}
+	const { sources, sourcesContent, names, mappings } = sourceMap;
+	for (let i = 0; i < sources.length; i++) {
+		onSource(
+			i,
+			getSource(sourceMap, i),
+			(sourcesContent && sourcesContent[i]) || undefined
+		);
+	}
+	if (names) {
+		for (let i = 0; i < names.length; i++) {
+			onName(i, names[i]);
+		}
+	}
+
+	const lastLine = lines[lines.length - 1];
+	const lastNewLine = lastLine.endsWith("\n");
+	const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+	const finalColumn = lastNewLine ? 0 : lastLine.length;
+
+	let currentGeneratedLine = 1;
+	let currentGeneratedColumn = 0;
+
+	let mappingActive = false;
+	let activeMappingSourceIndex = -1;
+	let activeMappingOriginalLine = -1;
+	let activeMappingOriginalColumn = -1;
+	let activeMappingNameIndex = -1;
+
+	const onMapping = (
+		generatedLine,
+		generatedColumn,
+		sourceIndex,
+		originalLine,
+		originalColumn,
+		nameIndex
+	) => {
+		if (mappingActive && currentGeneratedLine <= lines.length) {
+			let chunk;
+			const mappingLine = currentGeneratedLine;
+			const mappingColumn = currentGeneratedColumn;
+			const line = lines[currentGeneratedLine - 1];
+			if (generatedLine !== currentGeneratedLine) {
+				chunk = line.slice(currentGeneratedColumn);
+				currentGeneratedLine++;
+				currentGeneratedColumn = 0;
+			} else {
+				chunk = line.slice(currentGeneratedColumn, generatedColumn);
+				currentGeneratedColumn = generatedColumn;
+			}
+			if (chunk) {
+				onChunk(
+					chunk,
+					mappingLine,
+					mappingColumn,
+					activeMappingSourceIndex,
+					activeMappingOriginalLine,
+					activeMappingOriginalColumn,
+					activeMappingNameIndex
+				);
+			}
+			mappingActive = false;
+		}
+		if (generatedLine > currentGeneratedLine && currentGeneratedColumn > 0) {
+			if (currentGeneratedLine <= lines.length) {
+				const chunk = lines[currentGeneratedLine - 1].slice(
+					currentGeneratedColumn
+				);
+				onChunk(
+					chunk,
+					currentGeneratedLine,
+					currentGeneratedColumn,
+					-1,
+					-1,
+					-1,
+					-1
+				);
+			}
+			currentGeneratedLine++;
+			currentGeneratedColumn = 0;
+		}
+		while (generatedLine > currentGeneratedLine) {
+			if (currentGeneratedLine <= lines.length) {
+				onChunk(
+					lines[currentGeneratedLine - 1],
+					currentGeneratedLine,
+					0,
+					-1,
+					-1,
+					-1,
+					-1
+				);
+			}
+			currentGeneratedLine++;
+		}
+		if (generatedColumn > currentGeneratedColumn) {
+			if (currentGeneratedLine <= lines.length) {
+				const chunk = lines[currentGeneratedLine - 1].slice(
+					currentGeneratedColumn,
+					generatedColumn
+				);
+				onChunk(
+					chunk,
+					currentGeneratedLine,
+					currentGeneratedColumn,
+					-1,
+					-1,
+					-1,
+					-1
+				);
+			}
+			currentGeneratedColumn = generatedColumn;
+		}
+		if (
+			sourceIndex >= 0 &&
+			(generatedLine < finalLine ||
+				(generatedLine === finalLine && generatedColumn < finalColumn))
+		) {
+			mappingActive = true;
+			activeMappingSourceIndex = sourceIndex;
+			activeMappingOriginalLine = originalLine;
+			activeMappingOriginalColumn = originalColumn;
+			activeMappingNameIndex = nameIndex;
+		}
+	};
+	readMappings(mappings, onMapping);
+	onMapping(finalLine, finalColumn, -1, -1, -1, -1);
+	return {
+		generatedLine: finalLine,
+		generatedColumn: finalColumn
+	};
+};
+
+const streamChunksOfSourceMapLinesFull = (
+	source,
+	sourceMap,
+	onChunk,
+	onSource,
+	_onName
+) => {
+	const lines = splitIntoLines(source);
+	if (lines.length === 0) {
+		return {
+			generatedLine: 1,
+			generatedColumn: 0
+		};
+	}
+	const { sources, sourcesContent, mappings } = sourceMap;
+	for (let i = 0; i < sources.length; i++) {
+		onSource(
+			i,
+			getSource(sourceMap, i),
+			(sourcesContent && sourcesContent[i]) || undefined
+		);
+	}
+
+	let currentGeneratedLine = 1;
+
+	const onMapping = (
+		generatedLine,
+		_generatedColumn,
+		sourceIndex,
+		originalLine,
+		originalColumn,
+		_nameIndex
+	) => {
+		if (
+			sourceIndex < 0 ||
+			generatedLine < currentGeneratedLine ||
+			generatedLine > lines.length
+		) {
+			return;
+		}
+		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,
+				0,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				-1
+			);
+			currentGeneratedLine++;
+		}
+	};
+	readMappings(mappings, onMapping);
+	for (; currentGeneratedLine <= lines.length; currentGeneratedLine++) {
+		onChunk(
+			lines[currentGeneratedLine - 1],
+			currentGeneratedLine,
+			0,
+			-1,
+			-1,
+			-1,
+			-1
+		);
+	}
+
+	const lastLine = lines[lines.length - 1];
+	const lastNewLine = lastLine.endsWith("\n");
+
+	const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+	const finalColumn = lastNewLine ? 0 : lastLine.length;
+
+	return {
+		generatedLine: finalLine,
+		generatedColumn: finalColumn
+	};
+};
+
+const streamChunksOfSourceMapFinal = (
+	source,
+	sourceMap,
+	onChunk,
+	onSource,
+	onName
+) => {
+	const result = getGeneratedSourceInfo(source);
+	const { generatedLine: finalLine, generatedColumn: finalColumn } = result;
+
+	if (finalLine === 1 && finalColumn === 0) return result;
+	const { sources, sourcesContent, names, mappings } = sourceMap;
+	for (let i = 0; i < sources.length; i++) {
+		onSource(
+			i,
+			getSource(sourceMap, i),
+			(sourcesContent && sourcesContent[i]) || undefined
+		);
+	}
+	if (names) {
+		for (let i = 0; i < names.length; i++) {
+			onName(i, names[i]);
+		}
+	}
+
+	let mappingActiveLine = 0;
+
+	const onMapping = (
+		generatedLine,
+		generatedColumn,
+		sourceIndex,
+		originalLine,
+		originalColumn,
+		nameIndex
+	) => {
+		if (
+			generatedLine >= finalLine &&
+			(generatedColumn >= finalColumn || generatedLine > finalLine)
+		) {
+			return;
+		}
+		if (sourceIndex >= 0) {
+			onChunk(
+				undefined,
+				generatedLine,
+				generatedColumn,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				nameIndex
+			);
+			mappingActiveLine = generatedLine;
+		} else if (mappingActiveLine === generatedLine) {
+			onChunk(undefined, generatedLine, generatedColumn, -1, -1, -1, -1);
+			mappingActiveLine = 0;
+		}
+	};
+	readMappings(mappings, onMapping);
+	return result;
+};
+
+const streamChunksOfSourceMapLinesFinal = (
+	source,
+	sourceMap,
+	onChunk,
+	onSource,
+	_onName
+) => {
+	const result = getGeneratedSourceInfo(source);
+	const { generatedLine, generatedColumn } = result;
+	if (generatedLine === 1 && generatedColumn === 0) {
+		return {
+			generatedLine: 1,
+			generatedColumn: 0
+		};
+	}
+
+	const { sources, sourcesContent, mappings } = sourceMap;
+	for (let i = 0; i < sources.length; i++) {
+		onSource(
+			i,
+			getSource(sourceMap, i),
+			(sourcesContent && sourcesContent[i]) || undefined
+		);
+	}
+
+	const finalLine = generatedColumn === 0 ? generatedLine - 1 : generatedLine;
+
+	let currentGeneratedLine = 1;
+
+	const onMapping = (
+		generatedLine,
+		_generatedColumn,
+		sourceIndex,
+		originalLine,
+		originalColumn,
+		_nameIndex
+	) => {
+		if (
+			sourceIndex >= 0 &&
+			currentGeneratedLine <= generatedLine &&
+			generatedLine <= finalLine
+		) {
+			onChunk(
+				undefined,
+				generatedLine,
+				0,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				-1
+			);
+			currentGeneratedLine = generatedLine + 1;
+		}
+	};
+	readMappings(mappings, onMapping);
+	return result;
+};
+
+module.exports = (
+	source,
+	sourceMap,
+	onChunk,
+	onSource,
+	onName,
+	finalSource,
+	columns
+) => {
+	if (columns) {
+		return finalSource
+			? streamChunksOfSourceMapFinal(
+					source,
+					sourceMap,
+					onChunk,
+					onSource,
+					onName
+			  )
+			: streamChunksOfSourceMapFull(
+					source,
+					sourceMap,
+					onChunk,
+					onSource,
+					onName
+			  );
+	} else {
+		return finalSource
+			? streamChunksOfSourceMapLinesFinal(
+					source,
+					sourceMap,
+					onChunk,
+					onSource,
+					onName
+			  )
+			: streamChunksOfSourceMapLinesFull(
+					source,
+					sourceMap,
+					onChunk,
+					onSource,
+					onName
+			  );
+	}
+};