rollup 4.62.2 → 4.62.3

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.62.2
-	Fri, 19 Jun 2026 14:55:11 GMT - commit 8faa18777374582bb813d54ce3623f4acf1f9e0b
+	Rollup.js v4.62.3
+	Sun, 26 Jul 2026 14:58:21 GMT - commit a80a1974c584bfa8b694fb5d1a20f3fa75ebaf0a
 
 	https://github.com/rollup/rollup
 
@@ -42,7 +42,7 @@ function _mergeNamespaces(n, m) {
 
 const promises__namespace = /*#__PURE__*/_interopNamespaceDefault(promises);
 
-var version = "4.62.2";
+var version = "4.62.3";
 const package_ = {
 	version: version};
 
@@ -56,6 +56,170 @@ function ensureArray$1(items) {
     return [];
 }
 
+const doNothing = () => { };
+
+async function asyncFlatten(array) {
+    do {
+        array = (await Promise.all(array)).flat(Infinity);
+    } while (array.some((v) => v?.then));
+    return array;
+}
+
+const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+    const { onwarn, onLog } = config;
+    const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+    if (onLog) {
+        const minimalPriority = parseAst_js.logLevelPriority[logLevel];
+        return (level, log) => onLog(level, addLogToString(log), (level, handledLog) => {
+            if (level === parseAst_js.LOGLEVEL_ERROR) {
+                return parseAst_js.error(normalizeLog(handledLog));
+            }
+            if (parseAst_js.logLevelPriority[level] >= minimalPriority) {
+                defaultOnLog(level, normalizeLog(handledLog));
+            }
+        });
+    }
+    return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn
+    ? (level, log) => {
+        if (level === parseAst_js.LOGLEVEL_WARN) {
+            onwarn(addLogToString(log), warning => printLog(parseAst_js.LOGLEVEL_WARN, normalizeLog(warning)));
+        }
+        else {
+            printLog(level, log);
+        }
+    }
+    : printLog;
+const addLogToString = (log) => {
+    Object.defineProperty(log, 'toString', {
+        value: () => log.message,
+        writable: true
+    });
+    return log;
+};
+const normalizeLog = (log) => typeof log === 'string'
+    ? { message: log }
+    : typeof log === 'function'
+        ? normalizeLog(log())
+        : log;
+const defaultPrintLog = (level, { message }) => {
+    switch (level) {
+        case parseAst_js.LOGLEVEL_WARN: {
+            return console.warn(message);
+        }
+        case parseAst_js.LOGLEVEL_DEBUG: {
+            return console.debug(message);
+        }
+        default: {
+            return console.info(message);
+        }
+    }
+};
+function warnUnknownOptions(passedOptions, validOptions, optionType, log, ignoredKeys = /$./) {
+    const validOptionSet = new Set(validOptions);
+    const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
+    if (unknownOptions.length > 0) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
+    }
+}
+const treeshakePresets = {
+    recommended: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: false
+    },
+    safest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: true,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: true
+    },
+    smallest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
+        moduleSideEffects: () => false,
+        propertyReadSideEffects: false,
+        tryCatchDeoptimization: false,
+        unknownGlobalSideEffects: false
+    }
+};
+const jsxPresets = {
+    preserve: {
+        factory: null,
+        fragment: null,
+        importSource: null,
+        mode: 'preserve'
+    },
+    'preserve-react': {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'preserve'
+    },
+    react: {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'classic'
+    },
+    'react-jsx': {
+        factory: 'React.createElement',
+        importSource: 'react',
+        jsxImportSource: 'react/jsx-runtime',
+        mode: 'automatic'
+    }
+};
+const generatedCodePresets = {
+    es2015: {
+        arrowFunctions: true,
+        constBindings: true,
+        objectShorthand: true,
+        reservedNamesAsProps: true,
+        symbols: true
+    },
+    es5: {
+        arrowFunctions: false,
+        constBindings: false,
+        objectShorthand: false,
+        reservedNamesAsProps: true,
+        symbols: false
+    }
+};
+const objectifyOption = (value) => value && typeof value === 'object' ? value : {};
+const objectifyOptionWithPresets = (presets, optionName, urlSnippet, additionalValues) => (value) => {
+    if (typeof value === 'string') {
+        const preset = presets[value];
+        if (preset) {
+            return preset;
+        }
+        parseAst_js.error(parseAst_js.logInvalidOption(optionName, urlSnippet, `valid values are ${additionalValues}${parseAst_js.printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
+    }
+    return objectifyOption(value);
+};
+const getOptionWithPreset = (value, presets, optionName, urlSnippet, additionalValues) => {
+    const presetName = value?.preset;
+    if (presetName) {
+        const preset = presets[presetName];
+        if (preset) {
+            return { ...preset, ...value };
+        }
+        else {
+            parseAst_js.error(parseAst_js.logInvalidOption(`${optionName}.preset`, urlSnippet, `valid values are ${parseAst_js.printQuotedStringList(Object.keys(presets))}`, presetName));
+        }
+    }
+    return objectifyOptionWithPresets(presets, optionName, urlSnippet, additionalValues)(value);
+};
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+
 var BuildPhase;
 (function (BuildPhase) {
     BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
@@ -620,186 +784,22 @@ function getNamesFromAssets(consumedFiles) {
     return { names, originalFileNames };
 }
 
-const doNothing = () => { };
-
-async function asyncFlatten(array) {
-    do {
-        array = (await Promise.all(array)).flat(Infinity);
-    } while (array.some((v) => v?.then));
-    return array;
-}
-
-const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
-    const { onwarn, onLog } = config;
-    const defaultOnLog = getDefaultOnLog(printLog, onwarn);
-    if (onLog) {
-        const minimalPriority = parseAst_js.logLevelPriority[logLevel];
-        return (level, log) => onLog(level, addLogToString(log), (level, handledLog) => {
-            if (level === parseAst_js.LOGLEVEL_ERROR) {
-                return parseAst_js.error(normalizeLog(handledLog));
-            }
-            if (parseAst_js.logLevelPriority[level] >= minimalPriority) {
-                defaultOnLog(level, normalizeLog(handledLog));
-            }
-        });
-    }
-    return defaultOnLog;
-};
-const getDefaultOnLog = (printLog, onwarn) => onwarn
-    ? (level, log) => {
-        if (level === parseAst_js.LOGLEVEL_WARN) {
-            onwarn(addLogToString(log), warning => printLog(parseAst_js.LOGLEVEL_WARN, normalizeLog(warning)));
-        }
-        else {
-            printLog(level, log);
-        }
+function getLogHandler(level, code, logger, pluginName, logLevel) {
+    if (parseAst_js.logLevelPriority[level] < parseAst_js.logLevelPriority[logLevel]) {
+        return doNothing;
     }
-    : printLog;
-const addLogToString = (log) => {
-    Object.defineProperty(log, 'toString', {
-        value: () => log.message,
-        writable: true
-    });
-    return log;
-};
-const normalizeLog = (log) => typeof log === 'string'
-    ? { message: log }
-    : typeof log === 'function'
-        ? normalizeLog(log())
-        : log;
-const defaultPrintLog = (level, { message }) => {
-    switch (level) {
-        case parseAst_js.LOGLEVEL_WARN: {
-            return console.warn(message);
-        }
-        case parseAst_js.LOGLEVEL_DEBUG: {
-            return console.debug(message);
+    return (log, pos) => {
+        if (pos != null) {
+            logger(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInvalidLogPosition(pluginName));
         }
-        default: {
-            return console.info(message);
+        log = normalizeLog(log);
+        if (log.code && !log.pluginCode) {
+            log.pluginCode = log.code;
         }
-    }
-};
-function warnUnknownOptions(passedOptions, validOptions, optionType, log, ignoredKeys = /$./) {
-    const validOptionSet = new Set(validOptions);
-    const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
-    if (unknownOptions.length > 0) {
-        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
-    }
-}
-const treeshakePresets = {
-    recommended: {
-        annotations: true,
-        correctVarValueBeforeDeclaration: false,
-        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
-        moduleSideEffects: () => true,
-        propertyReadSideEffects: true,
-        tryCatchDeoptimization: true,
-        unknownGlobalSideEffects: false
-    },
-    safest: {
-        annotations: true,
-        correctVarValueBeforeDeclaration: true,
-        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
-        moduleSideEffects: () => true,
-        propertyReadSideEffects: true,
-        tryCatchDeoptimization: true,
-        unknownGlobalSideEffects: true
-    },
-    smallest: {
-        annotations: true,
-        correctVarValueBeforeDeclaration: false,
-        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
-        moduleSideEffects: () => false,
-        propertyReadSideEffects: false,
-        tryCatchDeoptimization: false,
-        unknownGlobalSideEffects: false
-    }
-};
-const jsxPresets = {
-    preserve: {
-        factory: null,
-        fragment: null,
-        importSource: null,
-        mode: 'preserve'
-    },
-    'preserve-react': {
-        factory: 'React.createElement',
-        fragment: 'React.Fragment',
-        importSource: 'react',
-        mode: 'preserve'
-    },
-    react: {
-        factory: 'React.createElement',
-        fragment: 'React.Fragment',
-        importSource: 'react',
-        mode: 'classic'
-    },
-    'react-jsx': {
-        factory: 'React.createElement',
-        importSource: 'react',
-        jsxImportSource: 'react/jsx-runtime',
-        mode: 'automatic'
-    }
-};
-const generatedCodePresets = {
-    es2015: {
-        arrowFunctions: true,
-        constBindings: true,
-        objectShorthand: true,
-        reservedNamesAsProps: true,
-        symbols: true
-    },
-    es5: {
-        arrowFunctions: false,
-        constBindings: false,
-        objectShorthand: false,
-        reservedNamesAsProps: true,
-        symbols: false
-    }
-};
-const objectifyOption = (value) => value && typeof value === 'object' ? value : {};
-const objectifyOptionWithPresets = (presets, optionName, urlSnippet, additionalValues) => (value) => {
-    if (typeof value === 'string') {
-        const preset = presets[value];
-        if (preset) {
-            return preset;
-        }
-        parseAst_js.error(parseAst_js.logInvalidOption(optionName, urlSnippet, `valid values are ${additionalValues}${parseAst_js.printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
-    }
-    return objectifyOption(value);
-};
-const getOptionWithPreset = (value, presets, optionName, urlSnippet, additionalValues) => {
-    const presetName = value?.preset;
-    if (presetName) {
-        const preset = presets[presetName];
-        if (preset) {
-            return { ...preset, ...value };
-        }
-        else {
-            parseAst_js.error(parseAst_js.logInvalidOption(`${optionName}.preset`, urlSnippet, `valid values are ${parseAst_js.printQuotedStringList(Object.keys(presets))}`, presetName));
-        }
-    }
-    return objectifyOptionWithPresets(presets, optionName, urlSnippet, additionalValues)(value);
-};
-const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
-
-function getLogHandler(level, code, logger, pluginName, logLevel) {
-    if (parseAst_js.logLevelPriority[level] < parseAst_js.logLevelPriority[logLevel]) {
-        return doNothing;
-    }
-    return (log, pos) => {
-        if (pos != null) {
-            logger(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInvalidLogPosition(pluginName));
-        }
-        log = normalizeLog(log);
-        if (log.code && !log.pluginCode) {
-            log.pluginCode = log.code;
-        }
-        log.code = code;
-        log.plugin = pluginName;
-        logger(level, log);
-    };
+        log.code = code;
+        log.plugin = pluginName;
+        logger(level, log);
+    };
 }
 
 const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
@@ -1881,7 +1881,15 @@ function requireParse () {
 	  }
 	};
 
-	const getStarExtglobSequenceOutput = pattern => {
+	const buildCharClassStar = chars => {
+	  const source = chars.length === 1
+	    ? utils.escapeRegex(chars[0])
+	    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
+
+	  return `${source}*`;
+	};
+
+	const getStarExtglobSequenceChars = pattern => {
 	  let index = 0;
 	  const chars = [];
 
@@ -1910,11 +1918,7 @@ function requireParse () {
 	    return;
 	  }
 
-	  const source = chars.length === 1
-	    ? utils.escapeRegex(chars[0])
-	    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
-
-	  return `${source}*`;
+	  return chars;
 	};
 
 	const repeatedExtglobRecursion = pattern => {
@@ -1953,17 +1957,43 @@ function requireParse () {
 	    }
 	  }
 
+	  // A repeated extglob is "risky" (prone to catastrophic backtracking) when a
+	  // branch is itself a `*(...)` sequence, since that nests an unbounded quantifier
+	  // inside the outer `+(...)`/`*(...)`. When *every* branch reduces to single
+	  // characters we can emit one flat, ReDoS-safe character class that preserves the
+	  // meaning of ALL branches (e.g. `+(*(a)|*(b))` -> `[ab]*`), rather than dropping
+	  // every branch but the first.
+	  const safeChars = [];
+	  let sawStarSequence = false;
+	  let combinable = true;
+
 	  for (const branch of branches) {
-	    const safeOutput = getStarExtglobSequenceOutput(branch);
-	    if (safeOutput) {
-	      return { risky: true, safeOutput };
+	    const chars = getStarExtglobSequenceChars(branch);
+	    if (chars) {
+	      sawStarSequence = true;
+	      safeChars.push(...chars);
+	      continue;
 	    }
 
+	    const literal = normalizeSimpleBranch(branch);
+	    if (literal && literal.length === 1) {
+	      safeChars.push(literal);
+	      continue;
+	    }
+
+	    combinable = false;
+
 	    if (repeatedExtglobRecursion(branch) > max) {
 	      return { risky: true };
 	    }
 	  }
 
+	  if (sawStarSequence) {
+	    return combinable
+	      ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) }
+	      : { risky: true };
+	  }
+
 	  return { risky: false };
 	};
 
