W260426/14.webpack/node_modules/webpack-sources/lib/ReplaceSource.js

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

const Source = require("./Source");
const { getMap, getSourceAndMap } = require("./helpers/getFromStreamChunks");
const splitIntoLines = require("./helpers/splitIntoLines");
const streamChunks = require("./helpers/streamChunks");

/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
/** @typedef {import("./Source").HashLike} HashLike */
/** @typedef {import("./Source").MapOptions} MapOptions */
/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
/** @typedef {import("./Source").SourceAndMap} SourceAndMap */
/** @typedef {import("./Source").SourceValue} SourceValue */
/** @typedef {import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
/** @typedef {import("./helpers/streamChunks").OnChunk} OnChunk */
/** @typedef {import("./helpers/streamChunks").OnName} OnName */
/** @typedef {import("./helpers/streamChunks").OnSource} OnSource */
/** @typedef {import("./helpers/streamChunks").Options} Options */

// since v8 7.0, Array.prototype.sort is stable
const hasStableSort =
	typeof process === "object" &&
	process.versions &&
	typeof process.versions.v8 === "string" &&
	!/^[0-6]\./.test(process.versions.v8);

// This is larger than max string length
const MAX_SOURCE_POSITION = 0x20000000;

/**
 * Stable comparator hoisted to module scope so each `_sortReplacements()`
 * call doesn't allocate a fresh closure.
 * @param {Replacement} a a
 * @param {Replacement} b b
 * @returns {number} order
 */
const compareStable = (a, b) => {
	const diff1 = a.start - b.start;
	if (diff1 !== 0) return diff1;
	const diff2 = a.end - b.end;
	if (diff2 !== 0) return diff2;
	return 0;
};

/**
 * Index-stabilising comparator for v8 < 7.0 (pre-stable Array.prototype.sort).
 * Unreachable on any supported Node — the `hasStableSort` guard always
 * wins so coverage tools never see this execute.
 * @param {Replacement} a a
 * @param {Replacement} b b
 * @returns {number} order
 */
/* istanbul ignore next */
const compareUnstableFallback = (a, b) => {
	const diff1 = a.start - b.start;
	if (diff1 !== 0) return diff1;
	const diff2 = a.end - b.end;
	if (diff2 !== 0) return diff2;
	return /** @type {number} */ (a.index) - /** @type {number} */ (b.index);
};

class Replacement {
	/**
	 * @param {number} start start
	 * @param {number} end end
	 * @param {string} content content
	 * @param {string=} name name
	 */
	constructor(start, end, content, name) {
		this.start = start;
		this.end = end;
		this.content = content;
		this.name = name;
		// V8 < 7.0 only — unreachable on any supported Node.
		/* istanbul ignore if */
		if (!hasStableSort) {
			this.index = -1;
		}
	}
}

class ReplaceSource extends Source {
	/**
	 * @param {Source} source source
	 * @param {string=} name name
	 */
	constructor(source, name) {
		super();
		/**
		 * @private
		 * @type {Source}
		 */
		this._source = source;
		/**
		 * @private
		 * @type {string | undefined}
		 */
		this._name = name;
		/** @type {Replacement[]} */
		this._replacements = [];
		/**
		 * @private
		 * @type {boolean}
		 */
		this._isSorted = true;
	}

	getName() {
		return this._name;
	}

	getReplacements() {
		this._sortReplacements();
		return this._replacements;
	}

	/**
	 * @param {number} start start
	 * @param {number} end end
	 * @param {string} newValue new value
	 * @param {string=} name name
	 * @returns {void}
	 */
	replace(start, end, newValue, name) {
		if (typeof newValue !== "string") {
			throw new Error(
				`insertion must be a string, but is a ${typeof newValue}`,
			);
		}
		this._replacements.push(new Replacement(start, end, newValue, name));
		this._isSorted = false;
	}

	/**
	 * @param {number} pos pos
	 * @param {string} newValue new value
	 * @param {string=} name name
	 * @returns {void}
	 */
	insert(pos, newValue, name) {
		if (typeof newValue !== "string") {
			throw new Error(
				`insertion must be a string, but is a ${typeof newValue}: ${newValue}`,
			);
		}
		this._replacements.push(new Replacement(pos, pos - 1, newValue, name));
		this._isSorted = false;
	}

