@rspack/core 1.3.10 → 1.3.12

package/compiled/webpack-sources/index.js

@@ -1,62 +1,127 @@
 /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 453:
+/***/ 627:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const Source = __nccwpck_require__(171);
-const streamChunksOfSourceMap = __nccwpck_require__(958);
-const streamChunksOfRawSource = __nccwpck_require__(348);
-const streamAndGetSourceAndMap = __nccwpck_require__(391);
 
-const mapToBufferedMap = map => {
+const Source = __nccwpck_require__(225);
+const streamAndGetSourceAndMap = __nccwpck_require__(765);
+const streamChunksOfRawSource = __nccwpck_require__(482);
+const streamChunksOfSourceMap = __nccwpck_require__(492);
+const {
+	isDualStringBufferCachingEnabled
+} = __nccwpck_require__(672);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @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 */
+
+/**
+ * @typedef {object} BufferedMap
+ * @property {number} version
+ * @property {string[]} sources
+ * @property {string[]} names
+ * @property {string=} sourceRoot
+ * @property {(Buffer | "")[]=} sourcesContent
+ * @property {Buffer=} mappings
+ * @property {string} file
+ */
+
+/**
+ * @param {null | RawSourceMap} map map
+ * @returns {null | BufferedMap} buffered map
+ */
+const mapToBufferedMap = (map) => {
 	if (typeof map !== "object" || !map) return map;
-	const bufferedMap = Object.assign({}, map);
+	/** @type {BufferedMap} */
+	const bufferedMap = Object.assign(/** @type {BufferedMap} */ ({}), map);
 	if (map.mappings) {
 		bufferedMap.mappings = Buffer.from(map.mappings, "utf-8");
 	}
 	if (map.sourcesContent) {
 		bufferedMap.sourcesContent = map.sourcesContent.map(
-			str => str && Buffer.from(str, "utf-8")
+			(str) => str && Buffer.from(str, "utf-8")
 		);
 	}
 	return bufferedMap;
 };
 
-const bufferedMapToMap = bufferedMap => {
+/**
+ * @param {null | BufferedMap} bufferedMap buffered map
+ * @returns {null | RawSourceMap} map
+ */
+const bufferedMapToMap = (bufferedMap) => {
 	if (typeof bufferedMap !== "object" || !bufferedMap) return bufferedMap;
-	const map = Object.assign({}, bufferedMap);
+	/** @type {RawSourceMap} */
+	const map = Object.assign(/** @type {RawSourceMap} */ ({}), bufferedMap);
 	if (bufferedMap.mappings) {
 		map.mappings = bufferedMap.mappings.toString("utf-8");
 	}
 	if (bufferedMap.sourcesContent) {
 		map.sourcesContent = bufferedMap.sourcesContent.map(
-			buffer => buffer && buffer.toString("utf-8")
+			(buffer) => buffer && buffer.toString("utf-8")
 		);
 	}
 	return map;
 };
 
+/** @typedef {{ map?: null | RawSourceMap, bufferedMap?: null | BufferedMap }} BufferEntry */
+/** @typedef {Map<string, BufferEntry>} BufferedMaps */
+
+/**
+ * @typedef {object} CachedData
+ * @property {boolean=} source
+ * @property {Buffer} buffer
+ * @property {number=} size
+ * @property {BufferedMaps} maps
+ * @property {(string | Buffer)[]=} hash
+ */
+
 class CachedSource extends Source {
+	// eslint-disable-next-line valid-jsdoc
+	/**
+	 * @param {Source | (() => Source)} source source
+	 * @param {CachedData=} cachedData cached data
+	 */
 	constructor(source, cachedData) {
 		super();
 		this._source = source;
 		this._cachedSourceType = cachedData ? cachedData.source : undefined;
+		/**
+		 * @private
+		 * @type {undefined | string}
+		 */
 		this._cachedSource = undefined;
 		this._cachedBuffer = cachedData ? cachedData.buffer : undefined;
 		this._cachedSize = cachedData ? cachedData.size : undefined;
+		/**
+		 * @private
+		 * @type {BufferedMaps}
+		 */
 		this._cachedMaps = cachedData ? cachedData.maps : new Map();
 		this._cachedHashUpdate = cachedData ? cachedData.hash : undefined;
 	}
 
+	/**
+	 * @returns {CachedData} cached data
+	 */
 	getCachedData() {
+		/** @type {BufferedMaps} */
 		const bufferedMaps = new Map();
 		for (const pair of this._cachedMaps) {
 			let cacheEntry = pair[1];
@@ -70,15 +135,14 @@ class CachedSource extends Source {
 				bufferedMap: cacheEntry.bufferedMap
 			});
 		}
-		// 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
-		if (this._cachedSource) {
-			this.buffer();
-		}
 		return {
-			buffer: this._cachedBuffer,
+			// 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),
 			source:
 				this._cachedSourceType !== undefined
 					? this._cachedSourceType
@@ -102,36 +166,62 @@ class CachedSource extends Source {
 		return this._source;
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		const source = this._getCachedSource();
 		if (source !== undefined) return source;
-		return (this._cachedSource = this.original().source());
+		return (this._cachedSource =
+			/** @type {string} */
+			(this.original().source()));
 	}
 
+	/**
+	 * @private
+	 * @param {BufferEntry} cacheEntry cache entry
+	 * @returns {null | RawSourceMap} raw source map
+	 */
 	_getMapFromCacheEntry(cacheEntry) {
 		if (cacheEntry.map !== undefined) {
 			return cacheEntry.map;
 		} else if (cacheEntry.bufferedMap !== undefined) {
 			return (cacheEntry.map = bufferedMapToMap(cacheEntry.bufferedMap));
 		}
+
+		return null;
 	}
 
+	/**
+	 * @private
+	 * @returns {undefined | string} cached source
+	 */
 	_getCachedSource() {
 		if (this._cachedSource !== undefined) return this._cachedSource;
 		if (this._cachedBuffer && this._cachedSourceType !== undefined) {
-			return (this._cachedSource = this._cachedSourceType
+			const value = this._cachedSourceType
 				? this._cachedBuffer.toString("utf-8")
-				: this._cachedBuffer);
+				: this._cachedBuffer;
+			if (isDualStringBufferCachingEnabled()) {
+				this._cachedSource = /** @type {string} */ (value);
+			}
+			return /** @type {string} */ (value);
 		}
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (this._cachedBuffer !== undefined) return this._cachedBuffer;
 		if (this._cachedSource !== undefined) {
-			if (Buffer.isBuffer(this._cachedSource)) {
-				return (this._cachedBuffer = this._cachedSource);
+			const value = Buffer.isBuffer(this._cachedSource)
+				? this._cachedSource
+				: Buffer.from(this._cachedSource, "utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._cachedBuffer = value;
 			}
-			return (this._cachedBuffer = Buffer.from(this._cachedSource, "utf-8"));
+			return value;
 		}
 		if (typeof this.original().buffer === "function") {
 			return (this._cachedBuffer = this.original().buffer());
@@ -140,9 +230,16 @@ class CachedSource extends Source {
 		if (Buffer.isBuffer(bufferOrString)) {
 			return (this._cachedBuffer = bufferOrString);
 		}
-		return (this._cachedBuffer = Buffer.from(bufferOrString, "utf-8"));
+		const value = Buffer.from(bufferOrString, "utf-8");
+		if (isDualStringBufferCachingEnabled()) {
+			this._cachedBuffer = value;
+		}
+		return value;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
 	size() {
 		if (this._cachedSize !== undefined) return this._cachedSize;
 		if (this._cachedBuffer !== undefined) {
@@ -155,6 +252,10 @@ class CachedSource extends Source {
 		return (this._cachedSize = this.original().size());
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
 	sourceAndMap(options) {
 		const key = options ? JSON.stringify(options) : "{}";
 		const cacheEntry = this._cachedMaps.get(key);
@@ -162,6 +263,7 @@ class CachedSource extends Source {
 		if (cacheEntry !== undefined) {
 			// We have a cached map in some representation
 			const map = this._getMapFromCacheEntry(cacheEntry);
+
 			// Either get the cached source or compute it
 			return { source: this.source(), map };
 		}
@@ -174,7 +276,7 @@ class CachedSource extends Source {
 		} else {
 			// Compute the source and map together.
 			const sourceAndMap = this.original().sourceAndMap(options);
-			source = sourceAndMap.source;
+			source = /** @type {string} */ (sourceAndMap.source);
 			map = sourceAndMap.map;
 			this._cachedSource = source;
 		}
@@ -185,6 +287,13 @@ class CachedSource extends Source {
 		return { source, map };
 	}
 
+	/**
+	 * @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) {
 		const key = options ? JSON.stringify(options) : "{}";
 		if (
@@ -194,7 +303,8 @@ class CachedSource extends Source {
 			const { source, map } = this.sourceAndMap(options);
 			if (map) {
 				return streamChunksOfSourceMap(
-					source,
+					/** @type {string} */
+					(source),
 					map,
 					onChunk,
 					onSource,
@@ -204,7 +314,8 @@ class CachedSource extends Source {
 				);
 			} else {
 				return streamChunksOfRawSource(
-					source,
+					/** @type {string} */
+					(source),
 					onChunk,
 					onSource,
 					onName,
@@ -221,12 +332,16 @@ class CachedSource extends Source {
 		);
 		this._cachedSource = source;
 		this._cachedMaps.set(key, {
-			map,
+			map: /** @type {RawSourceMap} */ (map),
 			bufferedMap: undefined
 		});
 		return result;
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		const key = options ? JSON.stringify(options) : "{}";
 		const cacheEntry = this._cachedMaps.get(key);
@@ -241,15 +356,25 @@ class CachedSource extends Source {
 		return map;
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		if (this._cachedHashUpdate !== undefined) {
 			for (const item of this._cachedHashUpdate) hash.update(item);
 			return;
 		}
+		/** @type {(string | Buffer)[]} */
 		const update = [];
+		/** @type {string | undefined} */
 		let currentString = undefined;
 		const tracker = {
-			update: item => {
+			/**
+			 * @param {string | Buffer} item item
+			 * @returns {void}
+			 */
+			update: (item) => {
 				if (typeof item === "string" && item.length < 10240) {
 					if (currentString === undefined) {
 						currentString = item;
@@ -269,7 +394,7 @@ class CachedSource extends Source {
 				}
 			}
 		};
-		this.original().updateHash(tracker);
+		this.original().updateHash(/** @type {Hash} */ (tracker));
 		if (currentString !== undefined) {
 			update.push(Buffer.from(currentString));
 		}
@@ -283,30 +408,56 @@ module.exports = CachedSource;
 
 /***/ }),
 
-/***/ 273:
+/***/ 583:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const Source = __nccwpck_require__(171);
+
+const Source = __nccwpck_require__(225);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @typedef {import("./Source").MapOptions} MapOptions */
+/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./Source").SourceAndMap} SourceAndMap */
+/** @typedef {import("./Source").SourceValue} SourceValue */
+
+/**
+ * @typedef {object} SourceLike
+ * @property {() => SourceValue} source
+ * @property {(() => Buffer)=} buffer
+ * @property {(() => number)=} size
+ * @property {((options?: MapOptions) => RawSourceMap | null)=} map
+ * @property {((options?: MapOptions) => SourceAndMap)=} sourceAndMap
+ * @property {((hash: Hash) => void)=} updateHash
+ */
 
 class CompatSource extends Source {
+	/**
+	 * @param {SourceLike} sourceLike source like
+	 * @returns {Source} source
+	 */
 	static from(sourceLike) {
 		return sourceLike instanceof Source
 			? sourceLike
 			: new CompatSource(sourceLike);
 	}
 
+	/**
+	 * @param {SourceLike} sourceLike source like
+	 */
 	constructor(sourceLike) {
 		super();
 		this._sourceLike = sourceLike;
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		return this._sourceLike.source();
 	}
@@ -325,6 +476,10 @@ class CompatSource extends Source {
 		return super.size();
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		if (typeof this._sourceLike.map === "function") {
 			return this._sourceLike.map(options);
@@ -332,6 +487,10 @@ class CompatSource extends Source {
 		return super.map(options);
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
 	sourceAndMap(options) {
 		if (typeof this._sourceLike.sourceAndMap === "function") {
 			return this._sourceLike.sourceAndMap(options);
@@ -339,6 +498,10 @@ class CompatSource extends Source {
 		return super.sourceAndMap(options);
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		if (typeof this._sourceLike.updateHash === "function") {
 			return this._sourceLike.updateHash(hash);
@@ -357,29 +520,52 @@ module.exports = CompatSource;
 
 /***/ }),
 
-/***/ 987:
+/***/ 49:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const Source = __nccwpck_require__(171);
-const RawSource = __nccwpck_require__(327);
-const streamChunks = __nccwpck_require__(266);
-const { getMap, getSourceAndMap } = __nccwpck_require__(56);
+
+const RawSource = __nccwpck_require__(745);
+const Source = __nccwpck_require__(225);
+const { getMap, getSourceAndMap } = __nccwpck_require__(614);
+const streamChunks = __nccwpck_require__(372);
+
+/** @typedef {import("./CompatSource").SourceLike} SourceLike */
+/** @typedef {import("./Source").Hash} Hash */
+/** @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 */
+
+/** @typedef {string | Source | SourceLike} Child */
 
 const stringsAsRawSources = new WeakSet();
 
 class ConcatSource extends Source {
-	constructor() {
+	/**
+	 *
+	 * @param {Child[]} args children
+	 */
+	constructor(...args) {
 		super();
+		/**
+		 * @private
+		 * @type {Child[]}
+		 */
 		this._children = [];
-		for (let i = 0; i < arguments.length; i++) {
-			const item = arguments[i];
+
+		for (let i = 0; i < args.length; i++) {
+			const item = args[i];
 			if (item instanceof ConcatSource) {
 				for (const child of item._children) {
 					this._children.push(child);
@@ -388,14 +574,22 @@ class ConcatSource extends Source {
 				this._children.push(item);
 			}
 		}
-		this._isOptimized = arguments.length === 0;
+
+		this._isOptimized = args.length === 0;
 	}
 
+	/**
+	 * @returns {Source[]} children
+	 */
 	getChildren() {
 		if (!this._isOptimized) this._optimize();
-		return this._children;
+		return /** @type {Source[]} */ (this._children);
 	}
 
+	/**
+	 * @param {Child} item item
+	 * @returns {void}
+	 */
 	add(item) {
 		if (item instanceof ConcatSource) {
 			for (const child of item._children) {
@@ -407,6 +601,10 @@ class ConcatSource extends Source {
 		this._isOptimized = false;
 	}
 
+	/**
+	 * @param {Child[]} items items
+	 * @returns {void}
+	 */
 	addAllSkipOptimizing(items) {
 		for (const item of items) {
 			this._children.push(item);
@@ -415,8 +613,9 @@ class ConcatSource extends Source {
 
 	buffer() {
 		if (!this._isOptimized) this._optimize();
+		/** @type {Buffer[]} */
 		const buffers = [];
-		for (const child of this._children) {
+		for (const child of /** @type {SourceLike[]} */ (this._children)) {
 			if (typeof child.buffer === "function") {
 				buffers.push(child.buffer());
 			} else {
@@ -432,11 +631,14 @@ class ConcatSource extends Source {
 		return Buffer.concat(buffers);
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		if (!this._isOptimized) this._optimize();
 		let source = "";
 		for (const child of this._children) {
-			source += child.source();
+			source += /** @type {Source} */ (child).source();
 		}
 		return source;
 	}
@@ -445,23 +647,44 @@ class ConcatSource extends Source {
 		if (!this._isOptimized) this._optimize();
 		let size = 0;
 		for (const child of this._children) {
-			size += child.size();
+			size += /** @type {Source} */ (child).size();
 		}
 		return size;
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		return getMap(this, options);
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
 	sourceAndMap(options) {
 		return getSourceAndMap(this, options);
 	}
 
+	/**
+	 * @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) {
 		if (!this._isOptimized) this._optimize();
-		if (this._children.length === 1)
-			return this._children[0].streamChunks(options, onChunk, onSource, onName);
+		if (this._children.length === 1) {
+			return /** @type {ConcatSource[]} */ (this._children)[0].streamChunks(
+				options,
+				onChunk,
+				onSource,
+				onName
+			);
+		}
 		let currentLineOffset = 0;
 		let currentColumnOffset = 0;
 		let sourceMapping = new Map();
@@ -469,8 +692,10 @@ class ConcatSource extends Source {
 		const finalSource = !!(options && options.finalSource);
 		let code = "";
 		let needToCloseMapping = false;
-		for (const item of this._children) {
+		for (const item of /** @type {Source[]} */ (this._children)) {
+			/** @type {number[]} */
 			const sourceIndexMapping = [];
+			/** @type {number[]} */
 			const nameIndexMapping = [];
 			let lastMappingLine = 0;
 			const { generatedLine, generatedColumn, source } = streamChunks(
@@ -575,15 +800,15 @@ class ConcatSource extends Source {
 					needToCloseMapping = false;
 				}
 			}
-			if (generatedLine > 1) {
-				currentColumnOffset = generatedColumn;
+			if (/** @type {number} */ (generatedLine) > 1) {
+				currentColumnOffset = /** @type {number} */ (generatedColumn);
 			} else {
-				currentColumnOffset += generatedColumn;
+				currentColumnOffset += /** @type {number} */ (generatedColumn);
 			}
 			needToCloseMapping =
 				needToCloseMapping ||
 				(finalSource && lastMappingLine === generatedLine);
-			currentLineOffset += generatedLine - 1;
+			currentLineOffset += /** @type {number} */ (generatedLine) - 1;
 		}
 		return {
 			generatedLine: currentLineOffset + 1,
@@ -592,19 +817,29 @@ class ConcatSource extends Source {
 		};
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		if (!this._isOptimized) this._optimize();
 		hash.update("ConcatSource");
 		for (const item of this._children) {
-			item.updateHash(hash);
+			/** @type {Source} */
+			(item).updateHash(hash);
 		}
 	}
 
 	_optimize() {
 		const newChildren = [];
 		let currentString = undefined;
+		/** @type {undefined | string | [string, string] | SourceLike} */
 		let currentRawSources = undefined;
-		const addStringToRawSources = string => {
+		/**
+		 * @param {string} string string
+		 * @returns {void}
+		 */
+		const addStringToRawSources = (string) => {
 			if (currentRawSources === undefined) {
 				currentRawSources = string;
 			} else if (Array.isArray(currentRawSources)) {
@@ -613,22 +848,30 @@ class ConcatSource extends Source {
 				currentRawSources = [
 					typeof currentRawSources === "string"
 						? currentRawSources
-						: currentRawSources.source(),
+						: /** @type {string} */ (currentRawSources.source()),
 					string
 				];
 			}
 		};
-		const addSourceToRawSources = source => {
+		/**
+		 * @param {SourceLike} source source
+		 * @returns {void}
+		 */
+		const addSourceToRawSources = (source) => {
 			if (currentRawSources === undefined) {
 				currentRawSources = source;
 			} else if (Array.isArray(currentRawSources)) {
-				currentRawSources.push(source.source());
+				currentRawSources.push(
+					/** @type {string} */
+					(source.source())
+				);
 			} else {
 				currentRawSources = [
 					typeof currentRawSources === "string"
 						? currentRawSources
-						: currentRawSources.source(),
-					source.source()
+						: /** @type {string} */ (currentRawSources.source()),
+					/** @type {string} */
+					(source.source())
 				];
 			}
 		};
@@ -658,7 +901,10 @@ class ConcatSource extends Source {
 					currentString = undefined;
 				}
 				if (stringsAsRawSources.has(child)) {
-					addSourceToRawSources(child);
+					addSourceToRawSources(
+						/** @type {SourceLike} */
+						(child)
+					);
 				} else {
 					if (currentRawSources !== undefined) {
 						mergeRawSources();
@@ -684,27 +930,55 @@ module.exports = ConcatSource;
 
 /***/ }),
 
-/***/ 472:
+/***/ 734:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const { getMap, getSourceAndMap } = __nccwpck_require__(56);
-const splitIntoLines = __nccwpck_require__(877);
-const getGeneratedSourceInfo = __nccwpck_require__(864);
-const Source = __nccwpck_require__(171);
-const splitIntoPotentialTokens = __nccwpck_require__(914);
+
+const Source = __nccwpck_require__(225);
+const { getMap, getSourceAndMap } = __nccwpck_require__(614);
+const getGeneratedSourceInfo = __nccwpck_require__(278);
+const splitIntoLines = __nccwpck_require__(51);
+const splitIntoPotentialTokens = __nccwpck_require__(904);
+const {
+	isDualStringBufferCachingEnabled
+} = __nccwpck_require__(672);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @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 */
 
 class OriginalSource extends Source {
+	/**
+	 * @param {string | Buffer} value value
+	 * @param {string} name name
+	 */
 	constructor(value, name) {
 		super();
+
 		const isBuffer = Buffer.isBuffer(value);
+
+		/**
+		 * @private
+		 * @type {undefined | string}
+		 */
 		this._value = isBuffer ? undefined : value;
+		/**
+		 * @private
+		 * @type {undefined | Buffer}
+		 */
 		this._valueAsBuffer = isBuffer ? value : undefined;
 		this._name = name;
 	}
@@ -713,38 +987,61 @@ class OriginalSource extends Source {
 		return this._name;
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		if (this._value === undefined) {
-			this._value = this._valueAsBuffer.toString("utf-8");
+			const value =
+				/** @type {Buffer} */
+				(this._valueAsBuffer).toString("utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._value = value;
+			}
+			return value;
 		}
 		return this._value;
 	}
 
 	buffer() {
 		if (this._valueAsBuffer === undefined) {
-			this._valueAsBuffer = Buffer.from(this._value, "utf-8");
+			const value = Buffer.from(/** @type {string} */ (this._value), "utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._valueAsBuffer = value;
+			}
+			return value;
 		}
 		return this._valueAsBuffer;
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		return getMap(this, options);
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
 	sourceAndMap(options) {
 		return getSourceAndMap(this, options);
 	}
 
 	/**
-	 * @param {object} options options
-	 * @param {function(string, number, number, number, number, number, number): void} onChunk called for each chunk of code
-	 * @param {function(number, string, string)} onSource called for each source
-	 * @param {function(number, string)} onName called for each name
-	 * @returns {void}
+	 * @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) {
 		if (this._value === undefined) {
-			this._value = this._valueAsBuffer.toString("utf-8");
+			this._value =
+				/** @type {Buffer} */
+				(this._valueAsBuffer).toString("utf-8");
 		}
 		onSource(0, this._name, this._value);
 		const finalSource = !!(options && options.finalSource);
@@ -781,10 +1078,14 @@ class OriginalSource extends Source {
 			const result = getGeneratedSourceInfo(this._value);
 			const { generatedLine, generatedColumn } = result;
 			if (generatedColumn === 0) {
-				for (let line = 1; line < generatedLine; line++)
+				for (let line = 1; line < /** @type {number} */ (generatedLine); line++)
 					onChunk(undefined, line, 0, 0, line, 0, -1);
 			} else {
-				for (let line = 1; line <= generatedLine; line++)
+				for (
+					let line = 1;
+					line <= /** @type {number} */ (generatedLine);
+					line++
+				)
 					onChunk(undefined, line, 0, 0, line, 0, -1);
 			}
 			return result;
@@ -793,12 +1094,14 @@ class OriginalSource extends Source {
 			// we need to split source by lines
 			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);
 				line++;
 			}
-			return matches.length === 0 || match.endsWith("\n")
+			return matches.length === 0 ||
+				/** @type {string} */ (match).endsWith("\n")
 				? {
 						generatedLine: matches.length + 1,
 						generatedColumn: 0,
@@ -806,18 +1109,23 @@ class OriginalSource extends Source {
 				  }
 				: {
 						generatedLine: matches.length,
-						generatedColumn: match.length,
+						generatedColumn: /** @type {string} */ (match).length,
 						source: finalSource ? this._value : undefined
 				  };
 		}
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
-		if (this._valueAsBuffer === undefined) {
-			this._valueAsBuffer = Buffer.from(this._value, "utf-8");
-		}
 		hash.update("OriginalSource");
-		hash.update(this._valueAsBuffer);
+		hash.update(
+			this._valueAsBuffer
+				? /** @type {Buffer} */ (this._valueAsBuffer)
+				: /** @type {string} */ (this._value)
+		);
 		hash.update(this._name || "");
 	}
 }
@@ -827,26 +1135,45 @@ module.exports = OriginalSource;
 
 /***/ }),
 
-/***/ 663:
+/***/ 805:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const Source = __nccwpck_require__(171);
-const RawSource = __nccwpck_require__(327);
-const streamChunks = __nccwpck_require__(266);
-const { getMap, getSourceAndMap } = __nccwpck_require__(56);
+
+const RawSource = __nccwpck_require__(745);
+const Source = __nccwpck_require__(225);
+const { getMap, getSourceAndMap } = __nccwpck_require__(614);
+const streamChunks = __nccwpck_require__(372);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @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 */
 
 const REPLACE_REGEX = /\n(?=.|\s)/g;
 
 class PrefixSource extends Source {
+	/**
+	 * @param {string} prefix prefix
+	 * @param {string | Buffer | Source} source source
+	 */
 	constructor(prefix, source) {
 		super();
+		/**
+		 * @private
+		 * @type {Source}
+		 */
 		this._source =
 			typeof source === "string" || Buffer.isBuffer(source)
 				? new RawSource(source, true)
@@ -862,22 +1189,40 @@ class PrefixSource extends Source {
 		return this._source;
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
-		const node = this._source.source();
+		const node = /** @type {string} */ (this._source.source());
 		const prefix = this._prefix;
 		return prefix + node.replace(REPLACE_REGEX, "\n" + prefix);
 	}
 
 	// TODO efficient buffer() implementation
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		return getMap(this, options);
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
 	sourceAndMap(options) {
 		return getSourceAndMap(this, options);
 	}
 
+	/**
+	 * @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) {
 		const prefix = this._prefix;
 		const prefixOffset = prefix.length;
@@ -929,7 +1274,9 @@ class PrefixSource extends Source {
 		return {
 			generatedLine,
 			generatedColumn:
-				generatedColumn === 0 ? 0 : prefixOffset + generatedColumn,
+				generatedColumn === 0
+					? 0
+					: prefixOffset + /** @type {number} */ (generatedColumn),
 			source:
 				source !== undefined
 					? prefix + source.replace(REPLACE_REGEX, "\n" + prefix)
@@ -937,6 +1284,10 @@ class PrefixSource extends Source {
 		};
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		hash.update("PrefixSource");
 		this._source.updateHash(hash);
@@ -949,10 +1300,9 @@ module.exports = PrefixSource;
 
 /***/ }),
 
-/***/ 327:
+/***/ 745:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -960,63 +1310,116 @@ module.exports = PrefixSource;
 
 
 
-const streamChunksOfRawSource = __nccwpck_require__(348);
-const Source = __nccwpck_require__(171);
+const Source = __nccwpck_require__(225);
+const streamChunksOfRawSource = __nccwpck_require__(482);
+const {
+	internString,
+	isDualStringBufferCachingEnabled
+} = __nccwpck_require__(672);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @typedef {import("./Source").MapOptions} MapOptions */
+/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
+/** @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 */
 
 class RawSource extends Source {
+	/**
+	 * @param {string | Buffer} value value
+	 * @param {boolean=} convertToString convert to string
+	 */
 	constructor(value, convertToString = false) {
 		super();
 		const isBuffer = Buffer.isBuffer(value);
 		if (!isBuffer && typeof value !== "string") {
-			throw new TypeError("argument 'value' must be either string of Buffer");
+			throw new TypeError("argument 'value' must be either string or Buffer");
 		}
 		this._valueIsBuffer = !convertToString && isBuffer;
-		this._value = convertToString && isBuffer ? undefined : value;
+		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;
-		this._valueAsString = isBuffer ? undefined : value;
+		/**
+		 * @private
+		 * @type {undefined | string}
+		 */
+		this._valueAsString = isBuffer ? undefined : internedString;
 	}
 
 	isBuffer() {
 		return this._valueIsBuffer;
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		if (this._value === undefined) {
-			this._value = this._valueAsBuffer.toString("utf-8");
+			const value =
+				/** @type {Buffer} */
+				(this._valueAsBuffer).toString("utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._value = internString(value);
+			}
+			return value;
 		}
 		return this._value;
 	}
 
 	buffer() {
 		if (this._valueAsBuffer === undefined) {
-			this._valueAsBuffer = Buffer.from(this._value, "utf-8");
+			const value = Buffer.from(/** @type {string} */ (this._value), "utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._valueAsBuffer = value;
+			}
+			return value;
 		}
 		return this._valueAsBuffer;
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		return null;
 	}
 
 	/**
-	 * @param {object} options options
-	 * @param {function(string, number, number, number, number, number, number): void} onChunk called for each chunk of code
-	 * @param {function(number, string, string)} onSource called for each source
-	 * @param {function(number, string)} onName called for each name
-	 * @returns {void}
+	 * @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) {
-		if (this._value === undefined) {
-			this._value = Buffer.from(this._valueAsBuffer, "utf-8");
-		}
-		if (this._valueAsString === undefined) {
-			this._valueAsString =
-				typeof this._value === "string"
-					? this._value
-					: this._value.toString("utf-8");
+		let strValue = this._valueAsString;
+		if (strValue === undefined) {
+			const value = this.source();
+			strValue = typeof value === "string" ? value : value.toString("utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._valueAsString = internString(strValue);
+			}
 		}
 		return streamChunksOfRawSource(
-			this._valueAsString,
+			strValue,
 			onChunk,
 			onSource,
 			onName,
@@ -1024,12 +1427,17 @@ class RawSource extends Source {
 		);
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
-		if (this._valueAsBuffer === undefined) {
-			this._valueAsBuffer = Buffer.from(this._value, "utf-8");
-		}
 		hash.update("RawSource");
-		hash.update(this._valueAsBuffer);
+		hash.update(
+			this._valueAsBuffer
+				? /** @type {Buffer} */ (this._valueAsBuffer)
+				: /** @type {string} */ (this._valueAsString)
+		);
 	}
 }
 
@@ -1038,20 +1446,31 @@ module.exports = RawSource;
 
 /***/ }),
 
-/***/ 829:
+/***/ 807:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const { getMap, getSourceAndMap } = __nccwpck_require__(56);
-const streamChunks = __nccwpck_require__(266);
-const Source = __nccwpck_require__(171);
-const splitIntoLines = __nccwpck_require__(877);
+
+const Source = __nccwpck_require__(225);
+const { getMap, getSourceAndMap } = __nccwpck_require__(614);
+const splitIntoLines = __nccwpck_require__(51);
+const streamChunks = __nccwpck_require__(372);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @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 =
@@ -1064,6 +1483,12 @@ const hasStableSort =
 const MAX_SOURCE_POSITION = 0x20000000;
 
 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;
@@ -1076,6 +1501,10 @@ class Replacement {
 }
 
 class ReplaceSource extends Source {
+	/**
+	 * @param {Source} source source
+	 * @param {string=} name name
+	 */
 	constructor(source, name) {
 		super();
 		this._source = source;
@@ -1094,6 +1523,13 @@ class ReplaceSource extends Source {
 		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(
@@ -1103,6 +1539,12 @@ class ReplaceSource extends Source {
 		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(
@@ -1115,6 +1557,9 @@ class ReplaceSource extends Source {
 		this._isSorted = false;
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		if (this._replacements.length === 0) {
 			return this._source.source();
@@ -1144,6 +1589,10 @@ class ReplaceSource extends Source {
 		return result.join("");
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		if (this._replacements.length === 0) {
 			return this._source.map(options);
@@ -1151,6 +1600,10 @@ class ReplaceSource extends Source {
 		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);
@@ -1179,27 +1632,49 @@ class ReplaceSource extends Source {
 				if (diff1 !== 0) return diff1;
 				const diff2 = a.end - b.end;
 				if (diff2 !== 0) return diff2;
-				return a.index - b.index;
+				return (
+					/** @type {number} */ (a.index) - /** @type {number} */ (b.index)
+				);
 			});
 		}
 		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();
-		const repls = this._replacements;
+		const replacements = this._replacements;
 		let pos = 0;
 		let i = 0;
 		let replacmentEnd = -1;
 		let nextReplacement =
-			i < repls.length ? Math.floor(repls[i].start) : MAX_SOURCE_POSITION;
+			i < replacements.length
+				? Math.floor(replacements[i].start)
+				: MAX_SOURCE_POSITION;
 		let generatedLineOffset = 0;
 		let generatedColumnOffset = 0;
 		let generatedColumnOffsetLine = 0;
+		/** @type {(string | string[] | undefined)[]} */
 		const sourceContents = [];
+		/** @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) => {
+			/** @type {undefined | string | string[]} */
 			let content =
 				sourceIndex < sourceContents.length
 					? sourceContents[sourceIndex]
@@ -1220,7 +1695,7 @@ class ReplaceSource extends Source {
 			this._source,
 			Object.assign({}, options, { finalSource: false }),
 			(
-				chunk,
+				_chunk,
 				generatedLine,
 				generatedColumn,
 				sourceIndex,
@@ -1229,6 +1704,7 @@ class ReplaceSource extends Source {
 				nameIndex
 			) => {
 				let chunkPos = 0;
+				const chunk = /** @type {string} */ (_chunk);
 				let endPos = pos + chunk.length;
 
 				// Skip over when it has been replaced
@@ -1313,7 +1789,7 @@ class ReplaceSource extends Source {
 						}
 
 						// Insert replacement content splitted into chunks by lines
-						const { content, name } = repls[i];
+						const { content, name } = replacements[i];
 						let matches = splitIntoLines(content);
 						let replacementNameIndex = nameIndex;
 						if (sourceIndex >= 0 && name) {
@@ -1361,14 +1837,14 @@ class ReplaceSource extends Source {
 						// Remove replaced content by settings this variable
 						replacmentEnd = Math.max(
 							replacmentEnd,
-							Math.floor(repls[i].end + 1)
+							Math.floor(replacements[i].end + 1)
 						);
 
 						// Move to next replacment
 						i++;
 						nextReplacement =
-							i < repls.length
-								? Math.floor(repls[i].start)
+							i < replacements.length
+								? Math.floor(replacements[i].start)
 								: MAX_SOURCE_POSITION;
 
 						// Skip over when it has been replaced
@@ -1454,19 +1930,20 @@ class ReplaceSource extends Source {
 
 		// Handle remaining replacements
 		let remainer = "";
-		for (; i < repls.length; i++) {
-			remainer += repls[i].content;
+		for (; i < replacements.length; i++) {
+			remainer += replacements[i].content;
 		}
 
 		// Insert remaining replacements content splitted into chunks by lines
-		let line = generatedLine + generatedLineOffset;
+		let line = /** @type {number} */ (generatedLine) + generatedLineOffset;
 		let matches = splitIntoLines(remainer);
 		for (let m = 0; m < matches.length; m++) {
 			const contentLine = matches[m];
 			onChunk(
 				contentLine,
 				line,
-				generatedColumn +
+				/** @type {number} */
+				(generatedColumn) +
 					(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
 				-1,
 				-1,
@@ -1484,7 +1961,7 @@ class ReplaceSource extends Source {
 			} else {
 				generatedLineOffset++;
 				line++;
-				generatedColumnOffset = -generatedColumn;
+				generatedColumnOffset = -(/** @type {number} */ (generatedColumn));
 				generatedColumnOffsetLine = line;
 			}
 		}
@@ -1492,40 +1969,56 @@ class ReplaceSource extends Source {
 		return {
 			generatedLine: line,
 			generatedColumn:
-				generatedColumn +
+				/** @type {number} */
+				(generatedColumn) +
 				(line === generatedColumnOffsetLine ? generatedColumnOffset : 0)
 		};
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		this._sortReplacements();
 		hash.update("ReplaceSource");
 		this._source.updateHash(hash);
 		hash.update(this._name || "");
 		for (const repl of this._replacements) {
-			hash.update(`${repl.start}${repl.end}${repl.content}${repl.name}`);
+			hash.update(
+				`${repl.start}${repl.end}${repl.content}${repl.name ? repl.name : ""}`
+			);
 		}
 	}
 }
 
 module.exports = ReplaceSource;
+module.exports.Replacement = Replacement;
 
 
 /***/ }),
 
-/***/ 908:
+/***/ 90:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const Source = __nccwpck_require__(171);
+
+const Source = __nccwpck_require__(225);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @typedef {import("./Source").MapOptions} MapOptions */
+/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./Source").SourceValue} SourceValue */
 
 class SizeOnlySource extends Source {
+	/**
+	 * @param {number} size size
+	 */
 	constructor(size) {
 		super();
 		this._size = size;
@@ -1541,19 +2034,33 @@ class SizeOnlySource extends Source {
 		return this._size;
 	}
 
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		throw this._error();
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		throw this._error();
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		throw this._error();
 	}
 
-	updateHash() {
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
+	updateHash(hash) {
 		throw this._error();
 	}
 }
@@ -1563,17 +2070,51 @@ module.exports = SizeOnlySource;
 
 /***/ }),
 
-/***/ 171:
+/***/ 225:
 /***/ ((module) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
+
+/**
+ * @typedef {object} MapOptions
+ * @property {boolean=} columns
+ * @property {boolean=} module
+ */
+
+/**
+ * @typedef {object} RawSourceMap
+ * @property {number} version
+ * @property {string[]} sources
+ * @property {string[]} names
+ * @property {string=} sourceRoot
+ * @property {string[]=} sourcesContent
+ * @property {string} mappings
+ * @property {string} file
+ */
+
+/** @typedef {string | Buffer} SourceValue */
+
+/**
+ * @typedef {object} SourceAndMap
+ * @property {SourceValue} source
+ * @property {RawSourceMap | null} map
+ */
+
+/**
+ * @typedef {object} Hash
+ * @property {(data: string | Buffer, inputEncoding?: string) => Hash} update
+ * @property {(encoding?: string) => string | Buffer} digest
+ */
+
 class Source {
+	/**
+	 * @returns {SourceValue} source
+	 */
 	source() {
 		throw new Error("Abstract");
 	}
@@ -1588,10 +2129,18 @@ class Source {
 		return this.buffer().length;
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		return null;
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
 	sourceAndMap(options) {
 		return {
 			source: this.source(),
@@ -1599,6 +2148,10 @@ class Source {
 		};
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		throw new Error("Abstract");
 	}
@@ -1609,22 +2162,44 @@ module.exports = Source;
 
 /***/ }),
 
-/***/ 188:
+/***/ 150:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
-const Source = __nccwpck_require__(171);
-const streamChunksOfSourceMap = __nccwpck_require__(958);
-const streamChunksOfCombinedSourceMap = __nccwpck_require__(503);
-const { getMap, getSourceAndMap } = __nccwpck_require__(56);
+
+const Source = __nccwpck_require__(225);
+const { getMap, getSourceAndMap } = __nccwpck_require__(614);
+const streamChunksOfCombinedSourceMap = __nccwpck_require__(549);
+const streamChunksOfSourceMap = __nccwpck_require__(492);
+const {
+	isDualStringBufferCachingEnabled
+} = __nccwpck_require__(672);
+
+/** @typedef {import("./Source").Hash} Hash */
+/** @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 */
 
 class SourceMapSource extends Source {
+	/**
+	 * @param {string | Buffer} value value
+	 * @param {string} name name
+	 * @param {string | Buffer | RawSourceMap=} sourceMap source map
+	 * @param {SourceValue=} originalSource original source
+	 * @param {(string | Buffer | RawSourceMap)=} innerSourceMap inner source map
+	 * @param {boolean=} removeOriginalSource do remove original source
+	 */
 	constructor(
 		value,
 		name,
@@ -1635,7 +2210,15 @@ class SourceMapSource extends Source {
 	) {
 		super();
 		const valueIsBuffer = Buffer.isBuffer(value);
+		/**
+		 * @private
+		 * @type {undefined | string}
+		 */
 		this._valueAsString = valueIsBuffer ? undefined : value;
+		/**
+		 * @private
+		 * @type {undefined | Buffer}
+		 */
 		this._valueAsBuffer = valueIsBuffer ? value : undefined;
 
 		this._name = name;
@@ -1643,9 +2226,21 @@ class SourceMapSource extends Source {
 		this._hasSourceMap = !!sourceMap;
 		const sourceMapIsBuffer = Buffer.isBuffer(sourceMap);
 		const sourceMapIsString = typeof sourceMap === "string";
+		/**
+		 * @private
+		 * @type {undefined | RawSourceMap}
+		 */
 		this._sourceMapAsObject =
 			sourceMapIsBuffer || sourceMapIsString ? undefined : sourceMap;
+		/**
+		 * @private
+		 * @type {undefined | string}
+		 */
 		this._sourceMapAsString = sourceMapIsString ? sourceMap : undefined;
+		/**
+		 * @private
+		 * @type {undefined | Buffer}
+		 */
 		this._sourceMapAsBuffer = sourceMapIsBuffer ? sourceMap : undefined;
 
 		this._hasOriginalSource = !!originalSource;
@@ -1660,13 +2255,25 @@ class SourceMapSource extends Source {
 		this._hasInnerSourceMap = !!innerSourceMap;
 		const innerSourceMapIsBuffer = Buffer.isBuffer(innerSourceMap);
 		const innerSourceMapIsString = typeof innerSourceMap === "string";
+		/**
+		 * @private
+		 * @type {undefined | RawSourceMap}
+		 */
 		this._innerSourceMapAsObject =
 			innerSourceMapIsBuffer || innerSourceMapIsString
 				? undefined
 				: innerSourceMap;
+		/**
+		 * @private
+		 * @type {undefined | string}
+		 */
 		this._innerSourceMapAsString = innerSourceMapIsString
 			? innerSourceMap
 			: undefined;
+		/**
+		 * @private
+		 * @type {undefined | Buffer}
+		 */
 		this._innerSourceMapAsBuffer = innerSourceMapIsBuffer
 			? innerSourceMap
 			: undefined;
@@ -1674,147 +2281,211 @@ class SourceMapSource extends Source {
 		this._removeOriginalSource = removeOriginalSource;
 	}
 
-	_ensureValueBuffer() {
+	// eslint-disable-next-line valid-jsdoc
+	/**
+	 * @returns {[Buffer, string, Buffer, Buffer | undefined, Buffer | undefined, boolean | undefined]} args
+	 */
+	getArgsAsBuffers() {
+		return [
+			this.buffer(),
+			this._name,
+			this._sourceMapBuffer(),
+			this._originalSourceBuffer(),
+			this._innerSourceMapBuffer(),
+			this._removeOriginalSource
+		];
+	}
+
+	buffer() {
 		if (this._valueAsBuffer === undefined) {
-			this._valueAsBuffer = Buffer.from(this._valueAsString, "utf-8");
+			const value = Buffer.from(
+				/** @type {string} */ (this._valueAsString),
+				"utf-8"
+			);
+			if (isDualStringBufferCachingEnabled()) {
+				this._valueAsBuffer = value;
+			}
+			return value;
 		}
+		return this._valueAsBuffer;
 	}
 
-	_ensureValueString() {
+	/**
+	 * @returns {SourceValue} source
+	 */
+	source() {
 		if (this._valueAsString === undefined) {
-			this._valueAsString = this._valueAsBuffer.toString("utf-8");
+			const value =
+				/** @type {Buffer} */
+				(this._valueAsBuffer).toString("utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._valueAsString = value;
+			}
+			return value;
 		}
+		return this._valueAsString;
 	}
 
-	_ensureOriginalSourceBuffer() {
+	/**
+	 * @private
+	 * @returns {undefined | Buffer} buffer
+	 */
+	_originalSourceBuffer() {
 		if (this._originalSourceAsBuffer === undefined && this._hasOriginalSource) {
-			this._originalSourceAsBuffer = Buffer.from(
-				this._originalSourceAsString,
+			const value = Buffer.from(
+				/** @type {string} */
+				(this._originalSourceAsString),
 				"utf-8"
 			);
+			if (isDualStringBufferCachingEnabled()) {
+				this._originalSourceAsBuffer = value;
+			}
+			return value;
 		}
+		return this._originalSourceAsBuffer;
 	}
 
-	_ensureOriginalSourceString() {
+	_originalSourceString() {
 		if (this._originalSourceAsString === undefined && this._hasOriginalSource) {
-			this._originalSourceAsString = this._originalSourceAsBuffer.toString(
-				"utf-8"
-			);
+			const value =
+				/** @type {Buffer} */
+				(this._originalSourceAsBuffer).toString("utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._originalSourceAsString = value;
+			}
+			return value;
 		}
+		return this._originalSourceAsString;
 	}
 
-	_ensureInnerSourceMapObject() {
+	_innerSourceMapObject() {
 		if (this._innerSourceMapAsObject === undefined && this._hasInnerSourceMap) {
-			this._ensureInnerSourceMapString();
-			this._innerSourceMapAsObject = JSON.parse(this._innerSourceMapAsString);
+			const value = JSON.parse(this._innerSourceMapString());
+			if (isDualStringBufferCachingEnabled()) {
+				this._innerSourceMapAsObject = value;
+			}
+			return value;
 		}
+		return this._innerSourceMapAsObject;
 	}
 
-	_ensureInnerSourceMapBuffer() {
+	_innerSourceMapBuffer() {
 		if (this._innerSourceMapAsBuffer === undefined && this._hasInnerSourceMap) {
-			this._ensureInnerSourceMapString();
-			this._innerSourceMapAsBuffer = Buffer.from(
-				this._innerSourceMapAsString,
-				"utf-8"
-			);
+			const value = Buffer.from(this._innerSourceMapString(), "utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._innerSourceMapAsBuffer = value;
+			}
+			return value;
 		}
+		return this._innerSourceMapAsBuffer;
 	}
 
-	_ensureInnerSourceMapString() {
+	/**
+	 * @private
+	 * @returns {string} result
+	 */
+	_innerSourceMapString() {
 		if (this._innerSourceMapAsString === undefined && this._hasInnerSourceMap) {
 			if (this._innerSourceMapAsBuffer !== undefined) {
-				this._innerSourceMapAsString = this._innerSourceMapAsBuffer.toString(
-					"utf-8"
-				);
+				const value = this._innerSourceMapAsBuffer.toString("utf-8");
+				if (isDualStringBufferCachingEnabled()) {
+					this._innerSourceMapAsString = value;
+				}
+				return value;
 			} else {
-				this._innerSourceMapAsString = JSON.stringify(
-					this._innerSourceMapAsObject
-				);
+				const value = JSON.stringify(this._innerSourceMapAsObject);
+				if (isDualStringBufferCachingEnabled()) {
+					this._innerSourceMapAsString = value;
+				}
+				return value;
 			}
 		}
+		return /** @type {string} */ (this._innerSourceMapAsString);
 	}
 
-	_ensureSourceMapObject() {
+	_sourceMapObject() {
 		if (this._sourceMapAsObject === undefined) {
-			this._ensureSourceMapString();
-			this._sourceMapAsObject = JSON.parse(this._sourceMapAsString);
+			const value = JSON.parse(this._sourceMapString());
+			if (isDualStringBufferCachingEnabled()) {
+				this._sourceMapAsObject = value;
+			}
+			return value;
 		}
+		return this._sourceMapAsObject;
 	}
 
-	_ensureSourceMapBuffer() {
+	_sourceMapBuffer() {
 		if (this._sourceMapAsBuffer === undefined) {
-			this._ensureSourceMapString();
-			this._sourceMapAsBuffer = Buffer.from(this._sourceMapAsString, "utf-8");
+			const value = Buffer.from(this._sourceMapString(), "utf-8");
+			if (isDualStringBufferCachingEnabled()) {
+				this._sourceMapAsBuffer = value;
+			}
+			return value;
 		}
+		return this._sourceMapAsBuffer;
 	}
 
-	_ensureSourceMapString() {
+	_sourceMapString() {
 		if (this._sourceMapAsString === undefined) {
 			if (this._sourceMapAsBuffer !== undefined) {
-				this._sourceMapAsString = this._sourceMapAsBuffer.toString("utf-8");
+				const value = this._sourceMapAsBuffer.toString("utf-8");
+				if (isDualStringBufferCachingEnabled()) {
+					this._sourceMapAsString = value;
+				}
+				return value;
 			} else {
-				this._sourceMapAsString = JSON.stringify(this._sourceMapAsObject);
+				const value = JSON.stringify(this._sourceMapAsObject);
+				if (isDualStringBufferCachingEnabled()) {
+					this._sourceMapAsString = value;
+				}
+				return value;
 			}
 		}
+		return this._sourceMapAsString;
 	}
 
-	getArgsAsBuffers() {
-		this._ensureValueBuffer();
-		this._ensureSourceMapBuffer();
-		this._ensureOriginalSourceBuffer();
-		this._ensureInnerSourceMapBuffer();
-		return [
-			this._valueAsBuffer,
-			this._name,
-			this._sourceMapAsBuffer,
-			this._originalSourceAsBuffer,
-			this._innerSourceMapAsBuffer,
-			this._removeOriginalSource
-		];
-	}
-
-	buffer() {
-		this._ensureValueBuffer();
-		return this._valueAsBuffer;
-	}
-
-	source() {
-		this._ensureValueString();
-		return this._valueAsString;
-	}
-
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
 	map(options) {
 		if (!this._hasInnerSourceMap) {
-			this._ensureSourceMapObject();
-			return this._sourceMapAsObject;
+			return this._sourceMapObject();
 		}
 		return getMap(this, options);
 	}
 
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
 	sourceAndMap(options) {
 		if (!this._hasInnerSourceMap) {
-			this._ensureValueString();
-			this._ensureSourceMapObject();
 			return {
-				source: this._valueAsString,
-				map: this._sourceMapAsObject
+				source: this.source(),
+				map: this._sourceMapObject()
 			};
 		}
 		return getSourceAndMap(this, options);
 	}
 
+	/**
+	 * @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._ensureValueString();
-		this._ensureSourceMapObject();
-		this._ensureOriginalSourceString();
 		if (this._hasInnerSourceMap) {
-			this._ensureInnerSourceMapObject();
 			return streamChunksOfCombinedSourceMap(
-				this._valueAsString,
-				this._sourceMapAsObject,
+				/** @type {string} */
+				(this.source()),
+				this._sourceMapObject(),
 				this._name,
-				this._originalSourceAsString,
-				this._innerSourceMapAsObject,
+				/** @type {string} */
+				(this._originalSourceString()),
+				this._innerSourceMapObject(),
 				this._removeOriginalSource,
 				onChunk,
 				onSource,
@@ -1824,8 +2495,9 @@ class SourceMapSource extends Source {
 			);
 		} else {
 			return streamChunksOfSourceMap(
-				this._valueAsString,
-				this._sourceMapAsObject,
+				/** @type {string} */
+				(this.source()),
+				this._sourceMapObject(),
 				onChunk,
 				onSource,
 				onName,
@@ -1835,24 +2507,41 @@ class SourceMapSource extends Source {
 		}
 	}
 
+	/**
+	 * @param {Hash} hash hash
+	 * @returns {void}
+	 */
 	updateHash(hash) {
-		this._ensureValueBuffer();
-		this._ensureSourceMapBuffer();
-		this._ensureOriginalSourceBuffer();
-		this._ensureInnerSourceMapBuffer();
-
 		hash.update("SourceMapSource");
-
-		hash.update(this._valueAsBuffer);
-
-		hash.update(this._sourceMapAsBuffer);
+		hash.update(
+			this._valueAsBuffer
+				? this._valueAsBuffer
+				: typeof this._valueAsString === "string"
+				? this._valueAsString
+				: // Fallback when memory optimization enabled
+				  this.buffer()
+		);
+		hash.update(
+			this._sourceMapAsBuffer
+				? this._sourceMapAsBuffer
+				: typeof this._sourceMapAsString === "string"
+				? this._sourceMapAsString
+				: // Fallback when memory optimization enabled
+				  this._sourceMapBuffer()
+		);
 
 		if (this._hasOriginalSource) {
-			hash.update(this._originalSourceAsBuffer);
+			hash.update(
+				/** @type {Buffer} */
+				(this._originalSourceBuffer())
+			);
 		}
 
 		if (this._hasInnerSourceMap) {
-			hash.update(this._innerSourceMapAsBuffer);
+			hash.update(
+				/** @type {Buffer} */
+				(this._innerSourceMapBuffer())
+			);
 		}
 
 		hash.update(this._removeOriginalSource ? "true" : "false");
@@ -1864,10 +2553,9 @@ module.exports = SourceMapSource;
 
 /***/ }),
 
-/***/ 543:
+/***/ 965:
 /***/ ((module) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -1875,13 +2563,28 @@ module.exports = SourceMapSource;
 
 
 
-const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(
-	""
-);
+const ALPHABET =
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
 
 const CONTINUATION_BIT = 0x20;
 
-const createMappingsSerializer = options => {
+/**
+ * @callback MappingsSerializer
+ * @param {number} generatedLine generated line
+ * @param {number} generatedColumn generated column
+ * @param {number} sourceIndex source index
+ * @param {number} originalLine original line
+ * @param {number} originalColumn generated line
+ * @param {number} nameIndex generated line
+ * @returns {string} result
+ */
+
+// eslint-disable-next-line valid-jsdoc
+/**
+ * @param {{ columns?: boolean }=} options options
+ * @returns {MappingsSerializer} mappings serializer
+ */
+const createMappingsSerializer = (options) => {
 	const linesOnly = options && options.columns === false;
 	return linesOnly
 		? createLinesOnlyMappingsSerializer()
@@ -1898,6 +2601,8 @@ const createFullMappingsSerializer = () => {
 	let activeMapping = false;
 	let activeName = false;
 	let initial = true;
+	// eslint-disable-next-line valid-jsdoc
+	/** @type {MappingsSerializer} */
 	return (
 		generatedLine,
 		generatedColumn,
@@ -1926,6 +2631,7 @@ const createFullMappingsSerializer = () => {
 			}
 		}
 
+		/** @type {undefined | string} */
 		let str;
 		if (currentLine < generatedLine) {
 			str = ";".repeat(generatedLine - currentLine);
@@ -1939,7 +2645,11 @@ const createFullMappingsSerializer = () => {
 			str = ",";
 		}
 
-		const writeValue = value => {
+		/**
+		 * @param {number} value value
+		 * @returns {void}
+		 */
+		const writeValue = (value) => {
 			const sign = (value >>> 31) & 1;
 			const mask = value >> 31;
 			const absValue = (value + mask) ^ mask;
@@ -1992,6 +2702,8 @@ const createLinesOnlyMappingsSerializer = () => {
 	let currentLine = 1;
 	let currentSourceIndex = 0;
 	let currentOriginalLine = 1;
+	// eslint-disable-next-line valid-jsdoc
+	/** @type {MappingsSerializer} */
 	return (
 		generatedLine,
 		_generatedColumn,
@@ -2008,8 +2720,13 @@ const createLinesOnlyMappingsSerializer = () => {
 			// avoid writing multiple original mappings per line
 			return "";
 		}
+		/** @type {undefined | string} */
 		let str;
-		const writeValue = value => {
+		/**
+		 * @param {number} value value
+		 * @returns {void}
+		 */
+		const writeValue = (value) => {
 			const sign = (value >>> 31) & 1;
 			const mask = value >> 31;
 			const absValue = (value + mask) ^ mask;
@@ -2029,7 +2746,6 @@ const createLinesOnlyMappingsSerializer = () => {
 		if (generatedLine === currentLine + 1) {
 			currentLine = generatedLine;
 			if (sourceIndex === currentSourceIndex) {
-				currentSourceIndex = sourceIndex;
 				if (originalLine === currentOriginalLine + 1) {
 					currentOriginalLine = originalLine;
 					return ";AACA";
@@ -2051,7 +2767,6 @@ const createLinesOnlyMappingsSerializer = () => {
 			str = ";".repeat(generatedLine - currentLine);
 			currentLine = generatedLine;
 			if (sourceIndex === currentSourceIndex) {
-				currentSourceIndex = sourceIndex;
 				if (originalLine === currentOriginalLine + 1) {
 					currentOriginalLine = originalLine;
 					return str + "AACA";
@@ -2078,10 +2793,9 @@ module.exports = createMappingsSerializer;
 
 /***/ }),
 
-/***/ 56:
+/***/ 614:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2089,13 +2803,28 @@ module.exports = createMappingsSerializer;
 
 
 
-const createMappingsSerializer = __nccwpck_require__(543);
+const createMappingsSerializer = __nccwpck_require__(965);
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("../Source").SourceAndMap} SourceAndMap */
+/** @typedef {import("./streamChunks").Options} Options */
+/** @typedef {import("./streamChunks").StreamChunksFunction} StreamChunksFunction */
 
+/** @typedef {{ streamChunks: StreamChunksFunction }} SourceLikeWithStreamChunks */
+
+/**
+ * @param {SourceLikeWithStreamChunks} inputSource input source
+ * @param {Options=} options options
+ * @returns {SourceAndMap} map
+ */
 exports.getSourceAndMap = (inputSource, options) => {
 	let code = "";
 	let mappings = "";
+	/** @type {(string | null)[]} */
 	let sources = [];
+	/** @type {(string | null)[]} */
 	let sourcesContent = [];
+	/** @type {(string | null)[]} */
 	let names = [];
 	const addMapping = createMappingsSerializer(options);
 	const { source } = inputSource.streamChunks(
@@ -2146,19 +2875,30 @@ exports.getSourceAndMap = (inputSource, options) => {
 						version: 3,
 						file: "x",
 						mappings,
-						sources,
+						// We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
+						sources: /** @type {string[]} */ (sources),
 						sourcesContent:
-							sourcesContent.length > 0 ? sourcesContent : undefined,
-						names
+							sourcesContent.length > 0
+								? /** @type {string[]} */ (sourcesContent)
+								: undefined,
+						names: /** @type {string[]} */ (names)
 				  }
 				: null
 	};
 };
 
+/**
+ * @param {SourceLikeWithStreamChunks} source source
+ * @param {Options=} options options
+ * @returns {RawSourceMap | null} map
+ */
 exports.getMap = (source, options) => {
 	let mappings = "";
+	/** @type {(string | null)[]} */
 	let sources = [];
+	/** @type {(string | null)[]} */
 	let sourcesContent = [];
+	/** @type {(string | null)[]} */
 	let names = [];
 	const addMapping = createMappingsSerializer(options);
 	source.streamChunks(
@@ -2205,9 +2945,13 @@ exports.getMap = (source, options) => {
 				version: 3,
 				file: "x",
 				mappings,
-				sources,
-				sourcesContent: sourcesContent.length > 0 ? sourcesContent : undefined,
-				names
+				// We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
+				sources: /** @type {string[]} */ (sources),
+				sourcesContent:
+					sourcesContent.length > 0
+						? /** @type {string[]} */ (sourcesContent)
+						: undefined,
+				names: /** @type {string[]} */ (names)
 		  }
 		: null;
 };
@@ -2215,10 +2959,9 @@ exports.getMap = (source, options) => {
 
 /***/ }),
 
-/***/ 864:
+/***/ 278:
 /***/ ((module) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2228,7 +2971,18 @@ exports.getMap = (source, options) => {
 
 const CHAR_CODE_NEW_LINE = "\n".charCodeAt(0);
 
-const getGeneratedSourceInfo = source => {
+/**
+ * @typedef {object} GeneratedSourceInfo
+ * @property {number=} generatedLine
+ * @property {number=} generatedColumn
+ * @property {string=} source
+ */
+
+/**
+ * @param {string | undefined} source source
+ * @returns {GeneratedSourceInfo} source info
+ */
+const getGeneratedSourceInfo = (source) => {
 	if (source === undefined) {
 		return {};
 	}
@@ -2256,10 +3010,9 @@ module.exports = getGeneratedSourceInfo;
 
 /***/ }),
 
-/***/ 367:
+/***/ 265:
 /***/ ((module) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2267,6 +3020,13 @@ module.exports = getGeneratedSourceInfo;
 
 
 
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+
+/**
+ * @param {RawSourceMap} sourceMap source map
+ * @param {number} index index
+ * @returns {string | null} name
+ */
 const getSource = (sourceMap, index) => {
 	if (index < 0) return null;
 	const { sourceRoot, sources } = sourceMap;
@@ -2281,10 +3041,9 @@ module.exports = getSource;
 
 /***/ }),
 
-/***/ 479:
+/***/ 449:
 /***/ ((module) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2312,9 +3071,11 @@ const ccToValue = new Uint8Array("z".charCodeAt(0) + 1);
 }
 const ccMax = ccToValue.length - 1;
 
+/** @typedef {function(number, number, number, number, number, number): void} OnMapping */
+
 /**
  * @param {string} mappings the mappings string
- * @param {function(number, number, number, number, number, number): void} onMapping called for each mapping
+ * @param {OnMapping} onMapping called for each mapping
  * @returns {void}
  */
 const readMappings = (mappings, onMapping) => {
@@ -2405,10 +3166,21 @@ module.exports = readMappings;
 
 /***/ }),
 
-/***/ 877:
+/***/ 51:
 /***/ ((module) => {
 
-const splitIntoLines = str => {
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/**
+ * @param {string} str string
+ * @returns {string[]} array of string separated by lines
+ */
+const splitIntoLines = (str) => {
 	const results = [];
 	const len = str.length;
 	let i = 0;
@@ -2428,14 +3200,22 @@ const splitIntoLines = str => {
 	}
 	return results;
 };
+
 module.exports = splitIntoLines;
 
 
 /***/ }),
 
-/***/ 914:
+/***/ 904:
 /***/ ((module) => {
 
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
 // \n = 10
 // ; = 59
 // { = 123
@@ -2444,7 +3224,11 @@ module.exports = splitIntoLines;
 // \r = 13
 // \t = 9
 
-const splitIntoPotentialTokens = str => {
+/**
+ * @param {string} str string
+ * @returns {string[] | null} array of string separated by potential tokens
+ */
+const splitIntoPotentialTokens = (str) => {
 	const len = str.length;
 	if (len === 0) return null;
 	const results = [];
@@ -2476,15 +3260,15 @@ const splitIntoPotentialTokens = str => {
 	}
 	return results;
 };
+
 module.exports = splitIntoPotentialTokens;
 
 
 /***/ }),
 
-/***/ 391:
+/***/ 765:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2492,9 +3276,26 @@ module.exports = splitIntoPotentialTokens;
 
 
 
-const createMappingsSerializer = __nccwpck_require__(543);
-const streamChunks = __nccwpck_require__(266);
+const createMappingsSerializer = __nccwpck_require__(965);
+const streamChunks = __nccwpck_require__(372);
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./streamChunks").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} OnChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
+/** @typedef {import("./streamChunks").Options} Options */
+/** @typedef {import("./streamChunks").SourceMaybeWithStreamChunksFunction} SourceMaybeWithStreamChunksFunction */
 
+// eslint-disable-next-line valid-jsdoc
+/**
+ * @param {SourceMaybeWithStreamChunksFunction} inputSource input source
+ * @param {Options} options options
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {{ result: GeneratedSourceInfo, source: string, map: RawSourceMap | null }} result
+ */
 const streamAndGetSourceAndMap = (
 	inputSource,
 	options,
@@ -2504,8 +3305,11 @@ const streamAndGetSourceAndMap = (
 ) => {
 	let code = "";
 	let mappings = "";
+	/** @type {(string | null)[]} */
 	let sources = [];
+	/** @type {(string | null)[]} */
 	let sourcesContent = [];
+	/** @type {(string | null)[]} */
 	let names = [];
 	const addMapping = createMappingsSerializer(
 		Object.assign({}, options, { columns: true })
@@ -2564,6 +3368,7 @@ const streamAndGetSourceAndMap = (
 		}
 	);
 	const resultSource = source !== undefined ? source : code;
+
 	return {
 		result: {
 			generatedLine,
@@ -2577,10 +3382,13 @@ const streamAndGetSourceAndMap = (
 						version: 3,
 						file: "x",
 						mappings,
-						sources,
+						// We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
+						sources: /** @type {string[]} */ (sources),
 						sourcesContent:
-							sourcesContent.length > 0 ? sourcesContent : undefined,
-						names
+							sourcesContent.length > 0
+								? /** @type {string[]} */ (sourcesContent)
+								: undefined,
+						names: /** @type {string[]} */ (names)
 				  }
 				: null
 	};
@@ -2591,10 +3399,9 @@ module.exports = streamAndGetSourceAndMap;
 
 /***/ }),
 
-/***/ 266:
+/***/ 372:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2602,9 +3409,35 @@ module.exports = streamAndGetSourceAndMap;
 
 
 
-const streamChunksOfRawSource = __nccwpck_require__(348);
-const streamChunksOfSourceMap = __nccwpck_require__(958);
+const streamChunksOfRawSource = __nccwpck_require__(482);
+const streamChunksOfSourceMap = __nccwpck_require__(492);
+
+/** @typedef {import("../Source")} Source */
+/** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {(chunk: string | undefined, generatedLine: number, generatedColumn: number, sourceIndex: number, originalLine: number, originalColumn: number, nameIndex: number) => void} OnChunk */
+/** @typedef {(sourceIndex: number, source: string | null, sourceContent: string | undefined) => void} OnSource */
+/** @typedef {(nameIndex: number, name: string) => void} OnName */
 
+/** @typedef {{ source?: boolean, finalSource?: boolean, columns?: boolean }} Options */
+
+/**
+ * @callback StreamChunksFunction
+ * @param {Options} options options
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ */
+
+/** @typedef {Source & { streamChunks?: StreamChunksFunction }} SourceMaybeWithStreamChunksFunction */
+
+/**
+ * @param {SourceMaybeWithStreamChunksFunction} source source
+ * @param {Options} options options
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {GeneratedSourceInfo} generated source info
+ */
 module.exports = (source, options, onChunk, onSource, onName) => {
 	if (typeof source.streamChunks === "function") {
 		return source.streamChunks(options, onChunk, onSource, onName);
@@ -2612,7 +3445,8 @@ module.exports = (source, options, onChunk, onSource, onName) => {
 		const sourceAndMap = source.sourceAndMap(options);
 		if (sourceAndMap.map) {
 			return streamChunksOfSourceMap(
-				sourceAndMap.source,
+				/** @type {string} */
+				(sourceAndMap.source),
 				sourceAndMap.map,
 				onChunk,
 				onSource,
@@ -2622,7 +3456,8 @@ module.exports = (source, options, onChunk, onSource, onName) => {
 			);
 		} else {
 			return streamChunksOfRawSource(
-				sourceAndMap.source,
+				/** @type {string} */
+				(sourceAndMap.source),
 				onChunk,
 				onSource,
 				onName,
@@ -2635,10 +3470,9 @@ module.exports = (source, options, onChunk, onSource, onName) => {
 
 /***/ }),
 
-/***/ 503:
+/***/ 549:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2646,9 +3480,29 @@ module.exports = (source, options, onChunk, onSource, onName) => {
 
 
 
-const streamChunksOfSourceMap = __nccwpck_require__(958);
-const splitIntoLines = __nccwpck_require__(877);
+const splitIntoLines = __nccwpck_require__(51);
+const streamChunksOfSourceMap = __nccwpck_require__(492);
+
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} onChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
 
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {string} innerSourceName inner source name
+ * @param {string} innerSource inner source
+ * @param {RawSourceMap} innerSourceMap inner source map
+ * @param {boolean | undefined} removeInnerSource do remove inner source
+ * @param {onChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @param {boolean} finalSource finalSource
+ * @param {boolean} columns columns
+ * @returns {GeneratedSourceInfo} generated source info
+ */
 const streamChunksOfCombinedSourceMap = (
 	source,
 	sourceMap,
@@ -2662,19 +3516,37 @@ const streamChunksOfCombinedSourceMap = (
 	finalSource,
 	columns
 ) => {
+	/** @type {Map<string | null, number>} */
 	let sourceMapping = new Map();
+	/** @type {Map<string, number>} */
 	let nameMapping = new Map();
+	/** @type {number[]} */
 	const sourceIndexMapping = [];
+	/** @type {number[]} */
 	const nameIndexMapping = [];
+	/** @type {string[]} */
 	const nameIndexValueMapping = [];
 	let innerSourceIndex = -2;
+	/** @type {number[]} */
 	const innerSourceIndexMapping = [];
+	/** @type {[string | null, string | undefined][]} */
 	const innerSourceIndexValueMapping = [];
+	/** @type {(string | undefined)[]} */
 	const innerSourceContents = [];
+	/** @type {(null | undefined | string[])[]} */
 	const innerSourceContentLines = [];
+	/** @type {number[]} */
 	const innerNameIndexMapping = [];
+	/** @type {string[]} */
 	const innerNameIndexValueMapping = [];
+	/** @typedef {[number, number, number, number, number]} MappingsData */
+	/** @type {{ chunks: string[], mappingsData: MappingsData }[]} */
 	const innerSourceMapLineData = [];
+	/**
+	 * @param {number} line line
+	 * @param {number} column column
+	 * @returns {number} result
+	 */
 	const findInnerMapping = (line, column) => {
 		if (line > innerSourceMapLineData.length) return -1;
 		const { mappingsData } = innerSourceMapLineData[line - 1];
@@ -2708,9 +3580,8 @@ const streamChunksOfCombinedSourceMap = (
 				// Check if there is a mapping in the inner source
 				const idx = findInnerMapping(originalLine, originalColumn);
 				if (idx !== -1) {
-					const { chunks, mappingsData } = innerSourceMapLineData[
-						originalLine - 1
-					];
+					const { chunks, mappingsData } =
+						innerSourceMapLineData[originalLine - 1];
 					const mi = idx * 5;
 					const innerSourceIndex = mappingsData[mi + 1];
 					const innerOriginalLine = mappingsData[mi + 2];
@@ -2906,10 +3777,11 @@ const streamChunksOfCombinedSourceMap = (
 			if (source === innerSourceName) {
 				innerSourceIndex = i;
 				if (innerSource !== undefined) sourceContent = innerSource;
-				else innerSource = sourceContent;
+				else innerSource = /** @type {string} */ (sourceContent);
 				sourceIndexMapping[i] = -2;
 				streamChunksOfSourceMap(
-					sourceContent,
+					/** @type {string} */
+					(sourceContent),
 					innerSourceMap,
 					(
 						chunk,
@@ -2922,7 +3794,7 @@ const streamChunksOfCombinedSourceMap = (
 					) => {
 						while (innerSourceMapLineData.length < generatedLine) {
 							innerSourceMapLineData.push({
-								mappingsData: [],
+								mappingsData: /** @type {any} */ ([]),
 								chunks: []
 							});
 						}
@@ -2934,7 +3806,7 @@ const streamChunksOfCombinedSourceMap = (
 							originalColumn,
 							nameIndex
 						);
-						data.chunks.push(chunk);
+						data.chunks.push(/** @type {string} */ (chunk));
 					},
 					(i, source, sourceContent) => {
 						innerSourceContents[i] = sourceContent;
@@ -2972,10 +3844,9 @@ module.exports = streamChunksOfCombinedSourceMap;
 
 /***/ }),
 
-/***/ 348:
+/***/ 482:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -2983,28 +3854,49 @@ module.exports = streamChunksOfCombinedSourceMap;
 
 
 
-const getGeneratedSourceInfo = __nccwpck_require__(864);
-const splitIntoLines = __nccwpck_require__(877);
+const getGeneratedSourceInfo = __nccwpck_require__(278);
+const splitIntoLines = __nccwpck_require__(51);
+
+/** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} OnChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
 
+/**
+ * @param {string} source source
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {GeneratedSourceInfo} source info
+ */
 const streamChunksOfRawSource = (source, onChunk, onSource, onName) => {
 	let line = 1;
 	const matches = splitIntoLines(source);
+	/** @type {undefined | string} */
 	let match;
 	for (match of matches) {
 		onChunk(match, line, 0, -1, -1, -1, -1);
 		line++;
 	}
-	return matches.length === 0 || match.endsWith("\n")
+	return matches.length === 0 || /** @type {string} */ (match).endsWith("\n")
 		? {
 				generatedLine: matches.length + 1,
 				generatedColumn: 0
 		  }
 		: {
 				generatedLine: matches.length,
-				generatedColumn: match.length
+				generatedColumn: /** @type {string} */ (match).length
 		  };
 };
 
+/**
+ * @param {string} source source
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @param {boolean} finalSource is final source
+ * @returns {GeneratedSourceInfo} source info
+ */
 module.exports = (source, onChunk, onSource, onName, finalSource) => {
 	return finalSource
 		? getGeneratedSourceInfo(source)
@@ -3014,10 +3906,9 @@ module.exports = (source, onChunk, onSource, onName, finalSource) => {
 
 /***/ }),
 
-/***/ 958:
+/***/ 492:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -3025,11 +3916,25 @@ module.exports = (source, onChunk, onSource, onName, finalSource) => {
 
 
 
-const getGeneratedSourceInfo = __nccwpck_require__(864);
-const getSource = __nccwpck_require__(367);
-const readMappings = __nccwpck_require__(479);
-const splitIntoLines = __nccwpck_require__(877);
+const getGeneratedSourceInfo = __nccwpck_require__(278);
+const getSource = __nccwpck_require__(265);
+const readMappings = __nccwpck_require__(449);
+const splitIntoLines = __nccwpck_require__(51);
 
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} OnChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
+
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {GeneratedSourceInfo} generated source info
+ */
 const streamChunksOfSourceMapFull = (
 	source,
 	sourceMap,
@@ -3072,6 +3977,15 @@ const streamChunksOfSourceMapFull = (
 	let activeMappingOriginalColumn = -1;
 	let activeMappingNameIndex = -1;
 
+	/**
+	 * @param {number} generatedLine generated line
+	 * @param {number} generatedColumn generated column
+	 * @param {number} sourceIndex source index
+	 * @param {number} originalLine original line
+	 * @param {number} originalColumn original column
+	 * @param {number} nameIndex name index
+	 * @returns {void}
+	 */
 	const onMapping = (
 		generatedLine,
 		generatedColumn,
@@ -3176,6 +4090,14 @@ const streamChunksOfSourceMapFull = (
 	};
 };
 
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} _onName on name
+ * @returns {GeneratedSourceInfo} generated source info
+ */
 const streamChunksOfSourceMapLinesFull = (
 	source,
 	sourceMap,
@@ -3201,6 +4123,15 @@ const streamChunksOfSourceMapLinesFull = (
 
 	let currentGeneratedLine = 1;
 
+	/**
+	 * @param {number} generatedLine generated line
+	 * @param {number} _generatedColumn generated column
+	 * @param {number} sourceIndex source index
+	 * @param {number} originalLine original line
+	 * @param {number} originalColumn original column
+	 * @param {number} _nameIndex name index
+	 * @returns {void}
+	 */
 	const onMapping = (
 		generatedLine,
 		_generatedColumn,
@@ -3268,6 +4199,14 @@ const streamChunksOfSourceMapLinesFull = (
 	};
 };
 
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {GeneratedSourceInfo} generated source info
+ */
 const streamChunksOfSourceMapFinal = (
 	source,
 	sourceMap,
@@ -3295,6 +4234,15 @@ const streamChunksOfSourceMapFinal = (
 
 	let mappingActiveLine = 0;
 
+	/**
+	 * @param {number} generatedLine generated line
+	 * @param {number} generatedColumn generated column
+	 * @param {number} sourceIndex source index
+	 * @param {number} originalLine original line
+	 * @param {number} originalColumn original column
+	 * @param {number} nameIndex name index
+	 * @returns {void}
+	 */
 	const onMapping = (
 		generatedLine,
 		generatedColumn,
@@ -3304,8 +4252,9 @@ const streamChunksOfSourceMapFinal = (
 		nameIndex
 	) => {
 		if (
-			generatedLine >= finalLine &&
-			(generatedColumn >= finalColumn || generatedLine > finalLine)
+			generatedLine >= /** @type {number} */ (finalLine) &&
+			(generatedColumn >= /** @type {number} */ (finalColumn) ||
+				generatedLine > /** @type {number} */ (finalLine))
 		) {
 			return;
 		}
@@ -3329,6 +4278,14 @@ const streamChunksOfSourceMapFinal = (
 	return result;
 };
 
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} _onName on name
+ * @returns {GeneratedSourceInfo} generated source info
+ */
 const streamChunksOfSourceMapLinesFinal = (
 	source,
 	sourceMap,
@@ -3354,10 +4311,22 @@ const streamChunksOfSourceMapLinesFinal = (
 		);
 	}
 
-	const finalLine = generatedColumn === 0 ? generatedLine - 1 : generatedLine;
+	const finalLine =
+		generatedColumn === 0
+			? /** @type {number} */ (generatedLine) - 1
+			: /** @type {number} */ (generatedLine);
 
 	let currentGeneratedLine = 1;
 
+	/**
+	 * @param {number} generatedLine generated line
+	 * @param {number} _generatedColumn generated column
+	 * @param {number} sourceIndex source index
+	 * @param {number} originalLine original line
+	 * @param {number} originalColumn original column
+	 * @param {number} _nameIndex name index
+	 * @returns {void}
+	 */
 	const onMapping = (
 		generatedLine,
 		_generatedColumn,
@@ -3387,6 +4356,16 @@ const streamChunksOfSourceMapLinesFinal = (
 	return result;
 };
 
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @param {boolean} finalSource final source
+ * @param {boolean} columns columns
+ * @returns {GeneratedSourceInfo} generated source info
+ */
 module.exports = (
 	source,
 	sourceMap,
@@ -3434,39 +4413,260 @@ module.exports = (
 
 /***/ }),
 
-/***/ 452:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ 672:
+/***/ ((module) => {
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Mark Knichel @mknichel
+*/
+
+
+
+let dualStringBufferCaching = true;
+
+/**
+ * @returns {boolean} Whether the optimization to cache copies of both the
+ * string and buffer version of source content is enabled. This is enabled by
+ * default to improve performance but can consume more memory since values are
+ * stored twice.
+ */
+function isDualStringBufferCachingEnabled() {
+	return dualStringBufferCaching;
+}
+
+/**
+ * Enables an optimization to save both string and buffer in memory to avoid
+ * repeat conversions between the two formats when they are requested. This
+ * is enabled by default. This option can improve performance but can consume
+ * additional memory since values are stored twice.
+ *
+ * @returns {void}
+ */
+function enableDualStringBufferCaching() {
+	dualStringBufferCaching = true;
+}
+
+/**
+ * Disables the optimization to save both string and buffer in memory. This
+ * may increase performance but should reduce memory usage in the Webpack
+ * compiler.
+ *
+ * @returns {void}
+ */
+function disableDualStringBufferCaching() {
+	dualStringBufferCaching = false;
+}
+
+const interningStringMap = new Map();
+
+/**
+ * Saves the string in a map to ensure that only one copy of the string exists
+ * in memory at a given time. This is controlled by {@link enableStringInterning}
+ * and {@link disableStringInterning}. Callers are expect to manage the memory
+ * of the interned strings by calling {@link disableStringInterning} after the
+ * compiler no longer needs to save the interned memory.
+ *
+ * @param {string} str A string to be interned.
+ * @returns {string} The original string or a reference to an existing string of the same value if it has already been interned.
+ */
+function internString(str) {
+	if (
+		!isStringInterningEnabled() ||
+		!str ||
+		str.length < 128 ||
+		typeof str !== "string"
+	) {
+		return str;
+	}
+	let internedString = interningStringMap.get(str);
+	if (internedString === undefined) {
+		internedString = str;
+		interningStringMap.set(str, internedString);
+	}
+	return internedString;
+}
+
+let enableStringInterningRefCount = 0;
+
+/**
+ * @returns {boolean} value
+ */
+function isStringInterningEnabled() {
+	return enableStringInterningRefCount > 0;
+}
+
+/**
+ * Starts a memory optimization to avoid repeat copies of the same string in
+ * memory by caching a single reference to the string. This can reduce memory
+ * usage if the same string is repeated many times in the compiler, such as
+ * when Webpack layers are used with the same files.
+ *
+ * {@link exitStringInterningRange} should be called when string interning is
+ * no longer necessary to free up the memory used by the interned strings. If
+ * {@link enterStringInterningRange} has been called multiple times, then
+ * this method may not immediately free all the memory until
+ * {@link exitStringInterningRange} has been called to end all string
+ * interning ranges.
+ *
+ * @returns {void}
+ */
+function enterStringInterningRange() {
+	enableStringInterningRefCount++;
+}
+
+/**
+ * Stops the current string interning range. Once all string interning ranges
+ * have been exited, this method will free all the memory used by the interned
+ * strings. This method should be called once for each time that
+ * {@link enterStringInterningRange} was called.
+ *
+ * @returns {void}
+ */
+function exitStringInterningRange() {
+	if (--enableStringInterningRefCount <= 0) {
+		interningStringMap.clear();
+		enableStringInterningRefCount = 0;
+	}
+}
+
+module.exports = {
+	disableDualStringBufferCaching,
+	enableDualStringBufferCaching,
+	internString,
+	isDualStringBufferCachingEnabled,
+	enterStringInterningRange,
+	exitStringInterningRange
+};
+
+
+/***/ }),
+
+/***/ 570:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
-const defineExport = (name, fn) => {
-	let value;
-	Object.defineProperty(exports, name, {
-		get: () => {
-			if (fn !== undefined) {
-				value = fn();
-				fn = undefined;
-			}
-			return value;
-		},
-		configurable: true
-	});
+
+
+/** @typedef {import("./CachedSource").CachedData} CachedData */
+/** @typedef {import("./CompatSource").SourceLike} SourceLike */
+/** @typedef {import("./ConcatSource").Child} ConcatSourceChild */
+/** @typedef {import("./ReplaceSource").Replacement} Replacement */
+/** @typedef {import("./Source").Hash} Hash */
+/** @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} StreamChunksOptions */
+
+// eslint-disable-next-line valid-jsdoc
+/**
+ * @template T
+ * @param {() => T} fn memorized function
+ * @returns {() => T} new function
+ */
+const memoize = (fn) => {
+	let cache = false;
+	/** @type {T | undefined} */
+	let result;
+	return () => {
+		if (cache) {
+			return /** @type {T} */ (result);
+		}
+
+		result = fn();
+		cache = true;
+		// Allow to clean up memory for fn
+		// and all dependent resources
+		/** @type {(() => T) | undefined} */
+		(fn) = undefined;
+		return /** @type {T} */ (result);
+	};
 };
 
-defineExport("Source", () => __nccwpck_require__(171));
+// eslint-disable-next-line valid-jsdoc
+/**
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
+ */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	for (const name of Object.keys(descriptors)) {
+		const descriptor = descriptors[name];
+		if (descriptor.get) {
+			const fn = descriptor.get;
+			Object.defineProperty(obj, name, {
+				configurable: false,
+				enumerable: true,
+				get: memoize(fn)
+			});
+		} else if (typeof descriptor.value === "object") {
+			Object.defineProperty(obj, name, {
+				configurable: false,
+				enumerable: true,
+				writable: false,
+				value: mergeExports({}, descriptor.value)
+			});
+		} else {
+			throw new Error(
+				"Exposed values must be either a getter or an nested object"
+			);
+		}
+	}
+	return /** @type {A & B} */ (Object.freeze(obj));
+};
 
-defineExport("RawSource", () => __nccwpck_require__(327));
-defineExport("OriginalSource", () => __nccwpck_require__(472));
-defineExport("SourceMapSource", () => __nccwpck_require__(188));
-defineExport("CachedSource", () => __nccwpck_require__(453));
-defineExport("ConcatSource", () => __nccwpck_require__(987));
-defineExport("ReplaceSource", () => __nccwpck_require__(829));
-defineExport("PrefixSource", () => __nccwpck_require__(663));
-defineExport("SizeOnlySource", () => __nccwpck_require__(908));
-defineExport("CompatSource", () => __nccwpck_require__(273));
+module.exports = mergeExports(
+	{},
+	{
+		get Source() {
+			return __nccwpck_require__(225);
+		},
+		get RawSource() {
+			return __nccwpck_require__(745);
+		},
+		get OriginalSource() {
+			return __nccwpck_require__(734);
+		},
+		get SourceMapSource() {
+			return __nccwpck_require__(150);
+		},
+		get CachedSource() {
+			return __nccwpck_require__(627);
+		},
+		get ConcatSource() {
+			return __nccwpck_require__(49);
+		},
+		get ReplaceSource() {
+			return __nccwpck_require__(807);
+		},
+		get PrefixSource() {
+			return __nccwpck_require__(805);
+		},
+		get SizeOnlySource() {
+			return __nccwpck_require__(90);
+		},
+		get CompatSource() {
+			return __nccwpck_require__(583);
+		},
+		util: {
+			get stringBufferUtils() {
+				return __nccwpck_require__(672);
+			}
+		}
+	}
+);
 
 
 /***/ })
@@ -3513,7 +4713,7 @@ defineExport("CompatSource", () => __nccwpck_require__(273));
 /******/ 	// 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__(452);
+/******/ 	var __webpack_exports__ = __nccwpck_require__(570);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()