@@ -3065,6 +3095,18 @@ function requirePicomatch$1 () {
 	 * const isMatch = picomatch('*.!(*a)');
 	 * console.log(isMatch('a.a')); //=> false
 	 * console.log(isMatch('a.b')); //=> true
+	 *
+	 * // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
+	 * const picomatch = require('picomatch/posix');
+	 * // the same API, defaulting to posix paths
+	 * const isMatch = picomatch('a/*');
+	 * console.log(isMatch('a\\b')); //=> false
+	 * console.log(isMatch('a/b')); //=> true
+	 *
+	 * // you can still configure the matcher function to accept windows paths
+	 * const isMatch = picomatch('a/*', { options: windows });
+	 * console.log(isMatch('a\\b')); //=> true
+	 * console.log(isMatch('a/b')); //=> true
 	 * ```
 	 * @name picomatch
 	 * @param {String|Array} `globs` One or more glob patterns.
@@ -3202,9 +3244,9 @@ function requirePicomatch$1 () {
 	 * @api public
 	 */
 
-	picomatch.matchBase = (input, glob, options) => {
+	picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
 	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-	  return regex.test(utils.basename(input));
+	  return regex.test(utils.basename(input, { windows: posix }));
 	};
 
 	/**
@@ -4330,214 +4372,160 @@ function encode(decoded) {
   return writer.flush();
 }
 
-class BitSet {
+//#region src/BitSet.ts
+var BitSet = class BitSet {
 	constructor(arg) {
 		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
 	}
-
 	add(n) {
 		this.bits[n >> 5] |= 1 << (n & 31);
 	}
-
 	has(n) {
-		return !!(this.bits[n >> 5] & (1 << (n & 31)));
+		return !!(this.bits[n >> 5] & 1 << (n & 31));
 	}
-}
-
-let Chunk$1 = class Chunk {
+};
+//#endregion
+//#region src/Chunk.ts
+var Chunk$1 = class Chunk {
 	constructor(start, end, content) {
 		this.start = start;
 		this.end = end;
 		this.original = content;
-
-		this.intro = '';
-		this.outro = '';
-
+		this.intro = "";
+		this.outro = "";
 		this.content = content;
 		this.storeName = false;
 		this.edited = false;
-
-		{
-			this.previous = null;
-			this.next = null;
-		}
+		this.previous = null;
+		this.next = null;
 	}
-
 	appendLeft(content) {
 		this.outro += content;
 	}
-
 	appendRight(content) {
 		this.intro = this.intro + content;
 	}
-
 	clone() {
 		const chunk = new Chunk(this.start, this.end, this.original);
-
 		chunk.intro = this.intro;
 		chunk.outro = this.outro;
 		chunk.content = this.content;
 		chunk.storeName = this.storeName;
 		chunk.edited = this.edited;
-
 		return chunk;
 	}
-
 	contains(index) {
 		return this.start < index && index < this.end;
 	}
-
 	eachNext(fn) {
-		let chunk = this;
+		fn(this);
+		let chunk = this.next;
 		while (chunk) {
 			fn(chunk);
 			chunk = chunk.next;
 		}
 	}
-
 	eachPrevious(fn) {
-		let chunk = this;
+		fn(this);
+		let chunk = this.previous;
 		while (chunk) {
 			fn(chunk);
 			chunk = chunk.previous;
 		}
 	}
-
 	edit(content, storeName, contentOnly) {
 		this.content = content;
 		if (!contentOnly) {
-			this.intro = '';
-			this.outro = '';
+			this.intro = "";
+			this.outro = "";
 		}
 		this.storeName = storeName;
-
 		this.edited = true;
-
 		return this;
 	}
-
 	prependLeft(content) {
 		this.outro = content + this.outro;
 	}
-
 	prependRight(content) {
 		this.intro = content + this.intro;
 	}
-
 	reset() {
-		this.intro = '';
-		this.outro = '';
+		this.intro = "";
+		this.outro = "";
 		if (this.edited) {
 			this.content = this.original;
 			this.storeName = false;
 			this.edited = false;
 		}
 	}
-
 	split(index) {
 		const sliceIndex = index - this.start;
-
 		const originalBefore = this.original.slice(0, sliceIndex);
 		const originalAfter = this.original.slice(sliceIndex);
-
 		this.original = originalBefore;
-
 		const newChunk = new Chunk(index, this.end, originalAfter);
 		newChunk.outro = this.outro;
-		this.outro = '';
-
+		this.outro = "";
 		this.end = index;
-
 		if (this.edited) {
-			// after split we should save the edit content record into the correct chunk
-			// to make sure sourcemap correct
-			// For example:
-			// '  test'.trim()
-			//     split   -> '  ' + 'test'
-			//   ✔️ edit    -> '' + 'test'
-			//   ✖️ edit    -> 'test' + ''
-			// TODO is this block necessary?...
-			newChunk.edit('', false);
-			this.content = '';
-		} else {
-			this.content = originalBefore;
-		}
-
+			newChunk.edit("", false);
+			this.content = "";
+		} else this.content = originalBefore;
 		newChunk.next = this.next;
 		if (newChunk.next) newChunk.next.previous = newChunk;
 		newChunk.previous = this;
 		this.next = newChunk;
-
 		return newChunk;
 	}
-
 	toString() {
 		return this.intro + this.content + this.outro;
 	}
-
 	trimEnd(rx) {
-		this.outro = this.outro.replace(rx, '');
+		this.outro = this.outro.replace(rx, "");
 		if (this.outro.length) return true;
-
-		const trimmed = this.content.replace(rx, '');
-
+		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
 			if (trimmed !== this.content) {
-				this.split(this.start + trimmed.length).edit('', undefined, true);
-				if (this.edited) {
-					// save the change, if it has been edited
-					this.edit(trimmed, this.storeName, true);
-				}
+				this.split(this.start + trimmed.length).edit("", void 0, true);
+				if (this.edited) this.edit(trimmed, this.storeName, true);
 			}
 			return true;
 		} else {
-			this.edit('', undefined, true);
-
-			this.intro = this.intro.replace(rx, '');
+			this.edit("", void 0, true);
+			this.intro = this.intro.replace(rx, "");
 			if (this.intro.length) return true;
 		}
 	}
-
 	trimStart(rx) {
-		this.intro = this.intro.replace(rx, '');
+		this.intro = this.intro.replace(rx, "");
 		if (this.intro.length) return true;
-
-		const trimmed = this.content.replace(rx, '');
-
+		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
 			if (trimmed !== this.content) {
 				const newChunk = this.split(this.end - trimmed.length);
-				if (this.edited) {
-					// save the change, if it has been edited
-					newChunk.edit(trimmed, this.storeName, true);
-				}
-				this.edit('', undefined, true);
+				if (this.edited) newChunk.edit(trimmed, this.storeName, true);
+				this.edit("", void 0, true);
 			}
 			return true;
 		} else {
-			this.edit('', undefined, true);
-
-			this.outro = this.outro.replace(rx, '');
+			this.edit("", void 0, true);
+			this.outro = this.outro.replace(rx, "");
 			if (this.outro.length) return true;
 		}
 	}
 };
-
+//#endregion
+//#region src/SourceMap.ts
 function getBtoa() {
-	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
-		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
-	} else if (typeof Buffer === 'function') {
-		return (str) => Buffer.from(str, 'utf-8').toString('base64');
-	} else {
-		return () => {
-			throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
-		};
-	}
+	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	const buffer = globalThis["Buffer"];
+	if (buffer) return (str) => buffer.from(str, "utf-8").toString("base64");
+	return () => {
+		throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+	};
 }
-
-const btoa = /*#__PURE__*/ getBtoa();
-
-class SourceMap {
+const btoa = /* #__PURE__ */ getBtoa();
+var SourceMap = class {
 	constructor(properties) {
 		this.version = 3;
 		this.file = properties.file;
@@ -4545,103 +4533,87 @@ class SourceMap {
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
 		this.mappings = encode(properties.mappings);
-		if (typeof properties.x_google_ignoreList !== 'undefined') {
-			this.x_google_ignoreList = properties.x_google_ignoreList;
-		}
-		if (typeof properties.debugId !== 'undefined') {
-			this.debugId = properties.debugId;
-		}
+		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
+		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
 	}
-
+	/**
+	* Returns the equivalent of `JSON.stringify(map)`
+	*/
 	toString() {
 		return JSON.stringify(this);
 	}
-
+	/**
+	* Returns a DataURI containing the sourcemap. Useful for doing this sort of thing:
+	* `generateMap(options?: SourceMapOptions): SourceMap;`
+	*/
 	toUrl() {
-		return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+		return `data:application/json;charset=utf-8;base64,${btoa(this.toString())}`;
 	}
-}
-
-function guessIndent(code) {
-	const lines = code.split('\n');
-
-	const tabbed = lines.filter((line) => /^\t+/.test(line));
-	const spaced = lines.filter((line) => /^ {2,}/.test(line));
-
-	if (tabbed.length === 0 && spaced.length === 0) {
-		return null;
-	}
-
-	// More lines tabbed than spaced? Assume tabs, and
-	// default to tabs in the case of a tie (or nothing
-	// to go on)
-	if (tabbed.length >= spaced.length) {
-		return '\t';
+};
+//#endregion
+//#region src/utils/getLocator.ts
+function getLocator(source) {
+	const originalLines = source.split("\n");
+	const lineOffsets = [];
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
 	}
-
-	// Otherwise, we need to guess the multiple
-	const min = spaced.reduce((previous, current) => {
-		const numSpaces = /^ +/.exec(current)[0].length;
-		return Math.min(numSpaces, previous);
-	}, Infinity);
-
-	return new Array(min + 1).join(' ');
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = i + j >> 1;
+			if (index < lineOffsets[m]) j = m;
+			else i = m + 1;
+		}
+		const line = i - 1;
+		return {
+			line,
+			column: index - lineOffsets[line]
+		};
+	};
 }
-
+//#endregion
+//#region src/utils/getRelativePath.ts
 function getRelativePath(from, to) {
 	const fromParts = from.split(/[/\\]/);
 	const toParts = to.split(/[/\\]/);
-
-	fromParts.pop(); // get dirname
-
+	fromParts.pop();
 	while (fromParts[0] === toParts[0]) {
 		fromParts.shift();
 		toParts.shift();
 	}
-
 	if (fromParts.length) {
 		let i = fromParts.length;
-		while (i--) fromParts[i] = '..';
+		while (i--) fromParts[i] = "..";
 	}
-
-	return fromParts.concat(toParts).join('/');
+	return fromParts.concat(toParts).join("/");
 }
-
+//#endregion
+//#region src/utils/guessIndent.ts
+function guessIndent(code) {
+	const lines = code.split("\n");
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+	if (tabbed.length === 0 && spaced.length === 0) return null;
+	if (tabbed.length >= spaced.length) return "	";
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+	return " ".repeat(min);
+}
+//#endregion
+//#region src/utils/isObject.ts
 const toString = Object.prototype.toString;
-
 function isObject(thing) {
-	return toString.call(thing) === '[object Object]';
-}
-
-function getLocator(source) {
-	const originalLines = source.split('\n');
-	const lineOffsets = [];
-
-	for (let i = 0, pos = 0; i < originalLines.length; i++) {
-		lineOffsets.push(pos);
-		pos += originalLines[i].length + 1;
-	}
-
-	return function locate(index) {
-		let i = 0;
-		let j = lineOffsets.length;
-		while (i < j) {
-			const m = (i + j) >> 1;
-			if (index < lineOffsets[m]) {
-				j = m;
-			} else {
-				i = m + 1;
-			}
-		}
-		const line = i - 1;
-		const column = index - lineOffsets[line];
-		return { line, column };
-	};
+	return toString.call(thing) === "[object Object]";
 }
-
+//#endregion
+//#region src/utils/Mappings.ts
 const wordRegex = /\w/;
-
-class Mappings {
+var Mappings = class {
 	constructor(hires) {
 		this.hires = hires;
 		this.generatedCodeLine = 0;
@@ -4650,52 +4622,47 @@ class Mappings {
 		this.rawSegments = this.raw[this.generatedCodeLine] = [];
 		this.pending = null;
 	}
-
 	addEdit(sourceIndex, content, loc, nameIndex) {
 		if (content.length) {
 			const contentLengthMinusOne = content.length - 1;
-			let contentLineEnd = content.indexOf('\n', 0);
+			let contentLineEnd = content.indexOf("\n", 0);
 			let previousContentLineEnd = -1;
-			// Loop through each line in the content and add a segment, but stop if the last line is empty,
-			// else code afterwards would fill one line too many
 			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
-				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
-				if (nameIndex >= 0) {
-					segment.push(nameIndex);
-				}
+				const segment = [
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				];
+				if (nameIndex >= 0) segment.push(nameIndex);
 				this.rawSegments.push(segment);
-
 				this.generatedCodeLine += 1;
 				this.raw[this.generatedCodeLine] = this.rawSegments = [];
 				this.generatedCodeColumn = 0;
-
 				previousContentLineEnd = contentLineEnd;
-				contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
-			}
-
-			const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
-			if (nameIndex >= 0) {
-				segment.push(nameIndex);
+				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
 			}
+			const segment = [
+				this.generatedCodeColumn,
+				sourceIndex,
+				loc.line,
+				loc.column
+			];
+			if (nameIndex >= 0) segment.push(nameIndex);
 			this.rawSegments.push(segment);
-
 			this.advance(content.slice(previousContentLineEnd + 1));
 		} else if (this.pending) {
 			this.rawSegments.push(this.pending);
 			this.advance(content);
 		}
-
 		this.pending = null;
 	}
-
 	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
 		let originalCharIndex = chunk.start;
 		let first = true;
-		// when iterating each char, check if it's in a word boundary
 		let charInHiresBoundary = false;
-
 		while (originalCharIndex < chunk.end) {
-			if (original[originalCharIndex] === '\n') {
+			if (original[originalCharIndex] === "\n") {
 				loc.line += 1;
 				loc.column = 0;
 				this.generatedCodeLine += 1;
@@ -4705,42 +4672,34 @@ class Mappings {
 				charInHiresBoundary = false;
 			} else {
 				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
-					const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
-
-					if (this.hires === 'boundary') {
-						// in hires "boundary", group segments per word boundary than per char
-						if (wordRegex.test(original[originalCharIndex])) {
-							// for first char in the boundary found, start the boundary by pushing a segment
-							if (!charInHiresBoundary) {
-								this.rawSegments.push(segment);
-								charInHiresBoundary = true;
-							}
-						} else {
-							// for non-word char, end the boundary by pushing a segment
+					const segment = [
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					];
+					if (this.hires === "boundary") if (wordRegex.test(original[originalCharIndex])) {
+						if (!charInHiresBoundary) {
 							this.rawSegments.push(segment);
-							charInHiresBoundary = false;
+							charInHiresBoundary = true;
 						}
 					} else {
 						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
 					}
+					else this.rawSegments.push(segment);
 				}
-
 				loc.column += 1;
 				this.generatedCodeColumn += 1;
 				first = false;
 			}
-
 			originalCharIndex += 1;
 		}
-
 		this.pending = null;
 	}
-
 	advance(str) {
 		if (!str) return;
-
-		const lines = str.split('\n');
-
+		const lines = str.split("\n");
 		if (lines.length > 1) {
 			for (let i = 0; i < lines.length - 1; i++) {
 				this.generatedCodeLine++;
@@ -4748,1029 +4707,872 @@ class Mappings {
 			}
 			this.generatedCodeColumn = 0;
 		}
-
 		this.generatedCodeColumn += lines[lines.length - 1].length;
 	}
-}
-
-const n = '\n';
-
+};
+//#endregion
+//#region src/MagicString.ts
+const n = "\n";
+const NEWLINE_CHAR = "\n".charCodeAt(0);
+const CR_CHAR = "\r".charCodeAt(0);
 const warned = {
 	insertLeft: false,
 	insertRight: false,
-	storeName: false,
+	storeName: false
 };
-
-class MagicString {
+var MagicString = class MagicString {
 	constructor(string, options = {}) {
 		const chunk = new Chunk$1(0, string.length, string);
-
 		Object.defineProperties(this, {
-			original: { writable: true, value: string },
-			outro: { writable: true, value: '' },
-			intro: { writable: true, value: '' },
-			firstChunk: { writable: true, value: chunk },
-			lastChunk: { writable: true, value: chunk },
-			lastSearchedChunk: { writable: true, value: chunk },
-			byStart: { writable: true, value: {} },
-			byEnd: { writable: true, value: {} },
-			filename: { writable: true, value: options.filename },
-			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
-			sourcemapLocations: { writable: true, value: new BitSet() },
-			storedNames: { writable: true, value: {} },
-			indentStr: { writable: true, value: undefined },
-			ignoreList: { writable: true, value: options.ignoreList },
-			offset: { writable: true, value: options.offset || 0 },
+			original: {
+				writable: true,
+				value: string
+			},
+			outro: {
+				writable: true,
+				value: ""
+			},
+			intro: {
+				writable: true,
+				value: ""
+			},
+			firstChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastSearchedChunk: {
+				writable: true,
+				value: chunk
+			},
+			byStart: {
+				writable: true,
+				value: {}
+			},
+			byEnd: {
+				writable: true,
+				value: {}
+			},
+			filename: {
+				writable: true,
+				value: options.filename
+			},
+			indentExclusionRanges: {
+				writable: true,
+				value: options.indentExclusionRanges
+			},
+			sourcemapLocations: {
+				writable: true,
+				value: new BitSet()
+			},
+			storedNames: {
+				writable: true,
+				value: {}
+			},
+			indentStr: {
+				writable: true,
+				value: void 0
+			},
+			ignoreList: {
+				writable: true,
+				value: options.ignoreList
+			},
+			offset: {
+				writable: true,
+				value: options.offset || 0
+			}
 		});
-
 		this.byStart[0] = chunk;
 		this.byEnd[string.length] = chunk;
 	}
-
+	/**
+	* Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false.
+	*/
 	addSourcemapLocation(char) {
 		this.sourcemapLocations.add(char);
 	}
-
+	/**
+	* Appends the specified content to the end of the string.
+	*/
 	append(content) {
-		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
-
+		if (typeof content !== "string") throw new TypeError("outro content must be a string");
 		this.outro += content;
 		return this;
 	}
-
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *ending* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependLeft(...)`.
+	*/
 	appendLeft(index, content) {
 		index = index + this.offset;
-
-		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
-
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
 		this._split(index);
-
 		const chunk = this.byEnd[index];
-
-		if (chunk) {
-			chunk.appendLeft(content);
-		} else {
-			this.intro += content;
-		}
+		if (chunk) chunk.appendLeft(content);
+		else this.intro += content;
 		return this;
 	}
-
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *starting* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependRight(...)`.
+	*/
 	appendRight(index, content) {
 		index = index + this.offset;
-
-		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
-
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
 		this._split(index);
-
 		const chunk = this.byStart[index];
-
-		if (chunk) {
-			chunk.appendRight(content);
-		} else {
-			this.outro += content;
-		}
+		if (chunk) chunk.appendRight(content);
+		else this.outro += content;
 		return this;
 	}
-
+	/**
+	* Does what you'd expect.
+	*/
 	clone() {
-		const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });
-
+		const cloned = new MagicString(this.original, {
+			filename: this.filename,
+			offset: this.offset
+		});
 		let originalChunk = this.firstChunk;
-		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
-
+		let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
 		while (originalChunk) {
 			cloned.byStart[clonedChunk.start] = clonedChunk;
 			cloned.byEnd[clonedChunk.end] = clonedChunk;
-
 			const nextOriginalChunk = originalChunk.next;
 			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
-
 			if (nextClonedChunk) {
 				clonedChunk.next = nextClonedChunk;
 				nextClonedChunk.previous = clonedChunk;
-
 				clonedChunk = nextClonedChunk;
 			}
-
 			originalChunk = nextOriginalChunk;
 		}
-
 		cloned.lastChunk = clonedChunk;
-
-		if (this.indentExclusionRanges) {
-			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
-		}
-
+		if (this.indentExclusionRanges) cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
 		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
-
 		cloned.intro = this.intro;
 		cloned.outro = this.outro;
-
 		return cloned;
 	}
-
+	/**
+	* Generates a sourcemap object with raw mappings in array form, rather than encoded as a string.
+	* Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead.
+	*/
 	generateDecodedMap(options) {
 		options = options || {};
-
 		const sourceIndex = 0;
 		const names = Object.keys(this.storedNames);
 		const mappings = new Mappings(options.hires);
-
 		const locate = getLocator(this.original);
-
-		if (this.intro) {
-			mappings.advance(this.intro);
-		}
-
+		if (this.intro) mappings.advance(this.intro);
 		this.firstChunk.eachNext((chunk) => {
 			const loc = locate(chunk.start);
-
 			if (chunk.intro.length) mappings.advance(chunk.intro);
-
-			if (chunk.edited) {
-				mappings.addEdit(
-					sourceIndex,
-					chunk.content,
-					loc,
-					chunk.storeName ? names.indexOf(chunk.original) : -1,
-				);
-			} else {
-				mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
-			}
-
+			if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+			else mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
 			if (chunk.outro.length) mappings.advance(chunk.outro);
 		});
-
-		if (this.outro) {
-			mappings.advance(this.outro);
-		}
-
+		if (this.outro) mappings.advance(this.outro);
 		return {
-			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
-			sources: [
-				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
-			],
-			sourcesContent: options.includeContent ? [this.original] : undefined,
+			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
+			sourcesContent: options.includeContent ? [this.original] : void 0,
 			names,
 			mappings: mappings.raw,
-			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
 		};
 	}
-
+	/**
+	* Generates a version 3 sourcemap.
+	*/
 	generateMap(options) {
 		return new SourceMap(this.generateDecodedMap(options));
 	}
-
+	/** @internal */
 	_ensureindentStr() {
-		if (this.indentStr === undefined) {
-			this.indentStr = guessIndent(this.original);
-		}
+		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
 	}
-
+	/** @internal */
 	_getRawIndentString() {
 		this._ensureindentStr();
 		return this.indentStr;
 	}
-
 	getIndentString() {
 		this._ensureindentStr();
-		return this.indentStr === null ? '\t' : this.indentStr;
+		return this.indentStr === null ? "	" : this.indentStr;
 	}
-
 	indent(indentStr, options) {
 		const pattern = /^[^\r\n]/gm;
-
 		if (isObject(indentStr)) {
 			options = indentStr;
-			indentStr = undefined;
+			indentStr = void 0;
 		}
-
-		if (indentStr === undefined) {
+		if (indentStr === void 0) {
 			this._ensureindentStr();
-			indentStr = this.indentStr || '\t';
+			indentStr = this.indentStr || "	";
 		}
-
-		if (indentStr === '') return this; // noop
-
+		if (indentStr === "") return this;
+		const resolvedIndentStr = indentStr;
 		options = options || {};
-
-		// Process exclusion ranges
 		const isExcluded = {};
-
-		if (options.exclude) {
-			const exclusions =
-				typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
-			exclusions.forEach((exclusion) => {
-				for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
-					isExcluded[i] = true;
-				}
-			});
-		}
-
+		if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
+			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
+		});
 		let shouldIndentNextCharacter = options.indentStart !== false;
 		const replacer = (match) => {
-			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			if (shouldIndentNextCharacter) return `${resolvedIndentStr}${match}`;
 			shouldIndentNextCharacter = true;
 			return match;
 		};
-
 		this.intro = this.intro.replace(pattern, replacer);
-
 		let charIndex = 0;
 		let chunk = this.firstChunk;
-
+		const indentAt = (index) => {
+			shouldIndentNextCharacter = false;
+			if (index === chunk.start) chunk.prependRight(resolvedIndentStr);
+			else {
+				this._splitChunk(chunk, index);
+				chunk = chunk.next;
+				chunk.prependRight(resolvedIndentStr);
+			}
+		};
 		while (chunk) {
 			const end = chunk.end;
-
 			if (chunk.edited) {
 				if (!isExcluded[charIndex]) {
 					chunk.content = chunk.content.replace(pattern, replacer);
-
-					if (chunk.content.length) {
-						shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+					if (chunk.content.length) shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
+				}
+			} else if (options.exclude) {
+				charIndex = chunk.start;
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original.charCodeAt(charIndex);
+						if (char === NEWLINE_CHAR) shouldIndentNextCharacter = true;
+						else if (char !== CR_CHAR && shouldIndentNextCharacter) indentAt(charIndex);
 					}
+					charIndex += 1;
 				}
 			} else {
 				charIndex = chunk.start;
-
 				while (charIndex < end) {
-					if (!isExcluded[charIndex]) {
-						const char = this.original[charIndex];
-
-						if (char === '\n') {
-							shouldIndentNextCharacter = true;
-						} else if (char !== '\r' && shouldIndentNextCharacter) {
-							shouldIndentNextCharacter = false;
-
-							if (charIndex === chunk.start) {
-								chunk.prependRight(indentStr);
-							} else {
-								this._splitChunk(chunk, charIndex);
-								chunk = chunk.next;
-								chunk.prependRight(indentStr);
-							}
-						}
+					if (!shouldIndentNextCharacter) {
+						const nextLine = this.original.indexOf(n, charIndex);
+						if (nextLine === -1 || nextLine >= end) break;
+						shouldIndentNextCharacter = true;
+						charIndex = nextLine + 1;
+						continue;
 					}
-
+					const char = this.original.charCodeAt(charIndex);
+					if (char === NEWLINE_CHAR || char === CR_CHAR) {
+						charIndex += 1;
+						continue;
+					}
+					indentAt(charIndex);
 					charIndex += 1;
 				}
 			}
-
 			charIndex = chunk.end;
 			chunk = chunk.next;
 		}
-
 		this.outro = this.outro.replace(pattern, replacer);
-
 		return this;
 	}
-
+	/** @internal */
 	insert() {
-		throw new Error(
-			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
-		);
+		throw new Error("magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)");
 	}
-
+	/** @internal */
 	insertLeft(index, content) {
 		if (!warned.insertLeft) {
-			console.warn(
-				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
-			);
+			console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
 			warned.insertLeft = true;
 		}
-
 		return this.appendLeft(index, content);
 	}
-
+	/** @internal */
 	insertRight(index, content) {
 		if (!warned.insertRight) {
-			console.warn(
-				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
-			);
+			console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
 			warned.insertRight = true;
 		}
-
 		return this.prependRight(index, content);
 	}
-
+	/**
+	* Moves the characters from `start` and `end` to `index`.
+	*/
 	move(start, end, index) {
 		start = start + this.offset;
 		end = end + this.offset;
 		index = index + this.offset;
-
-		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
-
+		if (start === end) return this;
+		if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
 		this._split(start);
 		this._split(end);
 		this._split(index);
-
 		const first = this.byStart[start];
 		const last = this.byEnd[end];
-
 		const oldLeft = first.previous;
 		const oldRight = last.next;
-
 		const newRight = this.byStart[index];
 		if (!newRight && last === this.lastChunk) return this;
 		const newLeft = newRight ? newRight.previous : this.lastChunk;
-
 		if (oldLeft) oldLeft.next = oldRight;
 		if (oldRight) oldRight.previous = oldLeft;
-
 		if (newLeft) newLeft.next = first;
 		if (newRight) newRight.previous = last;
-
 		if (!first.previous) this.firstChunk = last.next;
 		if (!last.next) {
 			this.lastChunk = first.previous;
 			this.lastChunk.next = null;
 		}
-
 		first.previous = newLeft;
 		last.next = newRight || null;
-
 		if (!newLeft) this.firstChunk = first;
 		if (!newRight) this.lastChunk = last;
 		return this;
 	}
-
+	/**
+	* Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in
+	* that range. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and a contentOnly property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*
+	* It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content.
+	*/
 	overwrite(start, end, content, options) {
-		options = options || {};
-		return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+		const optionObject = typeof options === "object" && options ? options : {};
+		return this.update(start, end, content, {
+			...optionObject,
+			overwrite: !optionObject.contentOnly
+		});
 	}
-
+	/**
+	* Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and an overwrite property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*/
 	update(start, end, content, options) {
 		start = start + this.offset;
 		end = end + this.offset;
-
-		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
-
+		if (typeof content !== "string") throw new TypeError("replacement content must be a string");
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
 		}
-
-		if (end > this.original.length) throw new Error('end is out of bounds');
-		if (start === end)
-			throw new Error(
-				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
-			);
-
+		if (end > this.original.length) throw new Error("end is out of bounds");
+		if (start === end) throw new Error("Cannot overwrite a zero-length range – use appendLeft or prependRight instead");
 		this._split(start);
 		this._split(end);
-
 		if (options === true) {
 			if (!warned.storeName) {
-				console.warn(
-					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
-				);
+				console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
 				warned.storeName = true;
 			}
-
 			options = { storeName: true };
 		}
-		const storeName = options !== undefined ? options.storeName : false;
-		const overwrite = options !== undefined ? options.overwrite : false;
-
+		const optionObject = typeof options === "object" && options ? options : {};
+		const storeName = optionObject.storeName || false;
+		const overwrite = optionObject.overwrite || false;
 		if (storeName) {
 			const original = this.original.slice(start, end);
 			Object.defineProperty(this.storedNames, original, {
 				writable: true,
 				value: true,
-				enumerable: true,
+				enumerable: true
 			});
 		}
-
 		const first = this.byStart[start];
 		const last = this.byEnd[end];
-
 		if (first) {
 			let chunk = first;
 			while (chunk !== last) {
-				if (chunk.next !== this.byStart[chunk.end]) {
-					throw new Error('Cannot overwrite across a split point');
-				}
+				if (chunk.next !== this.byStart[chunk.end]) throw new Error("Cannot overwrite across a split point");
 				chunk = chunk.next;
-				chunk.edit('', false);
+				chunk.edit("", false);
 			}
-
 			first.edit(content, storeName, !overwrite);
 		} else {
-			// must be inserting at the end
-			const newChunk = new Chunk$1(start, end, '').edit(content, storeName);
-
-			// TODO last chunk in the array may not be the last chunk, if it's moved...
+			const newChunk = new Chunk$1(start, end, "").edit(content, storeName);
 			last.next = newChunk;
 			newChunk.previous = last;
 		}
 		return this;
 	}
-
+	/**
+	* Prepends the string with the specified content.
+	*/
 	prepend(content) {
-		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
-
+		if (typeof content !== "string") throw new TypeError("outro content must be a string");
 		this.intro = content + this.intro;
 		return this;
 	}
-
+	/**
+	* Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index
+	*/
 	prependLeft(index, content) {
 		index = index + this.offset;
-
-		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
-
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
 		this._split(index);
-
 		const chunk = this.byEnd[index];
-
-		if (chunk) {
-			chunk.prependLeft(content);
-		} else {
-			this.intro = content + this.intro;
-		}
+		if (chunk) chunk.prependLeft(content);
+		else this.intro = content + this.intro;
 		return this;
 	}
-
+	/**
+	* Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index`
+	*/
 	prependRight(index, content) {
 		index = index + this.offset;
-
-		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
-
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
 		this._split(index);
-
 		const chunk = this.byStart[index];
-
-		if (chunk) {
-			chunk.prependRight(content);
-		} else {
-			this.outro = content + this.outro;
-		}
+		if (chunk) chunk.prependRight(content);
+		else this.outro = content + this.outro;
 		return this;
 	}
-
+	/**
+	* Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+	* Removing the same content twice, or making removals that partially overlap, will cause an error.
+	*/
 	remove(start, end) {
 		start = start + this.offset;
 		end = end + this.offset;
-
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
 		}
-
 		if (start === end) return this;
-
-		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
-		if (start > end) throw new Error('end must be greater than start');
-
+		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+		if (start > end) throw new Error("end must be greater than start");
 		this._split(start);
 		this._split(end);
-
 		let chunk = this.byStart[start];
-
 		while (chunk) {
-			chunk.intro = '';
-			chunk.outro = '';
-			chunk.edit('');
-
+			chunk.intro = "";
+			chunk.outro = "";
+			chunk.edit("");
 			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
 		}
 		return this;
 	}
