@rspack/core 2.1.0-beta.0 → 2.1.0

package/compiled/webpack-sources/index.js

@@ -2,7 +2,7 @@
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 61:
+/***/ 969:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -12,14 +12,15 @@
 
 
 
-const Source = __nccwpck_require__(331);
-const streamAndGetSourceAndMap = __nccwpck_require__(439);
-const streamChunksOfRawSource = __nccwpck_require__(300);
-const streamChunksOfSourceMap = __nccwpck_require__(814);
+const Source = __nccwpck_require__(143);
+const streamAndGetSourceAndMap = __nccwpck_require__(579);
+const streamChunksOfRawSource = __nccwpck_require__(824);
+const streamChunksOfSourceMap = __nccwpck_require__(938);
 const {
 	isDualStringBufferCachingEnabled,
-} = __nccwpck_require__(806);
+} = __nccwpck_require__(386);
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -85,6 +86,34 @@ const bufferedMapToMap = (bufferedMap) => {
 /** @typedef {{ map?: null | RawSourceMap, bufferedMap?: null | BufferedMap }} BufferEntry */
 /** @typedef {Map<string, BufferEntry>} BufferedMaps */
 
+const CACHE_KEY_EMPTY = "{}";
+const CACHE_KEY_COLUMNS_FALSE = '{"columns":false}';
+const CACHE_KEY_COLUMNS_TRUE = '{"columns":true}';
+
+/**
+ * Fast-path replacement for `JSON.stringify(options)` when used as a cache
+ * key. MapOptions / streamChunks Options are both small boolean-only shapes
+ * and the overwhelmingly common shapes (`undefined`, `{}`, `{columns}`) can
+ * be keyed without calling `JSON.stringify`, which dominates short-circuit
+ * cache lookups. Falls back to `JSON.stringify` for any other shape so keys
+ * remain compatible with previously cached `BufferedMaps` entries.
+ * @param {undefined | MapOptions | Options} options options
+ * @returns {string} cache key
+ */
+const getCacheKey = (options) => {
+	if (!options) return CACHE_KEY_EMPTY;
+	const { columns } = options;
+	if (
+		/** @type {Options} */ (options).source === undefined &&
+		/** @type {Options} */ (options).finalSource === undefined &&
+		/** @type {MapOptions} */ (options).module === undefined
+	) {
+		if (columns === undefined) return CACHE_KEY_EMPTY;
+		return columns ? CACHE_KEY_COLUMNS_TRUE : CACHE_KEY_COLUMNS_FALSE;
+	}
+	return JSON.stringify(options);
+};
+
 /**
  * @typedef {object} CachedData
  * @property {boolean=} source source
@@ -106,36 +135,48 @@ class CachedSource extends Source {
 		 * @type {Source | (() => Source)}
 		 */
 		this._source = source;
-		/**
-		 * @private
-		 * @type {boolean | undefined}
-		 */
-		this._cachedSourceType = cachedData ? cachedData.source : undefined;
 		/**
 		 * @private
 		 * @type {undefined | string}
 		 */
 		this._cachedSource = undefined;
-		/**
-		 * @private
-		 * @type {Buffer | undefined}
-		 */
-		this._cachedBuffer = cachedData ? cachedData.buffer : undefined;
-		/**
-		 * @private
-		 * @type {number | undefined}
-		 */
-		this._cachedSize = cachedData ? cachedData.size : undefined;
-		/**
-		 * @private
-		 * @type {BufferedMaps}
-		 */
-		this._cachedMaps = cachedData ? cachedData.maps : new Map();
-		/**
-		 * @private
-		 * @type {(string | Buffer)[] | undefined}
-		 */
-		this._cachedHashUpdate = cachedData ? cachedData.hash : undefined;
+		// Split on `cachedData` once instead of re-evaluating the ternary for
+		// every field. Under the interpreter (and CodSpeed's simulation) each
+		// ternary is a separate branch; consolidating cuts the per-instance
+		// branch count roughly in half.
+		if (cachedData) {
+			/**
+			 * @private
+			 * @type {boolean | undefined}
+			 */
+			this._cachedSourceType = cachedData.source;
+			/**
+			 * @private
+			 * @type {Buffer | undefined}
+			 */
+			this._cachedBuffer = cachedData.buffer;
+			/**
+			 * @private
+			 * @type {number | undefined}
+			 */
+			this._cachedSize = cachedData.size;
+			/**
+			 * @private
+			 * @type {BufferedMaps}
+			 */
+			this._cachedMaps = cachedData.maps;
+			/**
+			 * @private
+			 * @type {(string | Buffer)[] | undefined}
+			 */
+			this._cachedHashUpdate = cachedData.hash;
+		} else {
+			this._cachedSourceType = undefined;
+			this._cachedBuffer = undefined;
+			this._cachedSize = undefined;
+			this._cachedMaps = new Map();
+			this._cachedHashUpdate = undefined;
+		}
 	}
 
 	/**
@@ -157,13 +198,14 @@ class CachedSource extends Source {
 			});
 		}
 		return {
-			// We don't want to cache strings
-			// So if we have a caches sources
-			// create a buffer from it and only store
-			// if it was a Buffer or string
-			buffer: this._cachedSource
-				? this.buffer()
-				: /** @type {Buffer} */ (this._cachedBuffer),
+			// `CachedData.buffer` is required (it is the on-disk
+			// serialization format consumed by the
+			// `new CachedSource(source, cachedData)` constructor).
+			// `_cachedBuffer` is populated by `buffer()` calls but a
+			// caller may invoke `getCachedData()` after `clearCache()`
+			// has dropped it; `this.buffer()` rehydrates via the
+			// wrapped source so the contract holds in every state.
+			buffer: this.buffer(),
 			source:
 				this._cachedSourceType !== undefined
 					? this._cachedSourceType