	/**
	 * @returns {SourceValue} source
	 */
	source() {
		if (this._replacements.length === 0) {
			return this._source.source();
		}
		const current = /** @type {string} */ (this._source.source());
		let pos = 0;
		const result = [];

		this._sortReplacements();
		for (const replacement of this._replacements) {
			const start = Math.floor(replacement.start);
			const end = Math.floor(replacement.end + 1);
			if (pos < start) {
				// slice directly from the original string rather than repeatedly
				// producing smaller intermediate strings, which avoids O(n) copies.
				result.push(current.slice(pos, start));
				pos = start;
			}
			result.push(replacement.content);
			if (pos < end) {
				pos = end;
			}
		}
		if (pos < current.length) {
			result.push(pos === 0 ? current : current.slice(pos));
		}
		return result.join("");
	}

	/**
	 * @returns {Buffer} buffer
	 */
	buffer() {
		if (this._replacements.length === 0) {
			return this._source.buffer();
		}
		return super.buffer();
	}

	/**
	 * @returns {Buffer[]} buffers
	 */
	buffers() {
		if (this._replacements.length === 0) {
			// TODO remove in the next major release
			return typeof this._source.buffers === "function"
				? this._source.buffers()
				: [this._source.buffer()];
		}
		return [this.buffer()];
	}

	/**
	 * @param {MapOptions=} options map options
	 * @returns {RawSourceMap | null} map
	 */
	map(options) {
		if (this._replacements.length === 0) {
			return this._source.map(options);
		}
		return getMap(this, options);
	}

	/**
	 * @param {MapOptions=} options map options
	 * @returns {SourceAndMap} source and map
	 */
	sourceAndMap(options) {
		if (this._replacements.length === 0) {
			return this._source.sourceAndMap(options);
		}
		return getSourceAndMap(this, options);
	}

	original() {
		return this._source;
	}

	_sortReplacements() {
		if (this._isSorted) return;
		const replacements = this._replacements;
		// Replacements are usually appended in source order (ties keep
		// insertion order, matching a stable sort), so an O(n) pre-scan
		// often lets us skip the sort and its per-element comparator calls.
		let isPresorted = true;
		for (let i = 1; i < replacements.length; i++) {
			const prev = replacements[i - 1];
			const repl = replacements[i];
			if (
				repl.start < prev.start ||
				(repl.start === prev.start && repl.end < prev.end)
			) {
				isPresorted = false;
				break;
			}
		}
		if (isPresorted) {
			this._isSorted = true;
			return;
		}
		if (hasStableSort) {
			this._replacements.sort(compareStable);
		} else {
			// V8 < 7.0 only — unreachable on any supported Node.
			/* istanbul ignore next */
			for (const [i, repl] of this._replacements.entries()) repl.index = i;
			/* istanbul ignore next */
			this._replacements.sort(compareUnstableFallback);
		}
		this._isSorted = true;
	}