-
+	/**
+	* Reset the modified characters from `start` to `end` (of the original string, **not** the generated string).
+	*/
 	reset(start, end) {
 		start = start + this.offset;
 		end = end + this.offset;
-
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
 		}
-
 		if (start === end) return this;
-
-		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
-		if (start > end) throw new Error('end must be greater than start');
-
+		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+		if (start > end) throw new Error("end must be greater than start");
 		this._split(start);
 		this._split(end);
-
 		let chunk = this.byStart[start];
-
 		while (chunk) {
 			chunk.reset();
-
 			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
 		}
 		return this;
 	}
-
 	lastChar() {
 		if (this.outro.length) return this.outro[this.outro.length - 1];
 		let chunk = this.lastChunk;
-		do {
+		while (chunk) {
 			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
 			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
 			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
-		} while ((chunk = chunk.previous));
+			chunk = chunk.previous;
+		}
 		if (this.intro.length) return this.intro[this.intro.length - 1];
-		return '';
+		return "";
 	}
-
 	lastLine() {
 		let lineIndex = this.outro.lastIndexOf(n);
 		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
 		let lineStr = this.outro;
 		let chunk = this.lastChunk;
-		do {
+		while (chunk) {
 			if (chunk.outro.length > 0) {
 				lineIndex = chunk.outro.lastIndexOf(n);
 				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
 				lineStr = chunk.outro + lineStr;
 			}
-
 			if (chunk.content.length > 0) {
 				lineIndex = chunk.content.lastIndexOf(n);
 				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
 				lineStr = chunk.content + lineStr;
 			}
-
 			if (chunk.intro.length > 0) {
 				lineIndex = chunk.intro.lastIndexOf(n);
 				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
 				lineStr = chunk.intro + lineStr;
 			}
-		} while ((chunk = chunk.previous));
+			chunk = chunk.previous;
+		}
 		lineIndex = this.intro.lastIndexOf(n);
 		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
 		return this.intro + lineStr;
 	}