@@ -191,8 +233,21 @@ class CachedSource extends Source {
 	 * @returns {SourceValue} source
 	 */
 	source() {
-		const source = this._getCachedSource();
-		if (source !== undefined) return source;
+		// Fully inlined _getCachedSource: both warm- and cold-cache paths skip
+		// the prototype method lookup / stack frame the interpreter would
+		// otherwise pay on every call.
+		if (this._cachedSource !== undefined) return this._cachedSource;
+		const cachedBuffer = this._cachedBuffer;
+		const cachedSourceType = this._cachedSourceType;
+		if (cachedBuffer !== undefined && cachedSourceType !== undefined) {
+			const value = cachedSourceType
+				? cachedBuffer.toString("utf8")
+				: cachedBuffer;
+			if (isDualStringBufferCachingEnabled()) {
+				this._cachedSource = /** @type {string} */ (value);
+			}
+			return /** @type {string} */ (value);
+		}
 		return (this._cachedSource =
 			/** @type {string} */
 			(this.original().source()));
@@ -235,6 +290,9 @@ class CachedSource extends Source {
 	 */
 	buffer() {
 		if (this._cachedBuffer !== undefined) return this._cachedBuffer;
+		if (this._cachedBuffers !== undefined) {
+			return (this._cachedBuffer = Buffer.concat(this._cachedBuffers));
+		}
 		if (this._cachedSource !== undefined) {
 			const value = Buffer.isBuffer(this._cachedSource)
 				? this._cachedSource
@@ -258,6 +316,21 @@ class CachedSource extends Source {
 		return value;
 	}
 
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
+		if (this._cachedBuffers !== undefined) return this._cachedBuffers;
+		if (this._cachedBuffer !== undefined) {
+			return (this._cachedBuffers = [this._cachedBuffer]);
+		}
+		const original = this.original();
+		if (typeof original.buffers === "function") {
+			return (this._cachedBuffers = original.buffers());
+		}
+		return (this._cachedBuffers = [this.buffer()]);
+	}
+
 	/**
 	 * @returns {number} size
 	 */
@@ -278,7 +351,7 @@ class CachedSource extends Source {
 	 * @returns {SourceAndMap} source and map
 	 */
 	sourceAndMap(options) {
-		const key = options ? JSON.stringify(options) : "{}";
+		const key = getCacheKey(options);
 		const cacheEntry = this._cachedMaps.get(key);
 		// Look for a cached map
 		if (cacheEntry !== undefined) {
@@ -316,7 +389,7 @@ class CachedSource extends Source {
 	 * @returns {GeneratedSourceInfo} generated source info
 	 */
 	streamChunks(options, onChunk, onSource, onName) {
-		const key = options ? JSON.stringify(options) : "{}";
+		const key = getCacheKey(options);
 		if (
 			this._cachedMaps.has(key) &&
 			(this._cachedBuffer !== undefined || this._cachedSource !== undefined)
@@ -363,7 +436,7 @@ class CachedSource extends Source {
 	 * @returns {RawSourceMap | null} map
 	 */
 	map(options) {
-		const key = options ? JSON.stringify(options) : "{}";
+		const key = getCacheKey(options);
 		const cacheEntry = this._cachedMaps.get(key);
 		if (cacheEntry !== undefined) {
 			return this._getMapFromCacheEntry(cacheEntry);
@@ -376,6 +449,45 @@ class CachedSource extends Source {
 		return map;
 	}
 
+	/**
+	 * 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;
+		const clearSource = !options || options.source !== false;
+		const clearMaps = !options || options.maps !== false;
+		if (clearSource) {
+			this._cachedSource = undefined;
+			this._cachedSourceType = undefined;
+			this._cachedBuffer = undefined;
+			this._cachedBuffers = undefined;
+		}
+		if (clearMaps) {
+			// Reusing the Map avoids per-call allocation churn when builds
+			// call clearCache thousands of times.
+			this._cachedMaps.clear();
+		}
+		if (typeof this._source !== "function") {
+			let v = visited;
+			if (v === undefined) v = new WeakSet();
+			v.add(this);
+			this._source.clearCache(options, v);
+		} else if (visited !== undefined) {
+			visited.add(this);
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
@@ -428,7 +540,7 @@ module.exports = CachedSource;
 
 /***/ }),
 
-/***/ 961:
+/***/ 589:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -438,8 +550,9 @@ module.exports = CachedSource;
 
 
 
-const Source = __nccwpck_require__(331);
+const Source = __nccwpck_require__(143);
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -450,10 +563,12 @@ const Source = __nccwpck_require__(331);
  * @typedef {object} SourceLike
  * @property {() => SourceValue} source source
  * @property {(() => Buffer)=} buffer buffer
+ * @property {(() => Buffer[])=} buffers buffers
  * @property {(() => number)=} size size
  * @property {((options?: MapOptions) => RawSourceMap | null)=} map map
  * @property {((options?: MapOptions) => SourceAndMap)=} sourceAndMap source and map
  * @property {((hash: HashLike) => void)=} updateHash hash updater
+ * @property {((options?: ClearCacheOptions, visited?: WeakSet<Source>) => void)=} clearCache clear cache
  */
 
 class CompatSource extends Source {
@@ -486,6 +601,9 @@ class CompatSource extends Source {
 		return this._sourceLike.source();
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (typeof this._sourceLike.buffer === "function") {
 			return this._sourceLike.buffer();
@@ -493,6 +611,19 @@ class CompatSource extends Source {
 		return super.buffer();
 	}
 
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
+		if (typeof this._sourceLike.buffers === "function") {
+			return this._sourceLike.buffers();
+		}
+		return super.buffers();
+	}
+
+	/**
+	 * @returns {number} size
+	 */
 	size() {
 		if (typeof this._sourceLike.size === "function") {
 			return this._sourceLike.size();
@@ -522,6 +653,29 @@ class CompatSource extends Source {
 		return super.sourceAndMap(options);
 	}
 
+	/**
+	 * 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;
+		if (visited !== undefined) visited.add(this);
+		const sourceLike = this._sourceLike;
+		if (typeof sourceLike.clearCache === "function") {
+			sourceLike.clearCache(options, visited);
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
@@ -544,7 +698,7 @@ module.exports = CompatSource;
 
 /***/ }),
 
-/***/ 523:
+/***/ 415:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -554,12 +708,13 @@ module.exports = CompatSource;
 
 
 
-const RawSource = __nccwpck_require__(855);
-const Source = __nccwpck_require__(331);
-const { getMap, getSourceAndMap } = __nccwpck_require__(568);
-const streamChunks = __nccwpck_require__(786);
+const RawSource = __nccwpck_require__(371);
+const Source = __nccwpck_require__(143);
+const { getMap, getSourceAndMap } = __nccwpck_require__(468);
+const streamChunks = __nccwpck_require__(750);
 
 /** @typedef {import("./CompatSource").SourceLike} SourceLike */
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -587,10 +742,15 @@ class ConcatSource extends Source {
 		 */
 		this._children = [];
 
-		for (const item of args) {
+		// Indexed loops avoid the iterator-protocol overhead `for...of`
+		// pays per element. Hot during webpack's emit when many
+		// ConcatSources are constructed/flattened.
+		for (let i = 0, l = args.length; i < l; i++) {
+			const item = args[i];
 			if (item instanceof ConcatSource) {
-				for (const child of item._children) {
-					this._children.push(child);
+				const children = item._children;
+				for (let j = 0, jl = children.length; j < jl; j++) {
+					this._children.push(children[j]);
 				}
 			} else {
 				this._children.push(item);
@@ -618,8 +778,9 @@ class ConcatSource extends Source {
 	 */
 	add(item) {
 		if (item instanceof ConcatSource) {
-			for (const child of item._children) {
-				this._children.push(child);
+			const children = item._children;
+			for (let i = 0, l = children.length; i < l; i++) {
+				this._children.push(children[i]);
 			}
 		} else {
 			this._children.push(item);
@@ -632,17 +793,38 @@ class ConcatSource extends Source {
 	 * @returns {void}
 	 */
 	addAllSkipOptimizing(items) {
-		for (const item of items) {
-			this._children.push(item);
+		for (let i = 0, l = items.length; i < l; i++) {
+			this._children.push(items[i]);
 		}
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
+		return Buffer.concat(this.buffers());
+	}
+
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {SourceLike[]} */ (this._children);
+		const childCount = children.length;
 		/** @type {Buffer[]} */
 		const buffers = [];
-		for (const child of /** @type {SourceLike[]} */ (this._children)) {
-			if (typeof child.buffer === "function") {
+		// Indexed loop + manual splat avoids the iterator allocation per
+		// child and the inner for-of allocation per child.buffers() call.
+		// Hot path during webpack's emit on deeply-nested ConcatSources.
+		for (let ci = 0; ci < childCount; ci++) {
+			const child = children[ci];
+			if (typeof child.buffers === "function") {
+				const childBuffers = child.buffers();
+				for (let bi = 0, blen = childBuffers.length; bi < blen; bi++) {
+					buffers.push(childBuffers[bi]);
+				}
+			} else if (typeof child.buffer === "function") {
 				buffers.push(child.buffer());
 			} else {
 				const bufferOrString = child.source();
@@ -654,7 +836,7 @@ class ConcatSource extends Source {
 				}
 			}
 		}
-		return Buffer.concat(buffers);
+		return buffers;
 	}
 
 	/**
@@ -662,18 +844,25 @@ class ConcatSource extends Source {
 	 */
 	source() {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
 		let source = "";
-		for (const child of this._children) {
-			source += /** @type {Source} */ (child).source();
+		for (let ci = 0; ci < childCount; ci++) {
+			source += children[ci].source();
 		}
 		return source;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
 	size() {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
 		let size = 0;
-		for (const child of this._children) {
-			size += /** @type {Source} */ (child).size();
+		for (let ci = 0; ci < childCount; ci++) {
+			size += children[ci].size();
 		}
 		return size;
 	}
@@ -718,7 +907,10 @@ class ConcatSource extends Source {
 		const finalSource = Boolean(options && options.finalSource);
 		let code = "";
 		let needToCloseMapping = false;
-		for (const item of /** @type {Source[]} */ (this._children)) {
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
+		for (let ci = 0; ci < childCount; ci++) {
+			const item = children[ci];
 			/** @type {number[]} */
 			const sourceIndexMapping = [];
 			/** @type {number[]} */
@@ -760,11 +952,6 @@ class ConcatSource extends Source {
 						sourceIndex < 0 || sourceIndex >= sourceIndexMapping.length
 							? -1
 							: sourceIndexMapping[sourceIndex];
-					const resultNameIndex =
-						nameIndex < 0 || nameIndex >= nameIndexMapping.length
-							? -1
-							: nameIndexMapping[nameIndex];
-					lastMappingLine = resultSourceIndex < 0 ? 0 : generatedLine;
 					let _chunk;
 					// When using finalSource, we process the entire source code at once at the end, rather than chunk by chunk
 					if (finalSource) {
@@ -773,8 +960,17 @@ class ConcatSource extends Source {
 						_chunk = chunk;
 					}
 					if (resultSourceIndex < 0) {
+						lastMappingLine = 0;
 						onChunk(_chunk, line, column, -1, -1, -1, -1);
 					} else {
+						// Only compute the remapped name index when the chunk
+						// actually carries a source mapping; otherwise it is
+						// unused.
+						const resultNameIndex =
+							nameIndex < 0 || nameIndex >= nameIndexMapping.length
+								? -1
+								: nameIndexMapping[nameIndex];
+						lastMappingLine = generatedLine;
 						onChunk(
 							_chunk,
 							line,
@@ -836,16 +1032,46 @@ class ConcatSource extends Source {
 		};
 	}
 
+	/**
+	 * 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;
+		const children = this._children;
+		const { length } = children;
+		let v = visited;
+		if (v === undefined && length > 0) v = new WeakSet();
+		if (v !== undefined) v.add(this);
+		for (let i = 0; i < length; i++) {
+			const child = children[i];
+			if (typeof child !== "string" && typeof child.clearCache === "function") {
+				child.clearCache(options, v);
+			}
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
 	 */
 	updateHash(hash) {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
 		hash.update("ConcatSource");
-		for (const item of this._children) {
-			/** @type {Source} */
-			(item).updateHash(hash);
+		for (let ci = 0; ci < childCount; ci++) {
+			children[ci].updateHash(hash);
 		}
 	}
 
@@ -907,7 +1133,9 @@ class ConcatSource extends Source {
 				newChildren.push(currentRawSources);
 			}
 		};
-		for (const child of this._children) {
+		const children = this._children;
+		for (let ci = 0, cl = children.length; ci < cl; ci++) {
+			const child = children[ci];
 			if (typeof child === "string") {
 				if (currentString === undefined) {
 					currentString = child;
@@ -949,7 +1177,7 @@ module.exports = ConcatSource;
 
 /***/ }),
 
-/***/ 792:
+/***/ 924:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -959,15 +1187,15 @@ module.exports = ConcatSource;
 
 
 
-const Source = __nccwpck_require__(331);
-const { getMap, getSourceAndMap } = __nccwpck_require__(568);
-const getGeneratedSourceInfo = __nccwpck_require__(784);
-const splitIntoLines = __nccwpck_require__(509);
-const splitIntoPotentialTokens = __nccwpck_require__(674);
+const Source = __nccwpck_require__(143);
+const { getMap, getSourceAndMap } = __nccwpck_require__(468);
+const getGeneratedSourceInfo = __nccwpck_require__(724);
+const splitIntoPotentialTokens = __nccwpck_require__(574);
 const {
 	isDualStringBufferCachingEnabled,
-} = __nccwpck_require__(806);
+} = __nccwpck_require__(386);
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -1026,6 +1254,9 @@ class OriginalSource extends Source {
 		return this._value;
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (this._valueAsBuffer === undefined) {
 			const value = Buffer.from(/** @type {string} */ (this._value), "utf8");
@@ -1037,6 +1268,20 @@ class OriginalSource extends Source {
 		return this._valueAsBuffer;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
+	size() {
+		if (this._cachedSize !== undefined) return this._cachedSize;
+		if (this._valueAsBuffer !== undefined) {
+			return (this._cachedSize = this._valueAsBuffer.length);
+		}
+		return (this._cachedSize = Buffer.byteLength(
+			/** @type {string} */ (this._value),
+			"utf8",
+		));
+	}
+
 	/**
 	 * @param {MapOptions=} options map options
 	 * @returns {RawSourceMap | null} map
@@ -1119,27 +1364,64 @@ class OriginalSource extends Source {
 			}
 			return result;
 		}
-		// Without column info, but also without final source
-		// we need to split source by lines
+		// Without column info, but also without final source.
+		// We only get here when (options.columns === false && !finalSource),
+		// so the source field is always undefined and the chunk arg is always
+		// the line text. Single-pass scan over newlines avoids the
+		// splitIntoLines array allocation.
+		const value = this._value;
+		const len = value.length;
+		if (len === 0) {
+			return { generatedLine: 1, generatedColumn: 0, source: undefined };
+		}
 		let line = 1;
-		const matches = splitIntoLines(this._value);
-		/** @type {string | undefined} */
-		let match;
-		for (match of matches) {
-			onChunk(finalSource ? undefined : match, line, 0, 0, line, 0, -1);
+		let i = 0;
+		while (i < len) {
+			const n = value.indexOf("\n", i);
+			if (n === -1) {
+				const lastLine = i === 0 ? value : value.slice(i);
+				onChunk(lastLine, line, 0, 0, line, 0, -1);
+				return {
+					generatedLine: line,
+					generatedColumn: lastLine.length,
+					source: undefined,
+				};
+			}
+			const chunk = n === i ? "\n" : value.slice(i, n + 1);
+			onChunk(chunk, line, 0, 0, line, 0, -1);
 			line++;
+			i = n + 1;
+		}
+		// Source ended with a newline.
+		return { generatedLine: line, generatedColumn: 0, 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) {
+			if (visited.has(this)) return;
+			visited.add(this);
+		}
+		if (options !== undefined && options.source === false) return;
+		if (this._value !== undefined && this._valueAsBuffer !== undefined) {
+			// When both forms are cached, drop the string (UTF-16 in V8 is
+			// ~2 bytes/char) and keep the more compact buffer. source() will
+			// rehydrate the string on demand.
+			this._value = undefined;
 		}
-		return matches.length === 0 || /** @type {string} */ (match).endsWith("\n")
-			? {
-					generatedLine: matches.length + 1,
-					generatedColumn: 0,
-					source: finalSource ? this._value : undefined,
-				}
-			: {
-					generatedLine: matches.length,
-					generatedColumn: /** @type {string} */ (match).length,
-					source: finalSource ? this._value : undefined,
-				};
 	}
 
 	/**
@@ -1158,7 +1440,7 @@ module.exports = OriginalSource;
 
 /***/ }),
 
-/***/ 199:
+/***/ 11:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -1168,11 +1450,12 @@ module.exports = OriginalSource;
 
 
 
-const RawSource = __nccwpck_require__(855);
-const Source = __nccwpck_require__(331);
-const { getMap, getSourceAndMap } = __nccwpck_require__(568);
-const streamChunks = __nccwpck_require__(786);
+const RawSource = __nccwpck_require__(371);
+const Source = __nccwpck_require__(143);
+const { getMap, getSourceAndMap } = __nccwpck_require__(468);
+const streamChunks = __nccwpck_require__(750);
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -1184,7 +1467,31 @@ const streamChunks = __nccwpck_require__(786);
 /** @typedef {import("./helpers/streamChunks").OnSource} OnSource */
 /** @typedef {import("./helpers/streamChunks").Options} Options */
 
-const REPLACE_REGEX = /\n(?=.|\s)/g;
+// `/\n/g` (no lookahead) lets V8's regex compiler take its
+// literal-character fast path; the previous `/\n(?=.|\s)/g` form
+// disabled it. Output stays identical because `buildPrefixed` strips
+// the spurious trailing prefix when the input ended with a newline.
+const NEWLINE_REGEX = /\n/g;
+
+/**
+ * Prepend `prefix` and insert `prefix` after every newline that has
+ * content following — the original `/\n(?=.|\s)/g` semantics, but
+ * implemented as a fast-path regex + tail-strip.
+ * @param {string} prefix prefix
+ * @param {string} node underlying source string
+ * @returns {string} prefixed string
+ */
+const buildPrefixed = (prefix, node) => {
+	if (prefix.length === 0) return node;
+	const replaced = node.replace(NEWLINE_REGEX, `\n${prefix}`);
+	const len = node.length;
+	// `/\n/g` matches the trailing newline too, so the replace appended
+	// a spurious prefix at the end. Trim it.
+	if (len > 0 && node.charCodeAt(len - 1) === 10) {
+		return prefix + replaced.slice(0, replaced.length - prefix.length);
+	}
+	return prefix + replaced;
+};
 
 class PrefixSource extends Source {
 	/**
@@ -1220,12 +1527,19 @@ class PrefixSource extends Source {
 	 * @returns {SourceValue} source
 	 */
 	source() {
-		const node = /** @type {string} */ (this._source.source());
-		const prefix = this._prefix;
-		return prefix + node.replace(REPLACE_REGEX, `\n${prefix}`);
+		return buildPrefixed(
+			this._prefix,
+			/** @type {string} */ (this._source.source()),
+		);
 	}
 
-	// TODO efficient buffer() implementation
+	// buffer() / buffers() / size() inherit from Source.prototype.
+	// Source.buffer() does Buffer.from(this.source(), "utf8") — cheaper
+	// in CodSpeed instruction count than any safe override we tried
+	// (caching is unsafe with mutable child; a JS-side splice loop
+	// regressed ~5x in instruction count). Speeding up source() via the
+	// simpler regex above lifts buffer(), buffers(), size(), and any
+	// other `this.source()`-using path with no override needed.
 
 	/**
 	 * @param {MapOptions=} options map options
@@ -1304,10 +1618,7 @@ class PrefixSource extends Source {
 				generatedColumn === 0
 					? 0
 					: prefixOffset + /** @type {number} */ (generatedColumn),
-			source:
-				source !== undefined
-					? prefix + source.replace(REPLACE_REGEX, `\n${prefix}`)
-					: undefined,
+			source: source !== undefined ? buildPrefixed(prefix, source) : undefined,
 		};
 	}
 
@@ -1320,6 +1631,28 @@ class PrefixSource extends Source {
 		this._source.updateHash(hash);
 		hash.update(this._prefix);
 	}
+
+	/**
+	 * 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);
+	}
 }
 
 module.exports = PrefixSource;
@@ -1327,7 +1660,7 @@ module.exports = PrefixSource;
 
 /***/ }),
 
-/***/ 855:
+/***/ 371:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -1337,13 +1670,14 @@ module.exports = PrefixSource;
 
 
 
-const Source = __nccwpck_require__(331);
-const streamChunksOfRawSource = __nccwpck_require__(300);
+const Source = __nccwpck_require__(143);
+const streamChunksOfRawSource = __nccwpck_require__(824);
 const {
 	internString,
 	isDualStringBufferCachingEnabled,
-} = __nccwpck_require__(806);
+} = __nccwpck_require__(386);
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -1362,36 +1696,36 @@ class RawSource extends Source {
 	constructor(value, convertToString = false) {
 		super();
 		const isBuffer = Buffer.isBuffer(value);
-		if (!isBuffer && typeof value !== "string") {
+		if (isBuffer) {
+			/**
+			 * @private
+			 * @type {boolean}
+			 */
+			this._valueIsBuffer = !convertToString;
+			/**
+			 * @private
+			 * @type {undefined | string | Buffer}
+			 */
+			this._value = convertToString ? undefined : value;
+			/**
+			 * @private
+			 * @type {undefined | Buffer}
+			 */
+			this._valueAsBuffer = value;
+			/**
+			 * @private
+			 * @type {undefined | string}
+			 */
+			this._valueAsString = undefined;
+		} else if (typeof value === "string") {
+			const interned = internString(value);
+			this._valueIsBuffer = false;
+			this._value = interned;
+			this._valueAsBuffer = undefined;
+			this._valueAsString = interned;
+		} else {
 			throw new TypeError("argument 'value' must be either string or Buffer");
 		}
-		/**
-		 * @private
-		 * @type {boolean}
-		 */
-		this._valueIsBuffer = !convertToString && isBuffer;
-		const internedString =
-			typeof value === "string" ? internString(value) : undefined;
-		/**
-		 * @private
-		 * @type {undefined | string | Buffer}
-		 */
-		this._value =
-			convertToString && isBuffer
-				? undefined
-				: typeof value === "string"
-					? internedString
-					: value;
-		/**
-		 * @private
-		 * @type {undefined | Buffer}
-		 */
-		this._valueAsBuffer = isBuffer ? value : undefined;
-		/**
-		 * @private
-		 * @type {undefined | string}
-		 */
-		this._valueAsString = isBuffer ? undefined : internedString;
 	}
 
 	isBuffer() {
@@ -1414,6 +1748,9 @@ class RawSource extends Source {
 		return this._value;
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (this._valueAsBuffer === undefined) {
 			const value = Buffer.from(/** @type {string} */ (this._value), "utf8");
@@ -1425,6 +1762,20 @@ class RawSource extends Source {
 		return this._valueAsBuffer;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
+	size() {
+		if (this._cachedSize !== undefined) return this._cachedSize;
+		if (this._valueAsBuffer !== undefined) {
+			return (this._cachedSize = this._valueAsBuffer.length);
+		}
+		return (this._cachedSize = Buffer.byteLength(
+			/** @type {string} */ (this._valueAsString),
+			"utf8",
+		));
+	}
+
 	/**
 	 * @param {MapOptions=} options map options
 	 * @returns {RawSourceMap | null} map
@@ -1459,6 +1810,40 @@ class RawSource extends Source {
 		);
 	}
 
+	/**
+	 * 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) {
+			if (visited.has(this)) return;
+			visited.add(this);
+		}
+		if (options !== undefined && options.source === false) return;
+		if (this._valueIsBuffer) {
+			// Buffer is the primary representation (and lives in `_value`);
+			// only the string form, populated lazily by streamChunks, is
+			// safe to drop.
+			this._valueAsString = undefined;
+		} else if (this._valueAsBuffer !== undefined && this._value !== undefined) {
+			// The source was constructed from a string (so `_value` and
+			// `_valueAsString` reference the same interned string) and the
+			// buffer form was materialized later by `buffer()` /
+			// `updateHash()`. The buffer is therefore safe to drop.
+			this._valueAsBuffer = undefined;
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
@@ -1474,7 +1859,7 @@ module.exports = RawSource;
 
 /***/ }),
 
-/***/ 197:
+/***/ 753:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -1484,11 +1869,12 @@ module.exports = RawSource;
 
 
 
-const Source = __nccwpck_require__(331);
-const { getMap, getSourceAndMap } = __nccwpck_require__(568);
-const splitIntoLines = __nccwpck_require__(509);
-const streamChunks = __nccwpck_require__(786);
+const Source = __nccwpck_require__(143);
+const { getMap, getSourceAndMap } = __nccwpck_require__(468);
+const splitIntoLines = __nccwpck_require__(409);
+const streamChunks = __nccwpck_require__(750);
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -1510,6 +1896,35 @@ const hasStableSort =
 // 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).
+ * @param {Replacement} a a
+ * @param {Replacement} b b
+ * @returns {number} order
+ */
+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
@@ -1603,7 +2018,7 @@ class ReplaceSource extends Source {
 		if (this._replacements.length === 0) {
 			return this._source.source();
 		}
-		let current = this._source.source();
+		const current = /** @type {string} */ (this._source.source());
 		let pos = 0;
 		const result = [];
 
@@ -1612,22 +2027,45 @@ class ReplaceSource extends Source {
 			const start = Math.floor(replacement.start);
 			const end = Math.floor(replacement.end + 1);
 			if (pos < start) {
-				const offset = start - pos;
-				result.push(current.slice(0, offset));
-				current = current.slice(offset);
+				// 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) {
-				const offset = end - pos;
-				current = current.slice(offset);
 				pos = end;
 			}
 		}
-		result.push(current);
+		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
@@ -1657,24 +2095,10 @@ class ReplaceSource extends Source {
 	_sortReplacements() {
 		if (this._isSorted) return;
 		if (hasStableSort) {
-			this._replacements.sort((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;
-			});
+			this._replacements.sort(compareStable);
 		} else {
 			for (const [i, repl] of this._replacements.entries()) repl.index = i;
-			this._replacements.sort((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)
-				);
-			});
+			this._replacements.sort(compareUnstableFallback);
 		}
 		this._isSorted = true;
 	}
@@ -2015,6 +2439,28 @@ class ReplaceSource extends Source {
 		};
 	}
 
+	/**
+	 * 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}
@@ -2024,10 +2470,14 @@ class ReplaceSource extends Source {
 		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}${repl.content}${repl.name ? repl.name : ""}`,
-			);
+			hash.update(`${repl.start}${repl.end}`);
+			hash.update(repl.content);
+			if (repl.name) hash.update(repl.name);
 		}
 	}
 }
@@ -2038,7 +2488,7 @@ module.exports.Replacement = Replacement;
 
 /***/ }),
 
-/***/ 628:
+/***/ 216:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -2048,7 +2498,7 @@ module.exports.Replacement = Replacement;
 
 
 
-const Source = __nccwpck_require__(331);
+const Source = __nccwpck_require__(143);
 
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
@@ -2074,6 +2524,9 @@ class SizeOnlySource extends Source {
 		);
 	}
 
+	/**
+	 * @returns {number} size
+	 */
 	size() {
 		return this._size;
 	}
@@ -2092,6 +2545,13 @@ class SizeOnlySource extends Source {
 		throw this._error();
 	}
 
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
+		throw this._error();
+	}
+
 	/**
 	 * @param {MapOptions=} options map options
 	 * @returns {RawSourceMap | null} map
@@ -2116,7 +2576,7 @@ module.exports = SizeOnlySource;
 
 /***/ }),
 
-/***/ 331:
+/***/ 143:
 /***/ ((module) => {
 
 /*
@@ -2159,6 +2619,13 @@ module.exports = SizeOnlySource;
  * @property {(encoding?: string) => string | Buffer} digest get hash digest
  */
 
+/**
+ * @typedef {object} ClearCacheOptions
+ * @property {boolean=} maps drop cached source maps (default `true`)
+ * @property {boolean=} source drop cached source/buffer copies (default `true`)
+ * @property {boolean=} parsedMap drop the parsed object form of cached source maps on `SourceMapSource` instances (default `false` — re-parsing JSON is significantly more expensive than `toString`). Only takes effect when a serialized form (buffer or string) is also retained, so the data remains recoverable.
+ */
+
 class Source {
 	/**
 	 * @returns {SourceValue} source
@@ -2167,12 +2634,25 @@ class Source {
 		throw new Error("Abstract");
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		const source = this.source();
 		if (Buffer.isBuffer(source)) return source;
 		return Buffer.from(source, "utf8");
 	}
 
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
+		return [this.buffer()];
+	}
+
+	/**
+	 * @returns {number} size
+	 */
 	size() {
 		return this.buffer().length;
 	}
@@ -2205,6 +2685,23 @@ class Source {
 	updateHash(hash) {
 		throw new Error("Abstract");
 	}
+
+	/**
+	 * 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}
+	 */
+	// eslint-disable-next-line no-unused-vars
+	clearCache(options, visited) {}
 }
 
 module.exports = Source;
@@ -2212,7 +2709,7 @@ module.exports = Source;
 
 /***/ }),
 
-/***/ 476:
+/***/ 8:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -2222,14 +2719,15 @@ module.exports = Source;
 
 
 
-const Source = __nccwpck_require__(331);
-const { getMap, getSourceAndMap } = __nccwpck_require__(568);
-const streamChunksOfCombinedSourceMap = __nccwpck_require__(647);
-const streamChunksOfSourceMap = __nccwpck_require__(814);
+const Source = __nccwpck_require__(143);
+const { getMap, getSourceAndMap } = __nccwpck_require__(468);
+const streamChunksOfCombinedSourceMap = __nccwpck_require__(459);
+const streamChunksOfSourceMap = __nccwpck_require__(938);
 const {
 	isDualStringBufferCachingEnabled,
-} = __nccwpck_require__(806);
+} = __nccwpck_require__(386);
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -2346,6 +2844,9 @@ class SourceMapSource extends Source {
 		];
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (this._valueAsBuffer === undefined) {
 			const value = Buffer.from(
@@ -2360,6 +2861,20 @@ class SourceMapSource extends Source {
 		return this._valueAsBuffer;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
+	size() {
+		if (this._cachedSize !== undefined) return this._cachedSize;
+		if (this._valueAsBuffer !== undefined) {
+			return (this._cachedSize = this._valueAsBuffer.length);
+		}
+		return (this._cachedSize = Buffer.byteLength(
+			/** @type {string} */ (this._valueAsString),
+			"utf8",
+		));
+	}
+
 	/**
 	 * @returns {SourceValue} source
 	 */
@@ -2554,6 +3069,80 @@ class SourceMapSource extends Source {
 		);
 	}
 
+	/**
+	 * 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) {
+			if (visited.has(this)) return;
+			visited.add(this);
+		}
+		const clearSource = !options || options.source !== false;
+		const clearMaps = !options || options.maps !== false;
+		const clearParsedMap = options !== undefined && options.parsedMap === true;
+		// For every dual-cached pair, drop the string form when the
+		// buffer is also held — buffer is more compact in V8 (1 byte/char
+		// vs 2) and the string rehydrates cheaply. Parsed object forms
+		// of source maps are heavier but only dropped when
+		// `parsedMap: true` is set, because re-parsing JSON is much more
+		// expensive than `toString` from a buffer.
+		if (clearSource) {
+			if (
+				this._valueAsString !== undefined &&
+				this._valueAsBuffer !== undefined
+			) {
+				this._valueAsString = undefined;
+			}
+			if (
+				this._originalSourceAsString !== undefined &&
+				this._originalSourceAsBuffer !== undefined
+			) {
+				this._originalSourceAsString = undefined;
+			}
+		}
+		if (clearMaps) {
+			if (
+				this._sourceMapAsString !== undefined &&
+				this._sourceMapAsBuffer !== undefined
+			) {
+				this._sourceMapAsString = undefined;
+			}
+			if (
+				clearParsedMap &&
+				this._sourceMapAsObject !== undefined &&
+				(this._sourceMapAsBuffer !== undefined ||
+					this._sourceMapAsString !== undefined)
+			) {
+				this._sourceMapAsObject = undefined;
+			}
+			if (
+				this._innerSourceMapAsString !== undefined &&
+				this._innerSourceMapAsBuffer !== undefined
+			) {
+				this._innerSourceMapAsString = undefined;
+			}
+			if (
+				clearParsedMap &&
+				this._innerSourceMapAsObject !== undefined &&
+				(this._innerSourceMapAsBuffer !== undefined ||
+					this._innerSourceMapAsString !== undefined)
+			) {
+				this._innerSourceMapAsObject = undefined;
+			}
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
@@ -2586,7 +3175,7 @@ module.exports = SourceMapSource;
 
 /***/ }),
 
-/***/ 983:
+/***/ 859:
 /***/ ((module) => {
 
 /*
@@ -2613,6 +3202,29 @@ const ALPHABET = [
 
 const CONTINUATION_BIT = 0x20;
 
+/**
+ * Append a VLQ-encoded signed integer to `str`. Hoisted to module scope so
+ * that both serializers share a single function object and avoid allocating
+ * a new closure on every call.
+ * @param {string} str current string buffer
+ * @param {number} value signed integer to encode
+ * @returns {string} updated string buffer
+ */
+const writeValue = (str, 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) {
+			return str + ALPHABET[sextet];
+		}
+		str += ALPHABET[sextet | CONTINUATION_BIT];
+	}
+};
+
 const createFullMappingsSerializer = () => {
 	let currentLine = 1;
 	let currentColumn = 0;
@@ -2651,10 +3263,14 @@ const createFullMappingsSerializer = () => {
 			return "";
 		}
 
-		/** @type {undefined | string} */
 		let str;
 		if (currentLine < generatedLine) {
-			str = ";".repeat(generatedLine - currentLine);
+			// Consecutive lines (diff === 1) are the dominant case; avoid the
+			// `.repeat()` call entirely for them.
+			str =
+				generatedLine === currentLine + 1
+					? ";"
+					: ";".repeat(generatedLine - currentLine);
 			currentLine = generatedLine;
 			currentColumn = 0;
 			initial = false;
@@ -2665,46 +3281,26 @@ const createFullMappingsSerializer = () => {
 			str = ",";
 		}
 
-		/**
-		 * @param {number} value value
-		 * @returns {void}
-		 */
-		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);
+		str = writeValue(str, generatedColumn - currentColumn);
 		currentColumn = generatedColumn;
 		if (sourceIndex >= 0) {
 			activeMapping = true;
 			if (sourceIndex === currentSourceIndex) {
 				str += "A";
 			} else {
-				writeValue(sourceIndex - currentSourceIndex);
+				str = writeValue(str, sourceIndex - currentSourceIndex);
 				currentSourceIndex = sourceIndex;
 			}
-			writeValue(originalLine - currentOriginalLine);
+			str = writeValue(str, originalLine - currentOriginalLine);
 			currentOriginalLine = originalLine;
 			if (originalColumn === currentOriginalColumn) {
 				str += "A";
 			} else {
-				writeValue(originalColumn - currentOriginalColumn);
+				str = writeValue(str, originalColumn - currentOriginalColumn);
 				currentOriginalColumn = originalColumn;
 			}
 			if (nameIndex >= 0) {
-				writeValue(nameIndex - currentNameIndex);
+				str = writeValue(str, nameIndex - currentNameIndex);
 				currentNameIndex = nameIndex;
 				activeName = true;
 			} else {
@@ -2739,28 +3335,7 @@ const createLinesOnlyMappingsSerializer = () => {
 			// avoid writing multiple original mappings per line
 			return "";
 		}
-		/** @type {undefined | string} */
 		let str;
-		/**
-		 * @param {number} value value
-		 * @returns {void}
-		 */
-		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;
@@ -2770,14 +3345,14 @@ const createLinesOnlyMappingsSerializer = () => {
 					return ";AACA";
 				}
 				str = ";AA";
-				writeValue(originalLine - currentOriginalLine);
+				str = writeValue(str, originalLine - currentOriginalLine);
 				currentOriginalLine = originalLine;
 				return `${str}A`;
 			}
 			str = ";A";
-			writeValue(sourceIndex - currentSourceIndex);
+			str = writeValue(str, sourceIndex - currentSourceIndex);
 			currentSourceIndex = sourceIndex;
-			writeValue(originalLine - currentOriginalLine);
+			str = writeValue(str, originalLine - currentOriginalLine);
 			currentOriginalLine = originalLine;
 			return `${str}A`;
 		}
@@ -2789,14 +3364,14 @@ const createLinesOnlyMappingsSerializer = () => {
 				return `${str}AACA`;
 			}
 			str += "AA";
-			writeValue(originalLine - currentOriginalLine);
+			str = writeValue(str, originalLine - currentOriginalLine);
 			currentOriginalLine = originalLine;
 			return `${str}A`;
 		}
 		str += "A";
-		writeValue(sourceIndex - currentSourceIndex);
+		str = writeValue(str, sourceIndex - currentSourceIndex);
 		currentSourceIndex = sourceIndex;
-		writeValue(originalLine - currentOriginalLine);
+		str = writeValue(str, originalLine - currentOriginalLine);
 		currentOriginalLine = originalLine;
 		return `${str}A`;
 	};
@@ -2818,7 +3393,7 @@ module.exports = createMappingsSerializer;
 
 /***/ }),
 
-/***/ 568:
+/***/ 468:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -2828,7 +3403,7 @@ module.exports = createMappingsSerializer;
 
 
 
-const createMappingsSerializer = __nccwpck_require__(983);
+const createMappingsSerializer = __nccwpck_require__(859);
 
 /** @typedef {import("../Source").RawSourceMap} RawSourceMap */
 /** @typedef {import("../Source").SourceAndMap} SourceAndMap */
@@ -2984,7 +3559,7 @@ module.exports.getSourceAndMap = (inputSource, options) => {
 
 /***/ }),
 
-/***/ 784:
+/***/ 724:
 /***/ ((module) => {
 
 /*
@@ -2994,8 +3569,6 @@ module.exports.getSourceAndMap = (inputSource, options) => {
 
 
 
-const CHAR_CODE_NEW_LINE = "\n".charCodeAt(0);
-
 /**
  * @typedef {object} GeneratedSourceInfo
  * @property {number=} generatedLine generated line
@@ -3019,9 +3592,14 @@ const getGeneratedSourceInfo = (source) => {
 			source,
 		};
 	}
+	// Use native indexOf to scan for newlines instead of charCodeAt loops.
+	// This is significantly faster on large sources since indexOf uses
+	// vectorized/native string scanning.
 	let generatedLine = 2;
-	for (let i = 0; i < lastLineStart; i++) {
-		if (source.charCodeAt(i) === CHAR_CODE_NEW_LINE) generatedLine++;
+	let idx = source.indexOf("\n");
+	while (idx !== -1 && idx < lastLineStart) {
+		generatedLine++;
+		idx = source.indexOf("\n", idx + 1);
 	}
 	return {
 		generatedLine,
@@ -3035,7 +3613,7 @@ module.exports = getGeneratedSourceInfo;
 
 /***/ }),
 
-/***/ 711:
+/***/ 707:
 /***/ ((module) => {
 
 /*
@@ -3066,7 +3644,7 @@ module.exports = getSource;
 
 /***/ }),
 
-/***/ 28:
+/***/ 651:
 /***/ ((module) => {
 
 /*
@@ -3106,8 +3684,8 @@ const ccMax = ccToValue.length - 1;
  * @returns {void}
  */
 const readMappings = (mappings, onMapping) => {
-	// generatedColumn, [sourceIndex, originalLine, orignalColumn, [nameIndex]]
-	const currentData = new Uint32Array([0, 0, 1, 0, 0]);
+	// generatedColumn, [sourceIndex, originalLine, originalColumn, [nameIndex]]
+	const currentData = new Int32Array([0, 0, 1, 0, 0]);
 	let currentDataPos = 0;
 	// currentValue will include a sign bit at bit 0
 	let currentValue = 0;
@@ -3142,7 +3720,10 @@ const readMappings = (mappings, onMapping) => {
 						currentData[4],
 					);
 				}
-				[generatedColumn] = currentData;
+				// Direct typed-array index is faster here than destructuring,
+				// which would invoke the Int32Array iterator protocol.
+				// eslint-disable-next-line prefer-destructuring
+				generatedColumn = currentData[0];
 			}
 			currentDataPos = 0;
 			if (value === NEXT_LINE) {
@@ -3193,7 +3774,7 @@ module.exports = readMappings;
 
 /***/ }),
 
-/***/ 509:
+/***/ 409:
 /***/ ((module) => {
 
 /*
@@ -3212,18 +3793,19 @@ const splitIntoLines = (str) => {
 	const len = str.length;
 	let i = 0;
 	while (i < len) {
-		const cc = str.charCodeAt(i);
-		// 10 is "\n".charCodeAt(0)
-		if (cc === 10) {
+		// indexOf is implemented natively and is significantly faster than
+		// scanning char-by-char with charCodeAt for long lines.
+		const n = str.indexOf("\n", i);
+		if (n === -1) {
+			results.push(i === 0 ? str : str.slice(i));
+			break;
+		}
+		if (n === i) {
 			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;
+			results.push(str.slice(i, n + 1));
 		}
+		i = n + 1;
 	}
 	return results;
 };
@@ -3233,7 +3815,7 @@ module.exports = splitIntoLines;
 
 /***/ }),
 
-/***/ 674:
+/***/ 574:
 /***/ ((module) => {
 
 /*
@@ -3293,7 +3875,7 @@ module.exports = splitIntoPotentialTokens;
 
 /***/ }),
 
-/***/ 439:
+/***/ 579:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -3303,8 +3885,8 @@ module.exports = splitIntoPotentialTokens;
 
 
 
-const createMappingsSerializer = __nccwpck_require__(983);
-const streamChunks = __nccwpck_require__(786);
+const createMappingsSerializer = __nccwpck_require__(859);
+const streamChunks = __nccwpck_require__(750);
 
 /** @typedef {import("../Source").RawSourceMap} RawSourceMap */
 /** @typedef {import("./streamChunks").GeneratedSourceInfo} GeneratedSourceInfo */
@@ -3423,7 +4005,7 @@ module.exports = streamAndGetSourceAndMap;
 
 /***/ }),
 
-/***/ 786:
+/***/ 750:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -3433,8 +4015,8 @@ module.exports = streamAndGetSourceAndMap;
 
 
 
-const streamChunksOfRawSource = __nccwpck_require__(300);
-const streamChunksOfSourceMap = __nccwpck_require__(814);
+const streamChunksOfRawSource = __nccwpck_require__(824);
+const streamChunksOfSourceMap = __nccwpck_require__(938);
 
 /** @typedef {import("../Source")} Source */
 /** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
@@ -3492,7 +4074,7 @@ module.exports = (source, options, onChunk, onSource, onName) => {
 
 /***/ }),
 
-/***/ 647:
+/***/ 459:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -3502,8 +4084,8 @@ module.exports = (source, options, onChunk, onSource, onName) => {
 
 
 
-const splitIntoLines = __nccwpck_require__(509);
-const streamChunksOfSourceMap = __nccwpck_require__(814);
+const splitIntoLines = __nccwpck_require__(409);
+const streamChunksOfSourceMap = __nccwpck_require__(938);
 
 /** @typedef {import("../Source").RawSourceMap} RawSourceMap */
 /** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
@@ -3573,7 +4155,11 @@ const streamChunksOfCombinedSourceMap = (
 		if (line > innerSourceMapLineData.length) return -1;
 		const { mappingsData } = innerSourceMapLineData[line - 1];
 		let l = 0;
-		let r = mappingsData.length / 5;
+		// `mappingsData.length` is always a multiple of 5 (five values pushed
+		// per mapping), so dividing is exact. Coerce the bound to an int32 so
+		// the binary-search loop stays on V8's fast small-int path instead of
+		// comparing an int against a float.
+		let r = (mappingsData.length / 5) | 0;
 		while (l < r) {
 			const m = (l + r) >> 1;
 			if (mappingsData[m * 5] <= column) {
@@ -3865,7 +4451,7 @@ module.exports = streamChunksOfCombinedSourceMap;
 
 /***/ }),
 
-/***/ 300:
+/***/ 824:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -3875,8 +4461,7 @@ module.exports = streamChunksOfCombinedSourceMap;
 
 
 
-const getGeneratedSourceInfo = __nccwpck_require__(784);
-const splitIntoLines = __nccwpck_require__(509);
+const getGeneratedSourceInfo = __nccwpck_require__(724);
 
 /** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
 /** @typedef {import("./streamChunks").OnChunk} OnChunk */
@@ -3889,25 +4474,34 @@ const splitIntoLines = __nccwpck_require__(509);
  * @param {OnSource} _onSource on source
  * @param {OnName} _onName on name
  * @returns {GeneratedSourceInfo} source info
+ *
+ * Single-pass equivalent of `splitIntoLines(source).forEach(emit)` — emits
+ * each line via onChunk while scanning for newlines, so we never allocate
+ * the intermediate array of lines.
  */
 const streamChunksOfRawSource = (source, onChunk, _onSource, _onName) => {
+	const len = source.length;
+	if (len === 0) {
+		return { generatedLine: 1, generatedColumn: 0 };
+	}
 	let line = 1;
-	const matches = splitIntoLines(source);
-	/** @type {undefined | string} */
-	let match;
-	for (match of matches) {
-		onChunk(match, line, 0, -1, -1, -1, -1);
+	let i = 0;
+	while (i < len) {
+		const n = source.indexOf("\n", i);
+		if (n === -1) {
+			// Trailing partial line (no \n). Emit and return its length as the
+			// final column.
+			const lastLine = i === 0 ? source : source.slice(i);
+			onChunk(lastLine, line, 0, -1, -1, -1, -1);
+			return { generatedLine: line, generatedColumn: lastLine.length };
+		}
+		const chunk = n === i ? "\n" : source.slice(i, n + 1);
+		onChunk(chunk, line, 0, -1, -1, -1, -1);
 		line++;
+		i = n + 1;
 	}
-	return matches.length === 0 || /** @type {string} */ (match).endsWith("\n")
-		? {
-				generatedLine: matches.length + 1,
-				generatedColumn: 0,
-			}
-		: {
-				generatedLine: matches.length,
-				generatedColumn: /** @type {string} */ (match).length,
-			};
+	// Source ended with a newline — the next "logical" line is empty.
+	return { generatedLine: line, generatedColumn: 0 };
 };
 
 /**
@@ -3926,7 +4520,7 @@ module.exports = (source, onChunk, onSource, onName, finalSource) =>
 
 /***/ }),
 
-/***/ 814:
+/***/ 938:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -3936,10 +4530,10 @@ module.exports = (source, onChunk, onSource, onName, finalSource) =>
 
 
 
-const getGeneratedSourceInfo = __nccwpck_require__(784);
-const getSource = __nccwpck_require__(711);
-const readMappings = __nccwpck_require__(28);
-const splitIntoLines = __nccwpck_require__(509);
+const getGeneratedSourceInfo = __nccwpck_require__(724);
+const getSource = __nccwpck_require__(707);
+const readMappings = __nccwpck_require__(651);
+const splitIntoLines = __nccwpck_require__(409);
 
 /** @typedef {import("../Source").RawSourceMap} RawSourceMap */
 /** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
@@ -3963,7 +4557,8 @@ const streamChunksOfSourceMapFull = (
 	onName,
 ) => {
 	const lines = splitIntoLines(source);
-	if (lines.length === 0) {
+	const linesLength = lines.length;
+	if (linesLength === 0) {
 		return {
 			generatedLine: 1,
 			generatedColumn: 0,
@@ -3983,9 +4578,9 @@ const streamChunksOfSourceMapFull = (
 		}
 	}
 
-	const lastLine = lines[lines.length - 1];
+	const lastLine = lines[linesLength - 1];
 	const lastNewLine = lastLine.endsWith("\n");
-	const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+	const finalLine = lastNewLine ? linesLength + 1 : linesLength;
 	const finalColumn = lastNewLine ? 0 : lastLine.length;
 
 	let currentGeneratedLine = 1;
@@ -4014,7 +4609,7 @@ const streamChunksOfSourceMapFull = (
 		originalColumn,
 		nameIndex,
 	) => {
-		if (mappingActive && currentGeneratedLine <= lines.length) {
+		if (mappingActive && currentGeneratedLine <= linesLength) {
 			let chunk;
 			const mappingLine = currentGeneratedLine;
 			const mappingColumn = currentGeneratedColumn;
@@ -4041,7 +4636,7 @@ const streamChunksOfSourceMapFull = (
 			mappingActive = false;
 		}
 		if (generatedLine > currentGeneratedLine && currentGeneratedColumn > 0) {
-			if (currentGeneratedLine <= lines.length) {
+			if (currentGeneratedLine <= linesLength) {
 				const chunk = lines[currentGeneratedLine - 1].slice(
 					currentGeneratedColumn,
 				);
@@ -4058,22 +4653,29 @@ const streamChunksOfSourceMapFull = (
 			currentGeneratedLine++;
 			currentGeneratedColumn = 0;
 		}
-		while (generatedLine > currentGeneratedLine) {
-			if (currentGeneratedLine <= lines.length) {
-				onChunk(
-					lines[currentGeneratedLine - 1],
-					currentGeneratedLine,
-					0,
-					-1,
-					-1,
-					-1,
-					-1,
-				);
-			}
+		// Emit each fully-passed generated line. Once we move past the last
+		// available line we stop emitting, but still need to advance the
+		// counter to `generatedLine` so subsequent state matches the caller.
+		while (
+			generatedLine > currentGeneratedLine &&
+			currentGeneratedLine <= linesLength
+		) {
+			onChunk(
+				lines[currentGeneratedLine - 1],
+				currentGeneratedLine,
+				0,
+				-1,
+				-1,
+				-1,
+				-1,
+			);
 			currentGeneratedLine++;
 		}
+		if (currentGeneratedLine < generatedLine) {
+			currentGeneratedLine = generatedLine;
+		}
 		if (generatedColumn > currentGeneratedColumn) {
-			if (currentGeneratedLine <= lines.length) {
+			if (currentGeneratedLine <= linesLength) {
 				const chunk = lines[currentGeneratedLine - 1].slice(
 					currentGeneratedColumn,
 					generatedColumn,
@@ -4126,7 +4728,8 @@ const streamChunksOfSourceMapLinesFull = (
 	_onName,
 ) => {
 	const lines = splitIntoLines(source);
-	if (lines.length === 0) {
+	const linesLength = lines.length;
+	if (linesLength === 0) {
 		return {
 			generatedLine: 1,
 			generatedColumn: 0,
@@ -4163,39 +4766,38 @@ const streamChunksOfSourceMapLinesFull = (
 		if (
 			sourceIndex < 0 ||
 			generatedLine < currentGeneratedLine ||
-			generatedLine > lines.length
+			generatedLine > linesLength
 		) {
 			return;
 		}
+		// `generatedLine <= linesLength` is guaranteed by the guard above, so
+		// every line we iterate over is in bounds — no per-iteration length
+		// check needed.
 		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,
+				lines[currentGeneratedLine - 1],
+				currentGeneratedLine,
 				0,
-				sourceIndex,
-				originalLine,
-				originalColumn,
+				-1,
+				-1,
+				-1,
 				-1,
 			);
 			currentGeneratedLine++;
 		}
+		onChunk(
+			lines[generatedLine - 1],
+			generatedLine,
+			0,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			-1,
+		);
+		currentGeneratedLine++;
 	};
 	readMappings(mappings, onMapping);
-	for (; currentGeneratedLine <= lines.length; currentGeneratedLine++) {
+	for (; currentGeneratedLine <= linesLength; currentGeneratedLine++) {
 		onChunk(
 			lines[currentGeneratedLine - 1],
 			currentGeneratedLine,
@@ -4207,10 +4809,10 @@ const streamChunksOfSourceMapLinesFull = (
 		);
 	}
 
-	const lastLine = lines[lines.length - 1];
+	const lastLine = lines[linesLength - 1];
 	const lastNewLine = lastLine.endsWith("\n");
 
-	const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+	const finalLine = lastNewLine ? linesLength + 1 : linesLength;
 	const finalColumn = lastNewLine ? 0 : lastLine.length;
 
 	return {
@@ -4432,7 +5034,7 @@ module.exports = (
 
 /***/ }),
 
-/***/ 806:
+/***/ 386:
 /***/ ((module) => {
 
 /*
@@ -4556,7 +5158,7 @@ module.exports = {
 
 /***/ }),
 
-/***/ 340:
+/***/ 864:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
@@ -4643,38 +5245,38 @@ module.exports = mergeExports(
 	{},
 	{
 		get Source() {
-			return __nccwpck_require__(331);
+			return __nccwpck_require__(143);
 		},
 		get RawSource() {
-			return __nccwpck_require__(855);
+			return __nccwpck_require__(371);
 		},
 		get OriginalSource() {
-			return __nccwpck_require__(792);
+			return __nccwpck_require__(924);
 		},
 		get SourceMapSource() {
-			return __nccwpck_require__(476);
+			return __nccwpck_require__(8);
 		},
 		get CachedSource() {
-			return __nccwpck_require__(61);
+			return __nccwpck_require__(969);
 		},
 		get ConcatSource() {
-			return __nccwpck_require__(523);
+			return __nccwpck_require__(415);
 		},
 		get ReplaceSource() {
-			return __nccwpck_require__(197);
+			return __nccwpck_require__(753);
 		},
 		get PrefixSource() {
-			return __nccwpck_require__(199);
+			return __nccwpck_require__(11);
 		},
 		get SizeOnlySource() {
-			return __nccwpck_require__(628);
+			return __nccwpck_require__(216);
 		},
 		get CompatSource() {
-			return __nccwpck_require__(961);
+			return __nccwpck_require__(589);
 		},
 		util: {
 			get stringBufferUtils() {
-				return __nccwpck_require__(806);
+				return __nccwpck_require__(386);
 			},
 		},
 	},
@@ -4725,7 +5327,7 @@ module.exports = mergeExports(
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __nccwpck_require__(340);
+/******/ 	var __webpack_exports__ = __nccwpck_require__(864);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()