	/**
	 * @param {Options} options options
	 * @param {OnChunk} onChunk called for each chunk of code
	 * @param {OnSource} onSource called for each source
	 * @param {OnName} onName called for each name
	 * @returns {GeneratedSourceInfo} generated source info
	 */
	streamChunks(options, onChunk, onSource, onName) {
		this._sortReplacements();
		// When the consumer only wants the final source (map() /
		// sourceAndMap()), emit position-only chunks (chunk === undefined,
		// like OriginalSource and RawSource do) and hand back the whole
		// replaced source once at the end. This avoids allocating boundary
		// slices for emission and — more importantly — the per-chunk
		// `code += chunk` cons-string chain in every enclosing consumer.
		// With `source: false` the caller (getMap) additionally promises not
		// to read the returned source, so its assembly is skipped entirely;
		// streamAndGetSourceAndMap overrides that flag because it caches the
		// text.
		const finalSource = Boolean(options && options.finalSource);
		const needSource = !options || options.source !== false;
		const replacements = this._replacements;
		let pos = 0;
		let i = 0;
		let replacementEnd = -1;
		let nextReplacement =
			i < replacements.length
				? Math.floor(replacements[i].start)
				: MAX_SOURCE_POSITION;
		let generatedLineOffset = 0;
		let generatedColumnOffset = 0;
		let generatedColumnOffsetLine = 0;
		/** @type {(string | undefined)[]} */
		const sourceContents = [];
		/**
		 * Lazily-built line-start offsets per source content. One number per
		 * line instead of one substring per line (`splitIntoLines`), and the
		 * chunk comparison below runs allocation-free via `startsWith`.
		 * @type {(number[] | undefined)[]}
		 */
		const sourceContentLineStarts = [];
		/** @type {Map<string, number>} */
		const nameMapping = new Map();
		/** @type {number[]} */
		const nameIndexMapping = [];
		/**
		 * @param {number} sourceIndex source index
		 * @param {number} line line
		 * @param {number} column column
		 * @param {string} expectedChunk expected chunk
		 * @returns {boolean} result
		 */
		const checkOriginalContent = (sourceIndex, line, column, expectedChunk) => {
			const content =
				sourceIndex < sourceContents.length
					? sourceContents[sourceIndex]
					: undefined;
			if (content === undefined) return false;
			let lineStarts = sourceContentLineStarts[sourceIndex];
			if (lineStarts === undefined) {
				// Line boundaries mirror `splitIntoLines`: every line includes
				// its trailing "\n"; a final line without "\n" still counts.
				lineStarts = [];
				const { length } = content;
				let offset = 0;
				while (offset < length) {
					lineStarts.push(offset);
					const newline = content.indexOf("\n", offset);
					if (newline === -1) break;
					offset = newline + 1;
				}
				sourceContentLineStarts[sourceIndex] = lineStarts;
			}
			if (line > lineStarts.length) return false;
			const lineStart = lineStarts[line - 1];
			const lineEnd =
				line < lineStarts.length ? lineStarts[line] : content.length;
			// The expected chunk never spans lines, so a match must fit into
			// the current line (mirrors the old per-line slice comparison).
			if (column + expectedChunk.length > lineEnd - lineStart) return false;
			return content.startsWith(expectedChunk, lineStart + column);
		};
		const { generatedLine, generatedColumn } = streamChunks(
			this._source,
			{ ...options, finalSource: false },
			(
				_chunk,
				generatedLine,
				generatedColumn,
				sourceIndex,
				originalLine,
				originalColumn,
				nameIndex,
			) => {
				let chunkPos = 0;
				const chunk = /** @type {string} */ (_chunk);
				const endPos = pos + chunk.length;

				// Skip over when it has been replaced
				if (replacementEnd > pos) {
					// Skip over the whole chunk
					if (replacementEnd >= endPos) {
						const line = generatedLine + generatedLineOffset;
						if (chunk.endsWith("\n")) {
							generatedLineOffset--;
							if (generatedColumnOffsetLine === line) {
								// undo exiting corrections form the current line
								generatedColumnOffset += generatedColumn;
							}
						} else if (generatedColumnOffsetLine === line) {
							generatedColumnOffset -= chunk.length;
						} else {
							/* istanbul ignore next: pre-existing chunk-skipping cross-line case (also untested on main) */
							generatedColumnOffset = -chunk.length;
							/* istanbul ignore next: pre-existing chunk-skipping cross-line case (also untested on main) */
							generatedColumnOffsetLine = line;
						}
						pos = endPos;
						return;
					}

					// Partially skip over chunk
					chunkPos = replacementEnd - pos;
					if (
						checkOriginalContent(
							sourceIndex,
							originalLine,
							originalColumn,
							chunk.slice(0, chunkPos),
						)
					) {
						originalColumn += chunkPos;
					}
					pos += chunkPos;
					const line = generatedLine + generatedLineOffset;
					/* istanbul ignore else: pre-existing chunk-skipping cross-line case (also untested on main) */
					if (generatedColumnOffsetLine === line) {
						generatedColumnOffset -= chunkPos;
					} else {
						generatedColumnOffset = -chunkPos;
						generatedColumnOffsetLine = line;
					}
					generatedColumn += chunkPos;
				}

				// Is a replacement in the chunk?
				if (nextReplacement < endPos) {
					do {
						let line = generatedLine + generatedLineOffset;
						if (nextReplacement > pos) {
							// Emit chunk until replacement
							const offset = nextReplacement - pos;
							const chunkSlice = chunk.slice(chunkPos, chunkPos + offset);
							onChunk(
								finalSource ? undefined : chunkSlice,
								line,
								generatedColumn +
									(line === generatedColumnOffsetLine
										? generatedColumnOffset
										: 0),
								sourceIndex,
								originalLine,
								originalColumn,
								nameIndex < 0 || nameIndex >= nameIndexMapping.length
									? -1
									: nameIndexMapping[nameIndex],
							);
							generatedColumn += offset;
							chunkPos += offset;
							pos = nextReplacement;
							if (
								checkOriginalContent(
									sourceIndex,
									originalLine,
									originalColumn,
									chunkSlice,
								)
							) {
								originalColumn += chunkSlice.length;
							}
						}

						// Insert replacement content splitted into chunks by lines
						const { content, name } = replacements[i];
						let replacementNameIndex = nameIndex;
						if (sourceIndex >= 0 && name) {
							let globalIndex = nameMapping.get(name);
							if (globalIndex === undefined) {
								globalIndex = nameMapping.size;
								nameMapping.set(name, globalIndex);
								onName(globalIndex, name);
							}
							replacementNameIndex = globalIndex;
						}
						// Fast path: most replacements (renamed identifiers,
						// short inserts) carry single-line content. Skip
						// `splitIntoLines` — and its array allocation — when
						// we can tell the content has no embedded newline.
						// `splitIntoLines("")` returns `[]`; emitting a zero-
						// length chunk would still walk the loop, so handle
						// it as a no-op explicitly.
						if (content.length > 0 && !content.includes("\n")) {
							onChunk(
								finalSource ? undefined : content,
								line,
								generatedColumn +
									(line === generatedColumnOffsetLine
										? generatedColumnOffset
										: 0),
								sourceIndex,
								originalLine,
								originalColumn,
								replacementNameIndex,
							);
							if (generatedColumnOffsetLine === line) {
								generatedColumnOffset += content.length;
							} else {
								generatedColumnOffset = content.length;
								generatedColumnOffsetLine = line;
							}
						} else if (content.length === 0) {
							// Empty replacement: no chunk to emit, no column
							// movement. `splitIntoLines("")` is `[]` so the
							// existing loop already does nothing — explicit
							// guard skips the per-call array allocation.
						} else {
							const matches = splitIntoLines(content);
							for (let m = 0; m < matches.length; m++) {
								const contentLine = matches[m];
								onChunk(
									finalSource ? undefined : contentLine,
									line,
									generatedColumn +
										(line === generatedColumnOffsetLine
											? generatedColumnOffset
											: 0),
									sourceIndex,
									originalLine,
									originalColumn,
									replacementNameIndex,
								);

								// Only the first chunk has name assigned
								replacementNameIndex = -1;

								if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
									/* istanbul ignore else: pre-existing multi-line replacement cross-line case (also untested on main) */
									if (generatedColumnOffsetLine === line) {
										generatedColumnOffset += contentLine.length;
									} else {
										generatedColumnOffset = contentLine.length;
										generatedColumnOffsetLine = line;
									}
								} else {
									generatedLineOffset++;
									line++;
									generatedColumnOffset = -generatedColumn;
									generatedColumnOffsetLine = line;
								}
							}
						}

						// Remove replaced content by settings this variable
						replacementEnd = Math.max(
							replacementEnd,
							Math.floor(replacements[i].end + 1),
						);

						// Move to next replacement
						i++;
						nextReplacement =
							i < replacements.length
								? Math.floor(replacements[i].start)
								: MAX_SOURCE_POSITION;

						// Skip over when it has been replaced
						const offset = chunk.length - endPos + replacementEnd - chunkPos;
						if (offset > 0) {
							// Skip over whole chunk
							if (replacementEnd >= endPos) {
								const line = generatedLine + generatedLineOffset;
								if (chunk.endsWith("\n")) {
									generatedLineOffset--;
									if (generatedColumnOffsetLine === line) {
										// undo exiting corrections form the current line
										generatedColumnOffset += generatedColumn;
									}
								} else if (generatedColumnOffsetLine === line) {
									generatedColumnOffset -= chunk.length - chunkPos;
								} else {
									generatedColumnOffset = chunkPos - chunk.length;
									generatedColumnOffsetLine = line;
								}
								pos = endPos;
								return;
							}

							// Partially skip over chunk
							const line = generatedLine + generatedLineOffset;
							if (
								checkOriginalContent(
									sourceIndex,
									originalLine,
									originalColumn,
									chunk.slice(chunkPos, chunkPos + offset),
								)
							) {
								originalColumn += offset;
							}
							chunkPos += offset;
							pos += offset;
							if (generatedColumnOffsetLine === line) {
								generatedColumnOffset -= offset;
							} else {
								generatedColumnOffset = -offset;
								generatedColumnOffsetLine = line;
							}
							generatedColumn += offset;
						}
					} while (nextReplacement < endPos);
				}

				// Emit remaining chunk
				if (chunkPos < chunk.length) {
					const chunkSlice = finalSource
						? undefined
						: chunkPos === 0
							? chunk
							: chunk.slice(chunkPos);
					const line = generatedLine + generatedLineOffset;
					onChunk(
						chunkSlice,
						line,
						generatedColumn +
							(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
						sourceIndex,
						originalLine,
						originalColumn,
						nameIndex < 0 ? -1 : nameIndexMapping[nameIndex],
					);
				}
				pos = endPos;
			},
			(sourceIndex, source, sourceContent) => {
				/* istanbul ignore next: non-sequential sourceIndex emission is not produced by any in-tree Source */
				while (sourceContents.length < sourceIndex) {
					sourceContents.push(undefined);
				}
				sourceContents[sourceIndex] = sourceContent;
				onSource(sourceIndex, source, sourceContent);
			},
			(nameIndex, name) => {
				let globalIndex = nameMapping.get(name);
				if (globalIndex === undefined) {
					globalIndex = nameMapping.size;
					nameMapping.set(name, globalIndex);
					onName(globalIndex, name);
				}
				nameIndexMapping[nameIndex] = globalIndex;
			},
		);

		// Handle remaining replacements
		let remainer = "";
		for (; i < replacements.length; i++) {
			remainer += replacements[i].content;
		}

		// Insert remaining replacements content splitted into chunks by lines
		let line = /** @type {number} */ (generatedLine) + generatedLineOffset;
		// Fast path mirroring the in-chunk replacement loop above: skip
		// splitIntoLines + per-match loop when the trailing content has no
		// newlines (the common case when remaining replacements are single
		// inserts).
		if (remainer.length > 0 && !remainer.includes("\n")) {
			onChunk(
				finalSource ? undefined : remainer,
				line,
				/** @type {number} */
				(generatedColumn) +
					(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
				-1,
				-1,
				-1,
				-1,
			);
			/* istanbul ignore else: trailing-remainer cross-line case (also untested on main) */
			if (generatedColumnOffsetLine === line) {
				generatedColumnOffset += remainer.length;
			} else {
				generatedColumnOffset = remainer.length;
				generatedColumnOffsetLine = line;
			}
		} else {
			const matches = splitIntoLines(remainer);
			for (let m = 0; m < matches.length; m++) {
				const contentLine = matches[m];
				onChunk(
					finalSource ? undefined : contentLine,
					line,
					/** @type {number} */
					(generatedColumn) +
						(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
					-1,
					-1,
					-1,
					-1,
				);

				if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
					/* istanbul ignore else: trailing-remainer multi-line cross-line case (also untested on main) */
					if (generatedColumnOffsetLine === line) {
						generatedColumnOffset += contentLine.length;
					} else {
						generatedColumnOffset = contentLine.length;
						generatedColumnOffsetLine = line;
					}
				} else {
					generatedLineOffset++;
					line++;
					generatedColumnOffset = -(/** @type {number} */ (generatedColumn));
					generatedColumnOffsetLine = line;
				}
			}
		}

		return {
			generatedLine: line,
			generatedColumn:
				/** @type {number} */
				(generatedColumn) +
				(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
			// The streamed chunks reproduce source() exactly, so the final
			// source can be assembled in O(replacements) string operations
			// instead of re-concatenating every emitted chunk downstream.
			source:
				finalSource && needSource
					? /** @type {string} */ (this.source())
					: undefined,
		};
	}

	/**
	 * Release cached data held by this source. clearCache is a memory
	 * hint: it never affects correctness or output, only how expensive
	 * the next read is. Subclasses override; the base is a no-op so
	 * every Source supports the call. Composite sources always recurse
	 * into wrapped sources. When the same child is reachable via several
	 * parents (e.g. modules shared across webpack chunks), pass a shared
	 * `visited` WeakSet so each subtree is walked at most once.
	 * Not safe to call concurrently with source/map/sourceAndMap/
	 * streamChunks/updateHash on the same instance.
	 * @param {ClearCacheOptions=} options selectors
	 * @param {WeakSet<Source>=} visited de-duplication set shared across calls
	 * @returns {void}
	 */
	clearCache(options, visited) {
		if (visited !== undefined && visited.has(this)) return;
		let v = visited;
		if (v === undefined) v = new WeakSet();
		v.add(this);
		this._source.clearCache(options, v);
	}

	/**
	 * @param {HashLike} hash hash
	 * @returns {void}
	 */
	updateHash(hash) {
		this._sortReplacements();
		hash.update("ReplaceSource");
		this._source.updateHash(hash);
		hash.update(this._name || "");
		// Feed each replacement as multiple updates instead of building one
		// combined template literal per replacement. The resulting digest is
		// identical (hash.update is additive over bytes), but we avoid
		// allocating a new string per replacement.
		for (const repl of this._replacements) {
			hash.update(`${repl.start}${repl.end}`);
			hash.update(repl.content);
			if (repl.name) hash.update(repl.name);
		}
	}
}

module.exports = ReplaceSource;
module.exports.Replacement = Replacement;