-
+	/**
+	* Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string.
+	* Throws error if the indices are for characters that were already removed.
+	*/
 	slice(start = 0, end = this.original.length - this.offset) {
 		start = start + this.offset;
 		end = end + this.offset;
-
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
 		}
-
-		let result = '';
-
-		// find start chunk
+		let result = "";
 		let chunk = this.firstChunk;
 		while (chunk && (chunk.start > start || chunk.end <= start)) {
-			// found end chunk before start
-			if (chunk.start < end && chunk.end >= end) {
-				return result;
-			}
-
+			if (chunk.start < end && chunk.end >= end) return result;
 			chunk = chunk.next;
 		}
-
-		if (chunk && chunk.edited && chunk.start !== start)
-			throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
-
+		if (chunk && chunk.edited && chunk.start !== start) throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
 		const startChunk = chunk;
 		while (chunk) {
-			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
-				result += chunk.intro;
-			}
-
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
 			const containsEnd = chunk.start < end && chunk.end >= end;
-			if (containsEnd && chunk.edited && chunk.end !== end)
-				throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
-
+			if (containsEnd && chunk.edited && chunk.end !== end) throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
 			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
 			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
-
 			result += chunk.content.slice(sliceStart, sliceEnd);
-
-			if (chunk.outro && (!containsEnd || chunk.end === end)) {
-				result += chunk.outro;
-			}
-
-			if (containsEnd) {
-				break;
-			}
-
+			if (chunk.outro && (!containsEnd || chunk.end === end)) result += chunk.outro;
+			if (containsEnd) break;
 			chunk = chunk.next;
 		}
-
 		return result;
 	}
-
-	// TODO deprecate this? not really very useful
+	/**
+	* Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed.
+	*/
 	snip(start, end) {
 		const clone = this.clone();
 		clone.remove(0, start);
 		clone.remove(end, clone.original.length);
-
 		return clone;
 	}
-
+	/** @internal */
 	_split(index) {
 		if (this.byStart[index] || this.byEnd[index]) return;
-
 		let chunk = this.lastSearchedChunk;
 		let previousChunk = chunk;
 		const searchForward = index > chunk.end;
-
 		while (chunk) {
 			if (chunk.contains(index)) return this._splitChunk(chunk, index);
-
 			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
-
-			// Prevent infinite loop (e.g. via empty chunks, where start === end)
 			if (chunk === previousChunk) return;
-
 			previousChunk = chunk;
 		}
 	}
-
+	/** @internal */
 	_splitChunk(chunk, index) {
 		if (chunk.edited && chunk.content.length) {
-			// zero-length edited chunks are a special case (overlapping replacements)
 			const loc = getLocator(this.original)(index);
-			throw new Error(
-				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
-			);
+			throw new Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
 		}
-
 		const newChunk = chunk.split(index);
-
 		this.byEnd[index] = chunk;
 		this.byStart[index] = newChunk;
 		this.byEnd[newChunk.end] = newChunk;
-
 		if (chunk === this.lastChunk) this.lastChunk = newChunk;
-
 		this.lastSearchedChunk = chunk;
 		return true;
 	}
-
+	/**
+	* Returns the generated string.
+	*/
 	toString() {
 		let str = this.intro;
-
 		let chunk = this.firstChunk;
 		while (chunk) {
 			str += chunk.toString();
 			chunk = chunk.next;
 		}
-
 		return str + this.outro;
 	}
-
+	/**
+	* Returns true if the resulting source is empty (disregarding white space).
+	*/
 	isEmpty() {
 		let chunk = this.firstChunk;
-		do {
-			if (
-				(chunk.intro.length && chunk.intro.trim()) ||
-				(chunk.content.length && chunk.content.trim()) ||
-				(chunk.outro.length && chunk.outro.trim())
-			)
-				return false;
-		} while ((chunk = chunk.next));
+		while (chunk) {
+			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
+			chunk = chunk.next;
+		}
 		return true;
 	}
-
 	length() {
 		let chunk = this.firstChunk;
 		let length = 0;
-		do {
+		while (chunk) {
 			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
-		} while ((chunk = chunk.next));
+			chunk = chunk.next;
+		}
 		return length;
 	}
-
+	/**
+	* Removes empty lines from the start and end.
+	*/
 	trimLines() {
-		return this.trim('[\\r\\n]');
+		return this.trim("[\\r\\n]");
 	}
-
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end.
+	*/
 	trim(charType) {
 		return this.trimStart(charType).trimEnd(charType);
 	}
-
+	/** @internal */
 	trimEndAborted(charType) {
-		const rx = new RegExp((charType || '\\s') + '+$');
-
-		this.outro = this.outro.replace(rx, '');
+		const rx = new RegExp(`${charType || "\\s"}+$`);
+		this.outro = this.outro.replace(rx, "");
 		if (this.outro.length) return true;
-
 		let chunk = this.lastChunk;
-
 		do {
 			const end = chunk.end;
 			const aborted = chunk.trimEnd(rx);
-
-			// if chunk was trimmed, we have a new lastChunk
 			if (chunk.end !== end) {
-				if (this.lastChunk === chunk) {
-					this.lastChunk = chunk.next;
-				}
-
+				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
 				this.byEnd[chunk.end] = chunk;
 				this.byStart[chunk.next.start] = chunk.next;
 				this.byEnd[chunk.next.end] = chunk.next;
 			}
-
 			if (aborted) return true;
 			chunk = chunk.previous;
 		} while (chunk);
-
 		return false;
 	}
-
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
+	*/
 	trimEnd(charType) {
 		this.trimEndAborted(charType);
 		return this;
 	}
+	/** @internal */
 	trimStartAborted(charType) {
-		const rx = new RegExp('^' + (charType || '\\s') + '+');
-
-		this.intro = this.intro.replace(rx, '');
+		const rx = new RegExp(`^${charType || "\\s"}+`);
+		this.intro = this.intro.replace(rx, "");
 		if (this.intro.length) return true;
-
 		let chunk = this.firstChunk;
-
 		do {
 			const end = chunk.end;
 			const aborted = chunk.trimStart(rx);
-
 			if (chunk.end !== end) {
-				// special case...
 				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
-
 				this.byEnd[chunk.end] = chunk;
 				this.byStart[chunk.next.start] = chunk.next;
 				this.byEnd[chunk.next.end] = chunk.next;
 			}
-
 			if (aborted) return true;
 			chunk = chunk.next;
 		} while (chunk);
-
 		return false;
 	}
-
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
+	*/
 	trimStart(charType) {
 		this.trimStartAborted(charType);
 		return this;
 	}
-
+	/**
+	* Indicates if the string has been changed.
+	*/
 	hasChanged() {
 		return this.original !== this.toString();
 	}
-
+	/** @internal */
 	_replaceRegexp(searchValue, replacement) {
 		function getReplacement(match, str) {
-			if (typeof replacement === 'string') {
-				return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
-					// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
-					if (i === '$') return '$';
-					if (i === '&') return match[0];
-					const num = +i;
-					if (num < match.length) return match[+i];
-					return `$${i}`;
-				});
-			} else {
-				return replacement(...match, match.index, str, match.groups);
-			}
+			if (typeof replacement === "string") return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+				if (i === "$") return "$";
+				if (i === "&") return match[0];
+				if (+i < match.length) return match[+i];
+				return `$${i}`;
+			});
+			else return replacement(match[0], ...match.slice(1), match.index, str, match.groups);
 		}
 		function matchAll(re, str) {
-			let match;
 			const matches = [];
-			while ((match = re.exec(str))) {
+			while (true) {
+				const match = re.exec(str);
+				if (!match) break;
 				matches.push(match);
 			}
 			return matches;
 		}
-		if (searchValue.global) {
-			const matches = matchAll(searchValue, this.original);
-			matches.forEach((match) => {
-				if (match.index != null) {
-					const replacement = getReplacement(match, this.original);
-					if (replacement !== match[0]) {
-						this.overwrite(match.index, match.index + match[0].length, replacement);
-					}
-				}
-			});
-		} else {
+		if (searchValue.global) matchAll(searchValue, this.original).forEach((match) => {
+			if (match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
+			}
+		});
+		else {
 			const match = this.original.match(searchValue);
 			if (match && match.index != null) {
 				const replacement = getReplacement(match, this.original);
-				if (replacement !== match[0]) {
-					this.overwrite(match.index, match.index + match[0].length, replacement);
-				}
+				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
 			}
 		}
 		return this;
 	}
-
+	/** @internal */
 	_replaceString(string, replacement) {
 		const { original } = this;
 		const index = original.indexOf(string);
-
 		if (index !== -1) {
-			if (typeof replacement === 'function') {
-				replacement = replacement(string, index, original);
-			}
-			if (string !== replacement) {
-				this.overwrite(index, index + string.length, replacement);
-			}
+			if (typeof replacement === "function") replacement = replacement(string, index, original);
+			if (string !== replacement) this.overwrite(index, index + string.length, replacement);
 		}
-
 		return this;
 	}
-
+	/**
+	* String replacement with RegExp or string.
+	*/
 	replace(searchValue, replacement) {
-		if (typeof searchValue === 'string') {
-			return this._replaceString(searchValue, replacement);
-		}
-
+		if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
 		return this._replaceRegexp(searchValue, replacement);
 	}
-
+	/** @internal */
 	_replaceAllString(string, replacement) {
 		const { original } = this;
 		const stringLength = string.length;
-		for (
-			let index = original.indexOf(string);
-			index !== -1;
-			index = original.indexOf(string, index + stringLength)
-		) {
+		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
 			const previous = original.slice(index, index + stringLength);
-			let _replacement = replacement;
-			if (typeof replacement === 'function') {
-				_replacement = replacement(previous, index, original);
-			}
+			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : replacement;
 			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
 		}
-
 		return this;
 	}
-
+	/**
+	* Same as `s.replace`, but replace all matched strings instead of just one.
+	*/
 	replaceAll(searchValue, replacement) {
-		if (typeof searchValue === 'string') {
-			return this._replaceAllString(searchValue, replacement);
-		}
-
-		if (!searchValue.global) {
-			throw new TypeError(
-				'MagicString.prototype.replaceAll called with a non-global RegExp argument',
-			);
-		}
-
+		if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
+		if (!searchValue.global) throw new TypeError("MagicString.prototype.replaceAll called with a non-global RegExp argument");
 		return this._replaceRegexp(searchValue, replacement);
 	}
-}
-
+};
+//#endregion
+//#region src/Bundle.ts
 const hasOwnProp = Object.prototype.hasOwnProperty;
-
-let Bundle$1 = class Bundle {
+var Bundle$1 = class Bundle {
 	constructor(options = {}) {
-		this.intro = options.intro || '';
-		this.separator = options.separator !== undefined ? options.separator : '\n';
+		this.intro = options.intro || "";
+		this.separator = options.separator !== void 0 ? options.separator : "\n";
 		this.sources = [];
 		this.uniqueSources = [];
 		this.uniqueSourceIndexByFilename = {};
 	}
-
+	/**
+	* Adds the specified source to the bundle, which can either be a `MagicString` object directly,
+	* or an options object that holds a magic string `content` property and optionally provides
+	* a `filename` for the source within the bundle, as well as an optional `ignoreList` hint
+	* (which defaults to `false`). The `filename` is used when constructing the source map for the
+	* bundle, to identify this `source` in the source map's `sources` field. The `ignoreList` hint
+	* is used to populate the `x_google_ignoreList` extension field in the source map, which is a
+	* mechanism for tools to signal to debuggers that certain sources should be ignored by default
+	* (depending on user preferences).
+	*/
 	addSource(source) {
-		if (source instanceof MagicString) {
-			return this.addSource({
-				content: source,
-				filename: source.filename,
-				separator: this.separator,
-			});
-		}
-
-		if (!isObject(source) || !source.content) {
-			throw new Error(
-				'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',
-			);
-		}
-
-		['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => {
+		if (source instanceof MagicString) return this.addSource({
+			content: source,
+			filename: source.filename,
+			separator: this.separator
+		});
+		if (!isObject(source) || !source.content) throw new Error("bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`");
+		[
+			"filename",
+			"ignoreList",
+			"indentExclusionRanges",
+			"separator"
+		].forEach((option) => {
 			if (!hasOwnProp.call(source, option)) source[option] = source.content[option];
 		});
-
-		if (source.separator === undefined) {
-			// TODO there's a bunch of this sort of thing, needs cleaning up
-			source.separator = this.separator;
-		}
-
-		if (source.filename) {
-			if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
-				this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
-				this.uniqueSources.push({ filename: source.filename, content: source.content.original });
-			} else {
-				const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
-				if (source.content.original !== uniqueSource.content) {
-					throw new Error(`Illegal source: same filename (${source.filename}), different contents`);
-				}
-			}
+		if (source.separator === void 0) source.separator = this.separator;
+		if (source.filename) if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
+			this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
+			this.uniqueSources.push({
+				filename: source.filename,
+				content: source.content.original
+			});
+		} else {
+			const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
+			if (source.content.original !== uniqueSource.content) throw new Error(`Illegal source: same filename (${source.filename}), different contents`);
 		}
-
 		this.sources.push(source);
 		return this;
 	}
-
 	append(str, options) {
 		this.addSource({
 			content: new MagicString(str),
-			separator: (options && options.separator) || '',
+			separator: options && options.separator || ""
 		});
-
 		return this;
 	}
-
 	clone() {
 		const bundle = new Bundle({
 			intro: this.intro,
-			separator: this.separator,
+			separator: this.separator
 		});
-
 		this.sources.forEach((source) => {
 			bundle.addSource({
 				filename: source.filename,
 				content: source.content.clone(),
-				separator: source.separator,
+				separator: source.separator
 			});
 		});
-
 		return bundle;
 	}
-
 	generateDecodedMap(options = {}) {
 		const names = [];
-		let x_google_ignoreList = undefined;
+		let x_google_ignoreList;
 		this.sources.forEach((source) => {
 			Object.keys(source.content.storedNames).forEach((name) => {
-				if (!~names.indexOf(name)) names.push(name);
+				if (!names.includes(name)) names.push(name);
 			});
 		});
-
 		const mappings = new Mappings(options.hires);
-
-		if (this.intro) {
-			mappings.advance(this.intro);
-		}
-
+		if (this.intro) mappings.advance(this.intro);
 		this.sources.forEach((source, i) => {
-			if (i > 0) {
-				mappings.advance(this.separator);
-			}
-
+			if (i > 0) mappings.advance(this.separator);
 			const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;
 			const magicString = source.content;
 			const locate = getLocator(magicString.original);
-
-			if (magicString.intro) {
-				mappings.advance(magicString.intro);
-			}
-
+			if (magicString.intro) mappings.advance(magicString.intro);
 			magicString.firstChunk.eachNext((chunk) => {
 				const loc = locate(chunk.start);
-
 				if (chunk.intro.length) mappings.advance(chunk.intro);
-
-				if (source.filename) {
-					if (chunk.edited) {
-						mappings.addEdit(
-							sourceIndex,
-							chunk.content,
-							loc,
-							chunk.storeName ? names.indexOf(chunk.original) : -1,
-						);
-					} else {
-						mappings.addUneditedChunk(
-							sourceIndex,
-							chunk,
-							magicString.original,
-							loc,
-							magicString.sourcemapLocations,
-						);
-					}
-				} else {
-					mappings.advance(chunk.content);
-				}
-
+				if (source.filename) if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+				else mappings.addUneditedChunk(sourceIndex, chunk, magicString.original, loc, magicString.sourcemapLocations);
+				else mappings.advance(chunk.content);
 				if (chunk.outro.length) mappings.advance(chunk.outro);
 			});
-
-			if (magicString.outro) {
-				mappings.advance(magicString.outro);
-			}
-
+			if (magicString.outro) mappings.advance(magicString.outro);
 			if (source.ignoreList && sourceIndex !== -1) {
-				if (x_google_ignoreList === undefined) {
-					x_google_ignoreList = [];
-				}
+				if (x_google_ignoreList === void 0) x_google_ignoreList = [];
 				x_google_ignoreList.push(sourceIndex);
 			}
 		});
-
 		return {
-			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
 			sources: this.uniqueSources.map((source) => {
 				return options.file ? getRelativePath(options.file, source.filename) : source.filename;
 			}),
@@ -5779,137 +5581,91 @@ let Bundle$1 = class Bundle {
 			}),
 			names,
 			mappings: mappings.raw,
-			x_google_ignoreList,
+			x_google_ignoreList
 		};
 	}
-
 	generateMap(options) {
 		return new SourceMap(this.generateDecodedMap(options));
 	}
-
 	getIndentString() {
 		const indentStringCounts = {};
-
 		this.sources.forEach((source) => {
 			const indentStr = source.content._getRawIndentString();
-
 			if (indentStr === null) return;
-
 			if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;
 			indentStringCounts[indentStr] += 1;
 		});
-
-		return (
-			Object.keys(indentStringCounts).sort((a, b) => {
-				return indentStringCounts[a] - indentStringCounts[b];
-			})[0] || '\t'
-		);
+		return Object.keys(indentStringCounts).sort((a, b) => {
+			return indentStringCounts[a] - indentStringCounts[b];
+		})[0] || "	";
 	}
-
 	indent(indentStr) {
-		if (!arguments.length) {
-			indentStr = this.getIndentString();
-		}
-
-		if (indentStr === '') return this; // noop
-
-		let trailingNewline = !this.intro || this.intro.slice(-1) === '\n';
-
+		if (!arguments.length) indentStr = this.getIndentString();
+		if (indentStr === "") return this;
+		let trailingNewline = !this.intro || this.intro.slice(-1) === "\n";
 		this.sources.forEach((source, i) => {
-			const separator = source.separator !== undefined ? source.separator : this.separator;
-			const indentStart = trailingNewline || (i > 0 && /\r?\n$/.test(separator));
-
+			const separator = source.separator !== void 0 ? source.separator : this.separator;
+			const indentStart = trailingNewline || i > 0 && /\r?\n$/.test(separator);
 			source.content.indent(indentStr, {
 				exclude: source.indentExclusionRanges,
-				indentStart, //: trailingNewline || /\r?\n$/.test( separator )  //true///\r?\n/.test( separator )
+				indentStart
 			});
-
-			trailingNewline = source.content.lastChar() === '\n';
+			trailingNewline = source.content.lastChar() === "\n";
+		});
+		if (this.intro) this.intro = indentStr + this.intro.replace(/^[^\n]/gm, (match, index) => {
+			return index > 0 ? indentStr + match : match;
 		});
-
-		if (this.intro) {
-			this.intro =
-				indentStr +
-				this.intro.replace(/^[^\n]/gm, (match, index) => {
-					return index > 0 ? indentStr + match : match;
-				});
-		}
-
 		return this;
 	}
-
 	prepend(str) {
 		this.intro = str + this.intro;
 		return this;
 	}
-
 	toString() {
-		const body = this.sources
-			.map((source, i) => {
-				const separator = source.separator !== undefined ? source.separator : this.separator;
-				const str = (i > 0 ? separator : '') + source.content.toString();
-
-				return str;
-			})
-			.join('');
-
+		const body = this.sources.map((source, i) => {
+			const separator = source.separator !== void 0 ? source.separator : this.separator;
+			return (i > 0 ? separator : "") + source.content.toString();
+		}).join("");
 		return this.intro + body;
 	}
-
 	isEmpty() {
 		if (this.intro.length && this.intro.trim()) return false;
 		if (this.sources.some((source) => !source.content.isEmpty())) return false;
 		return true;
 	}
-
 	length() {
-		return this.sources.reduce(
-			(length, source) => length + source.content.length(),
-			this.intro.length,
-		);
+		return this.sources.reduce((length, source) => length + source.content.length(), this.intro.length);
 	}
-
 	trimLines() {
-		return this.trim('[\\r\\n]');
+		return this.trim("[\\r\\n]");
 	}
-
 	trim(charType) {
 		return this.trimStart(charType).trimEnd(charType);
 	}
-
 	trimStart(charType) {
-		const rx = new RegExp('^' + (charType || '\\s') + '+');
-		this.intro = this.intro.replace(rx, '');
-
+		const rx = new RegExp(`^${charType || "\\s"}+`);
+		this.intro = this.intro.replace(rx, "");
 		if (!this.intro) {
 			let source;
 			let i = 0;
-
 			do {
 				source = this.sources[i++];
-				if (!source) {
-					break;
-				}
+				if (!source) break;
 			} while (!source.content.trimStartAborted(charType));
 		}
-
 		return this;
 	}
-
 	trimEnd(charType) {
-		const rx = new RegExp((charType || '\\s') + '+$');
-
+		const rx = new RegExp(`${charType || "\\s"}+$`);
 		let source;
 		let i = this.sources.length - 1;
-
 		do {
 			source = this.sources[i--];
 			if (!source) {
-				this.intro = this.intro.replace(rx, '');
+				this.intro = this.intro.replace(rx, "");
 				break;
 			}
 		} while (!source.content.trimEndAborted(charType));
-
 		return this;
 	}
 };
@@ -6669,13 +6425,14 @@ const RESERVED_NAMES = new Set([
 ]);
 
 const illegalCharacters = /[^\w$]/g;
+const illegalCharacter = /[^\w$]/;
 const startsWithDigit = (value) => /\d/.test(value[0]);
 const needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES.has(value) || value === 'arguments';
 function isLegal(value) {
     if (needsEscape(value)) {
         return false;
     }
-    return !illegalCharacters.test(value);
+    return !illegalCharacter.test(value);
 }
 function makeLegal(value) {
     value = value
@@ -9449,12 +9206,12 @@ class IdentifierBase extends NodeBase {
             this.variable.module.hasTreeShakingPassStarted)) {
             return (this.isTDZAccess = false);
         }
-        let decl_id;
+        let declaration_id;
         if (this.variable.declarations &&
             this.variable.declarations.length === 1 &&
-            (decl_id = this.variable.declarations[0]) &&
-            this.start < decl_id.start &&
-            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
+            (declaration_id = this.variable.declarations[0]) &&
+            this.start < declaration_id.start &&
+            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(declaration_id)) {
             // a variable accessed before its declaration
             // in the same function or at top level of module
             return (this.isTDZAccess = true);
@@ -12336,13 +12093,13 @@ function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snip
     }
     let exportBlock = '';
     if (namedExportsMode) {
-        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: dependencyNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
             if (!reexports) {
                 continue;
             }
             for (const specifier of reexports) {
                 if (specifier.reexported !== '*') {
-                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+                    const importName = getReexportedImportName(name, specifier.imported, dependencyNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
                     if (exportBlock)
                         exportBlock += n;
                     if (specifier.imported !== '*' && specifier.needsLiveBinding) {
@@ -12421,14 +12178,14 @@ function getSingleDefaultExport(exports, dependencies, interop, externalLiveBind
         return exports[0].local;
     }
     else {
-        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: dependencyNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
             if (reexports) {
-                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+                return getReexportedImportName(name, reexports[0].imported, dependencyNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
             }
         }
     }
 }
-function getReexportedImportName(moduleVariableName, imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings, getPropertyAccess) {
+function getReexportedImportName(moduleVariableName, imported, dependencyNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings, getPropertyAccess) {
     if (imported === 'default') {
         if (!isChunk) {
             const moduleInterop = interop(moduleId);
@@ -12439,12 +12196,14 @@ function getReexportedImportName(moduleVariableName, imported, depNamedExportsMo
                 ? `${variableName}${getPropertyAccess('default')}`
                 : variableName;
         }
-        return depNamedExportsMode
+        return dependencyNamedExportsMode
             ? `${moduleVariableName}${getPropertyAccess('default')}`
             : moduleVariableName;
     }
     if (imported === '*') {
-        return (isChunk ? !depNamedExportsMode : namespaceInteropHelpersByInteropType[interop(moduleId)])
+        return (isChunk
+            ? !dependencyNamedExportsMode
+            : namespaceInteropHelpersByInteropType[interop(moduleId)])
             ? namespaceVariableName
             : moduleVariableName;
     }
@@ -12669,6 +12428,7 @@ const builtinModules = [
 	"util/types",
 	"node:v8",
 	"v8",
+	"node:vfs",
 	"node:vm",
 	"vm",
 	"node:wasi",
@@ -12958,7 +12718,7 @@ function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultE
     }
     warnOnBuiltins(log, dependencies);
     const external = trimEmptyImports(dependencies);
-    const deps = external.map(dep => dep.globalName || 'null');
+    const deps = external.map(dependency => dependency.globalName || 'null');
     const parameters = external.map(m => m.name);
     if (hasExports && !name) {
         log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingNameOptionForIifeExport());
@@ -13179,21 +12939,21 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultEx
     }
     throwOnPhase('umd', id, dependencies);
     warnOnBuiltins(log, dependencies);
-    const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
-    const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
+    const amdDependencies = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
+    const cjsDependencies = dependencies.map(m => `require('${m.importPath}')`);
     const trimmedImports = trimEmptyImports(dependencies);
-    const globalDeps = trimmedImports.map(module => globalProperty(module.globalName, globalVariable, getPropertyAccess));
+    const globalDependencies = trimmedImports.map(module => globalProperty(module.globalName, globalVariable, getPropertyAccess));
     const factoryParameters = trimmedImports.map(m => m.name);
     if ((hasExports || noConflict) &&
         (namedExportsMode || (hasExports && exports[0]?.local === 'exports.default'))) {
-        amdDeps.unshift(`'exports'`);
-        cjsDeps.unshift(`exports`);
-        globalDeps.unshift(assignToDeepVariable(name, globalVariable, globals, `${extend ? `${globalProperty(name, globalVariable, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets, log));
+        amdDependencies.unshift(`'exports'`);
+        cjsDependencies.unshift(`exports`);
+        globalDependencies.unshift(assignToDeepVariable(name, globalVariable, globals, `${extend ? `${globalProperty(name, globalVariable, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets, log));
         factoryParameters.unshift('exports');
     }
     const completeAmdId = getCompleteAmdId(amd, id);
     const amdParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
-        (amdDeps.length > 0 ? `[${amdDeps.join(`,${_}`)}],${_}` : ``);
+        (amdDependencies.length > 0 ? `[${amdDependencies.join(`,${_}`)}],${_}` : ``);
     const define = amd.define;
     const cjsExport = !namedExportsMode && hasExports ? `module.exports${_}=${_}` : ``;
     const useStrict = strict ? `${_}'use strict';${n}` : ``;
@@ -13202,13 +12962,13 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultEx
         const noConflictExportsVariable = compact ? 'e' : 'exports';
         let factory;
         if (!namedExportsMode && hasExports) {
-            factory = `${cnst} ${noConflictExportsVariable}${_}=${_}${assignToDeepVariable(name, globalVariable, globals, `${factoryVariable}(${globalDeps.join(`,${_}`)})`, snippets, log)};`;
+            factory = `${cnst} ${noConflictExportsVariable}${_}=${_}${assignToDeepVariable(name, globalVariable, globals, `${factoryVariable}(${globalDependencies.join(`,${_}`)})`, snippets, log)};`;
         }
         else {
-            const module = globalDeps.shift();
+            const module = globalDependencies.shift();
             factory =
                 `${cnst} ${noConflictExportsVariable}${_}=${_}${module};${n}` +
-                    `${t}${t}${factoryVariable}(${[noConflictExportsVariable, ...globalDeps].join(`,${_}`)});`;
+                    `${t}${t}${factoryVariable}(${[noConflictExportsVariable, ...globalDependencies].join(`,${_}`)});`;
         }
         iifeExport =
             `(${getFunctionIntro([], { isAsync: false, name: null })}{${n}` +
@@ -13222,12 +12982,12 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultEx
                 `${t}})()`;
     }
     else {
-        iifeExport = `${factoryVariable}(${globalDeps.join(`,${_}`)})`;
+        iifeExport = `${factoryVariable}(${globalDependencies.join(`,${_}`)})`;
         if (!namedExportsMode && hasExports) {
             iifeExport = assignToDeepVariable(name, globalVariable, globals, iifeExport, snippets, log);
         }
     }
-    const iifeNeedsGlobal = hasExports || (noConflict && namedExportsMode) || globalDeps.length > 0;
+    const iifeNeedsGlobal = hasExports || (noConflict && namedExportsMode) || globalDependencies.length > 0;
     const wrapperParameters = [factoryVariable];
     if (iifeNeedsGlobal) {
         wrapperParameters.unshift(globalVariable);
@@ -13239,7 +12999,7 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultEx
     const iifeEnd = iifeNeedsGlobal ? ')' : '';
     const cjsIntro = iifeNeedsGlobal
         ? `${t}typeof exports${_}===${_}'object'${_}&&${_}typeof module${_}!==${_}'undefined'${_}?` +
-            `${_}${cjsExport}${factoryVariable}(${cjsDeps.join(`,${_}`)})${_}:${n}`
+            `${_}${cjsExport}${factoryVariable}(${cjsDependencies.join(`,${_}`)})${_}:${n}`
         : '';
     const wrapperIntro = `(${getNonArrowFunctionIntro(wrapperParameters, { isAsync: false, name: null })}{${n}` +
         cjsIntro +
@@ -15300,19 +15060,19 @@ class ImportExpression extends NodeBase {
                         return null;
                     const chunkInfos = [];
                     const importerPath = ownChunk.getFileName();
-                    for (const dep of targetChunk.dependencies) {
-                        const resolvedImportPath = `'${dep.getImportPath(importerPath)}'`;
-                        if (dep instanceof ExternalChunk) {
+                    for (const dependency of targetChunk.dependencies) {
+                        const resolvedImportPath = `'${dependency.getImportPath(importerPath)}'`;
+                        if (dependency instanceof ExternalChunk) {
                             chunkInfos.push({
-                                fileName: dep.getFileName(),
+                                fileName: dependency.getFileName(),
                                 resolvedImportPath,
                                 type: 'external'
                             });
                         }
                         else {
                             chunkInfos.push({
-                                chunk: dep.getPreRenderedChunkInfo(),
-                                fileName: dep.getFileName(),
+                                chunk: dependency.getPreRenderedChunkInfo(),
+                                fileName: dependency.getFileName(),
                                 resolvedImportPath,
                                 type: 'internal'
                             });
@@ -20489,9 +20249,9 @@ class Chunk {
         // for static and dynamic entry points, add transitive dependencies to this
         // chunk's dependencies to avoid loading latency
         if (hoistTransitiveImports && !preserveModules && facadeModule !== null) {
-            for (const dep of dependencies) {
-                if (dep instanceof Chunk)
-                    this.inlineChunkDependencies(dep);
+            for (const dependency of dependencies) {
+                if (dependency instanceof Chunk)
+                    this.inlineChunkDependencies(dependency);
             }
         }
     }
@@ -20663,11 +20423,11 @@ class Chunk {
                         if (!chunk || format !== 'es') {
                             continue;
                         }
-                        const chunkDep = this.renderedDependencies.get(chunk);
-                        if (!chunkDep) {
+                        const chunkDependency = this.renderedDependencies.get(chunk);
+                        if (!chunkDependency) {
                             continue;
                         }
-                        const { imports, reexports } = chunkDep;
+                        const { imports, reexports } = chunkDependency;
                         const importedByReexported = reexports?.find(({ reexported }) => reexported === exportName);
                         const isImported = imports?.find(({ imported }) => imported === importedByReexported?.imported);
                         if (!isImported) {
@@ -20877,6 +20637,10 @@ class Chunk {
             return predefinedChunkName;
         const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
         const sanitizedId = sanitizeFileName(parseAst_js.normalize(module.id.split(QUERY_HASH_REGEX, 1)[0]));
+        // The module id was sanitized, so the base must be sanitized as well before
+        // comparing paths; otherwise ids containing sanitized characters escape the
+        // base via "../" and trip the placeholder validation (#5446).
+        const sanitizedBase = sanitizeFileName(this.inputBase);
         const extensionName = path.extname(sanitizedId);
         const idWithoutExtension = NON_ASSET_EXTENSIONS.has(extensionName)
             ? sanitizedId.slice(0, -extensionName.length)
@@ -20887,10 +20651,10 @@ class Chunk {
             }
             else {
                 // handle edge case in Windows
-                if (this.inputBase === '/' && idWithoutExtension[0] !== '/') {
-                    return parseAst_js.relative(this.inputBase, idWithoutExtension.replace(/^[a-zA-Z]:[/\\]/, '/'));
+                if (sanitizedBase === '/' && idWithoutExtension[0] !== '/') {
+                    return parseAst_js.relative(sanitizedBase, idWithoutExtension.replace(/^[a-zA-Z]:[/\\]/, '/'));
                 }
-                return parseAst_js.relative(this.inputBase, idWithoutExtension);
+                return parseAst_js.relative(sanitizedBase, idWithoutExtension);
             }
         }
         else {
@@ -21005,12 +20769,12 @@ class Chunk {
         return (this.renderedDependencies = renderedDependencies);
     }
     inlineChunkDependencies(chunk) {
-        for (const dep of chunk.dependencies) {
-            if (this.dependencies.has(dep))
+        for (const dependency of chunk.dependencies) {
+            if (this.dependencies.has(dependency))
                 continue;
-            this.dependencies.add(dep);
-            if (dep instanceof Chunk) {
-                this.inlineChunkDependencies(dep);
+            this.dependencies.add(dependency);
+            if (dependency instanceof Chunk) {
+                this.inlineChunkDependencies(dependency);
             }
         }
     }
@@ -22464,7 +22228,7 @@ function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bun
             finalSourcemapFileName = sourcemapFileName
                 ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
                 : `${finalFileName}.map`;
-            map.file = replacePlaceholders(map.file, hashesByPlaceholder);
+            map.file = replacePlaceholders(map.file ?? '', hashesByPlaceholder);
             updatedCode += emitSourceMapAndGetComment(finalSourcemapFileName, map, pluginDriver, options);
         }
         bundle[finalFileName] = chunk.finalizeChunk(updatedCode, map, finalSourcemapFileName, hashesByPlaceholder);
@@ -22997,7 +22761,6 @@ async function transform(source, module, pluginDriver, options) {
                     }
                     return new SourceMap({
                         ...combinedMap,
-                        file: null,
                         sourcesContent: combinedMap.sourcesContent
                     });
                 },