@datadog/esbuild-plugin 2.3.1-dev-1 → 2.3.1-dev-3

package/dist/src/index.mjs

@@ -7,7 +7,7 @@ import { lstat, readdir as readdir$1, readlink, realpath } from 'node:fs/promise
 import { EventEmitter as EventEmitter$1 } from 'node:events';
 import Stream$1 from 'node:stream';
 import { StringDecoder } from 'node:string_decoder';
-import require$$1, { resolve as resolve$1, isAbsolute, normalize as normalize$1, extname, basename, dirname } from 'path';
+import require$$1, { resolve as resolve$1, extname, isAbsolute, normalize as normalize$1 } from 'path';
 import require$$0$1 from 'tty';
 import require$$1$1 from 'util';
 import { spawn } from 'child_process';
@@ -22,7 +22,6 @@ import { request } from 'https';
 import { performance as performance$1 } from 'perf_hooks';
 import * as querystring from 'querystring';
 import process2 from 'process';
-import { createRequire } from 'module';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -2267,9 +2266,9 @@ function retry$1(fn, opts) {
   return new Promise(run);
 }
 
-var lib$2 = retry$1;
+var lib$3 = retry$1;
 
-var retry$2 = /*@__PURE__*/getDefaultExportFromCjs(lib$2);
+var retry$2 = /*@__PURE__*/getDefaultExportFromCjs(lib$3);
 
 const formatDuration = (duration) => {
   const days = Math.floor(duration / 1e3 / 60 / 60 / 24);
@@ -19076,7 +19075,6 @@ const getInjectionPlugins = (opts, context, toInject) => {
     }
   };
   const isInjectedFile = (id) => {
-    console.log("GOT INJECTED FILE", id);
     return id.includes(INJECTED_FILE);
   };
   return [
@@ -19149,23 +19147,17 @@ const getInjectionPlugins = (opts, context, toInject) => {
       name: RESOLUTION_PLUGIN_NAME,
       enforce: "post",
       resolveId(id) {
-        console.log("RESOLVE", id);
         if (isInjectedFile(id)) {
-          console.log("RESOLVED INJECTED", id);
           return { id, moduleSideEffects: true };
         }
       },
       loadInclude(id) {
-        console.log("LOAD INCLUDE", id);
         if (isInjectedFile(id)) {
-          console.log("LOAD INCLUDE INJECTED", id);
           return true;
         }
       },
       load(id) {
-        console.log("LOAD", id);
         if (isInjectedFile(id)) {
-          console.log("LOAD INJECTED", id);
           return getContentToInject();
         }
       }
@@ -20540,7 +20532,7 @@ const getPlugins$2 = (opts, context) => {
   ];
 };
 
-var lib$1 = {exports: {}};
+var lib$2 = {exports: {}};
 
 var fs$i = {};
 
@@ -23479,9 +23471,9 @@ var output = {
 	    get () { return fs.promises }
 	  });
 	} 
-} (lib$1));
+} (lib$2));
 
-var libExports = lib$1.exports;
+var libExports = lib$2.exports;
 
 const CONFIG_KEY = "telemetry";
 const PLUGIN_NAME = `datadog-telemetry-plugin`;
@@ -25483,7 +25475,7 @@ var pp$9 = Parser.prototype;
 
 // ## Parser utilities
 
-var literal = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/;
+var literal = /^(?:'((?:\\.|[^'\\])*?)'|"((?:\\.|[^"\\])*?)")/;
 pp$9.strictDirective = function(start) {
   if (this.options.ecmaVersion < 5) { return false }
   for (;;) {
@@ -25669,7 +25661,7 @@ pp$8.isLet = function(context) {
   // Statement) is allowed here. If context is not empty then only a Statement
   // is allowed. However, `let [` is an explicit negative lookahead for
   // ExpressionStatement, so special-case it first.
-  if (nextCh === 91 || nextCh === 92) { return true } // '[', '\'
+  if (nextCh === 91 || nextCh === 92) { return true } // '[', '/'
   if (context) { return false }
 
   if (nextCh === 123 || nextCh > 0xd7ff && nextCh < 0xdc00) { return true } // '{', astral
@@ -25862,19 +25854,13 @@ pp$8.parseForStatement = function(node) {
     return this.parseFor(node, init$1)
   }
   var startsWithLet = this.isContextual("let"), isForOf = false;
-  var containsEsc = this.containsEsc;
   var refDestructuringErrors = new DestructuringErrors;
-  var initPos = this.start;
-  var init = awaitAt > -1
-    ? this.parseExprSubscripts(refDestructuringErrors, "await")
-    : this.parseExpression(true, refDestructuringErrors);
+  var init = this.parseExpression(awaitAt > -1 ? "await" : true, refDestructuringErrors);
   if (this.type === types$1._in || (isForOf = this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
-    if (awaitAt > -1) { // implies `ecmaVersion >= 9` (see declaration of awaitAt)
-      if (this.type === types$1._in) { this.unexpected(awaitAt); }
-      node.await = true;
-    } else if (isForOf && this.options.ecmaVersion >= 8) {
-      if (init.start === initPos && !containsEsc && init.type === "Identifier" && init.name === "async") { this.unexpected(); }
-      else if (this.options.ecmaVersion >= 9) { node.await = false; }
+    if (this.options.ecmaVersion >= 9) {
+      if (this.type === types$1._in) {
+        if (awaitAt > -1) { this.unexpected(awaitAt); }
+      } else { node.await = awaitAt > -1; }
     }
     if (startsWithLet && isForOf) { this.raise(init.start, "The left-hand side of a for-of loop may not start with 'let'."); }
     this.toAssignable(init, false, refDestructuringErrors);
@@ -27487,7 +27473,8 @@ pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
     node.argument = this.parseMaybeUnary(null, true, update, forInit);
     this.checkExpressionErrors(refDestructuringErrors, true);
     if (update) { this.checkLValSimple(node.argument); }
-    else if (this.strict && node.operator === "delete" && isLocalVariableAccess(node.argument))
+    else if (this.strict && node.operator === "delete" &&
+             node.argument.type === "Identifier")
       { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
     else if (node.operator === "delete" && isPrivateFieldAccess(node.argument))
       { this.raiseRecoverable(node.start, "Private fields can not be deleted"); }
@@ -27522,18 +27509,10 @@ pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
   }
 };
 
-function isLocalVariableAccess(node) {
-  return (
-    node.type === "Identifier" ||
-    node.type === "ParenthesizedExpression" && isLocalVariableAccess(node.expression)
-  )
-}
-
 function isPrivateFieldAccess(node) {
   return (
     node.type === "MemberExpression" && node.property.type === "PrivateIdentifier" ||
-    node.type === "ChainExpression" && isPrivateFieldAccess(node.expression) ||
-    node.type === "ParenthesizedExpression" && isPrivateFieldAccess(node.expression)
+    node.type === "ChainExpression" && isPrivateFieldAccess(node.expression)
   )
 }
 
@@ -27960,7 +27939,7 @@ pp$5.parseTemplateElement = function(ref) {
       this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
     }
     elem.value = {
-      raw: this.value.replace(/\r\n?/g, "\n"),
+      raw: this.value,
       cooked: null
     };
   } else {
@@ -28635,30 +28614,6 @@ for (var i = 0, list = [9, 10, 11, 12, 13, 14]; i < list.length; i += 1) {
 
 var pp$1 = Parser.prototype;
 
-// Track disjunction structure to determine whether a duplicate
-// capture group name is allowed because it is in a separate branch.
-var BranchID = function BranchID(parent, base) {
-  // Parent disjunction branch
-  this.parent = parent;
-  // Identifies this set of sibling branches
-  this.base = base || this;
-};
-
-BranchID.prototype.separatedFrom = function separatedFrom (alt) {
-  // A branch is separate from another branch if they or any of
-  // their parents are siblings in a given disjunction
-  for (var self = this; self; self = self.parent) {
-    for (var other = alt; other; other = other.parent) {
-      if (self.base === other.base && self !== other) { return true }
-    }
-  }
-  return false
-};
-
-BranchID.prototype.sibling = function sibling () {
-  return new BranchID(this.parent, this.base)
-};
-
 var RegExpValidationState = function RegExpValidationState(parser) {
   this.parser = parser;
   this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "") + (parser.options.ecmaVersion >= 13 ? "d" : "") + (parser.options.ecmaVersion >= 15 ? "v" : "");
@@ -28675,9 +28630,8 @@ var RegExpValidationState = function RegExpValidationState(parser) {
   this.lastAssertionIsQuantifiable = false;
   this.numCapturingParens = 0;
   this.maxBackReference = 0;
-  this.groupNames = Object.create(null);
+  this.groupNames = [];
   this.backReferenceNames = [];
-  this.branchID = null;
 };
 
 RegExpValidationState.prototype.reset = function reset (start, pattern, flags) {
@@ -28809,11 +28763,6 @@ pp$1.validateRegExpFlags = function(state) {
   }
 };
 
-function hasProp(obj) {
-  for (var _ in obj) { return true }
-  return false
-}
-
 /**
  * Validate the pattern part of a given RegExpLiteral.
  *
@@ -28828,7 +28777,7 @@ pp$1.validateRegExpPattern = function(state) {
   // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*
   // exception if _P_ did not conform to the grammar, if any elements of _P_
   // were not matched by the parse, or if any Early Error conditions exist.
-  if (!state.switchN && this.options.ecmaVersion >= 9 && hasProp(state.groupNames)) {
+  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
     state.switchN = true;
     this.regexp_pattern(state);
   }
@@ -28842,9 +28791,8 @@ pp$1.regexp_pattern = function(state) {
   state.lastAssertionIsQuantifiable = false;
   state.numCapturingParens = 0;
   state.maxBackReference = 0;
-  state.groupNames = Object.create(null);
+  state.groupNames.length = 0;
   state.backReferenceNames.length = 0;
-  state.branchID = null;
 
   this.regexp_disjunction(state);
 
@@ -28863,7 +28811,7 @@ pp$1.regexp_pattern = function(state) {
   for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
     var name = list[i];
 
-    if (!state.groupNames[name]) {
+    if (state.groupNames.indexOf(name) === -1) {
       state.raise("Invalid named capture referenced");
     }
   }
@@ -28871,14 +28819,10 @@ pp$1.regexp_pattern = function(state) {
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction
 pp$1.regexp_disjunction = function(state) {
-  var trackDisjunction = this.options.ecmaVersion >= 16;
-  if (trackDisjunction) { state.branchID = new BranchID(state.branchID, null); }
   this.regexp_alternative(state);
   while (state.eat(0x7C /* | */)) {
-    if (trackDisjunction) { state.branchID = state.branchID.sibling(); }
     this.regexp_alternative(state);
   }
-  if (trackDisjunction) { state.branchID = state.branchID.parent; }
 
   // Make the same message as V8.
   if (this.regexp_eatQuantifier(state, true)) {
@@ -28891,7 +28835,8 @@ pp$1.regexp_disjunction = function(state) {
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative
 pp$1.regexp_alternative = function(state) {
-  while (state.pos < state.source.length && this.regexp_eatTerm(state)) {}
+  while (state.pos < state.source.length && this.regexp_eatTerm(state))
+    { }
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term
@@ -29129,26 +29074,14 @@ pp$1.regexp_eatExtendedPatternCharacter = function(state) {
 //   `?` GroupName
 pp$1.regexp_groupSpecifier = function(state) {
   if (state.eat(0x3F /* ? */)) {
-    if (!this.regexp_eatGroupName(state)) { state.raise("Invalid group"); }
-    var trackDisjunction = this.options.ecmaVersion >= 16;
-    var known = state.groupNames[state.lastStringValue];
-    if (known) {
-      if (trackDisjunction) {
-        for (var i = 0, list = known; i < list.length; i += 1) {
-          var altID = list[i];
-
-          if (!altID.separatedFrom(state.branchID))
-            { state.raise("Duplicate capture group name"); }
-        }
-      } else {
+    if (this.regexp_eatGroupName(state)) {
+      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
         state.raise("Duplicate capture group name");
       }
+      state.groupNames.push(state.lastStringValue);
+      return
     }
-    if (trackDisjunction) {
-      (known || (state.groupNames[state.lastStringValue] = [])).push(state.branchID);
-    } else {
-      state.groupNames[state.lastStringValue] = true;
-    }
+    state.raise("Invalid group");
   }
 };
 
@@ -30653,18 +30586,15 @@ pp.readInvalidTemplateToken = function() {
       break
 
     case "$":
-      if (this.input[this.pos + 1] !== "{") { break }
-      // fall through
+      if (this.input[this.pos + 1] !== "{") {
+        break
+      }
+
+    // falls through
     case "`":
       return this.finishToken(types$1.invalidTemplate, this.input.slice(this.start, this.pos))
 
-    case "\r":
-      if (this.input[this.pos + 1] === "\n") { ++this.pos; }
-      // fall through
-    case "\n": case "\u2028": case "\u2029":
-      ++this.curLine;
-      this.lineStart = this.pos + 1;
-      break
+    // no default
     }
   }
   this.raise(this.start, "Unterminated template");
@@ -30727,7 +30657,6 @@ pp.readEscapedChar = function(inTemplate) {
     if (isNewLine(ch)) {
       // Unicode new line characters after \ get removed from output in both
       // template literals and strings
-      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
       return ""
     }
     return String.fromCharCode(ch)
@@ -30806,7 +30735,7 @@ pp.readWord = function() {
 // [walk]: util/walk.js
 
 
-var version$2 = "8.12.1";
+var version$2 = "8.11.3";
 
 Parser.acorn = {
   Parser: Parser,
@@ -30830,6 +30759,3486 @@ Parser.acorn = {
   nonASCIIwhitespace: nonASCIIwhitespace
 };
 
+var lib$1 = {};
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var Source_1;
+var hasRequiredSource;
+
+function requireSource () {
+	if (hasRequiredSource) return Source_1;
+	hasRequiredSource = 1;
+
+	class Source {
+		source() {
+			throw new Error("Abstract");
+		}
+
+		buffer() {
+			const source = this.source();
+			if (Buffer.isBuffer(source)) return source;
+			return Buffer.from(source, "utf-8");
+		}
+
+		size() {
+			return this.buffer().length;
+		}
+
+		map(options) {
+			return null;
+		}
+
+		sourceAndMap(options) {
+			return {
+				source: this.source(),
+				map: this.map(options)
+			};
+		}
+
+		updateHash(hash) {
+			throw new Error("Abstract");
+		}
+	}
+
+	Source_1 = Source;
+	return Source_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var getGeneratedSourceInfo_1;
+var hasRequiredGetGeneratedSourceInfo;
+
+function requireGetGeneratedSourceInfo () {
+	if (hasRequiredGetGeneratedSourceInfo) return getGeneratedSourceInfo_1;
+	hasRequiredGetGeneratedSourceInfo = 1;
+
+	const CHAR_CODE_NEW_LINE = "\n".charCodeAt(0);
+
+	const getGeneratedSourceInfo = source => {
+		if (source === undefined) {
+			return {};
+		}
+		const lastLineStart = source.lastIndexOf("\n");
+		if (lastLineStart === -1) {
+			return {
+				generatedLine: 1,
+				generatedColumn: source.length,
+				source
+			};
+		}
+		let generatedLine = 2;
+		for (let i = 0; i < lastLineStart; i++) {
+			if (source.charCodeAt(i) === CHAR_CODE_NEW_LINE) generatedLine++;
+		}
+		return {
+			generatedLine,
+			generatedColumn: source.length - lastLineStart - 1,
+			source
+		};
+	};
+
+	getGeneratedSourceInfo_1 = getGeneratedSourceInfo;
+	return getGeneratedSourceInfo_1;
+}
+
+var splitIntoLines_1;
+var hasRequiredSplitIntoLines;
+
+function requireSplitIntoLines () {
+	if (hasRequiredSplitIntoLines) return splitIntoLines_1;
+	hasRequiredSplitIntoLines = 1;
+	const splitIntoLines = str => {
+		const results = [];
+		const len = str.length;
+		let i = 0;
+		for (; i < len; ) {
+			const cc = str.charCodeAt(i);
+			// 10 is "\n".charCodeAt(0)
+			if (cc === 10) {
+				results.push("\n");
+				i++;
+			} else {
+				let j = i + 1;
+				// 10 is "\n".charCodeAt(0)
+				while (j < len && str.charCodeAt(j) !== 10) j++;
+				results.push(str.slice(i, j + 1));
+				i = j + 1;
+			}
+		}
+		return results;
+	};
+	splitIntoLines_1 = splitIntoLines;
+	return splitIntoLines_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var streamChunksOfRawSource_1;
+var hasRequiredStreamChunksOfRawSource;
+
+function requireStreamChunksOfRawSource () {
+	if (hasRequiredStreamChunksOfRawSource) return streamChunksOfRawSource_1;
+	hasRequiredStreamChunksOfRawSource = 1;
+
+	const getGeneratedSourceInfo = requireGetGeneratedSourceInfo();
+	const splitIntoLines = requireSplitIntoLines();
+
+	const streamChunksOfRawSource = (source, onChunk, onSource, onName) => {
+		let line = 1;
+		const matches = splitIntoLines(source);
+		let match;
+		for (match of matches) {
+			onChunk(match, line, 0, -1, -1, -1, -1);
+			line++;
+		}
+		return matches.length === 0 || match.endsWith("\n")
+			? {
+					generatedLine: matches.length + 1,
+					generatedColumn: 0
+			  }
+			: {
+					generatedLine: matches.length,
+					generatedColumn: match.length
+			  };
+	};
+
+	streamChunksOfRawSource_1 = (source, onChunk, onSource, onName, finalSource) => {
+		return finalSource
+			? getGeneratedSourceInfo(source)
+			: streamChunksOfRawSource(source, onChunk);
+	};
+	return streamChunksOfRawSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var RawSource_1;
+var hasRequiredRawSource;
+
+function requireRawSource () {
+	if (hasRequiredRawSource) return RawSource_1;
+	hasRequiredRawSource = 1;
+
+	const streamChunksOfRawSource = requireStreamChunksOfRawSource();
+	const Source = requireSource();
+
+	class RawSource extends Source {
+		constructor(value, convertToString = false) {
+			super();
+			const isBuffer = Buffer.isBuffer(value);
+			if (!isBuffer && typeof value !== "string") {
+				throw new TypeError("argument 'value' must be either string of Buffer");
+			}
+			this._valueIsBuffer = !convertToString && isBuffer;
+			this._value = convertToString && isBuffer ? undefined : value;
+			this._valueAsBuffer = isBuffer ? value : undefined;
+			this._valueAsString = isBuffer ? undefined : value;
+		}
+
+		isBuffer() {
+			return this._valueIsBuffer;
+		}
+
+		source() {
+			if (this._value === undefined) {
+				this._value = this._valueAsBuffer.toString("utf-8");
+			}
+			return this._value;
+		}
+
+		buffer() {
+			if (this._valueAsBuffer === undefined) {
+				this._valueAsBuffer = Buffer.from(this._value, "utf-8");
+			}
+			return this._valueAsBuffer;
+		}
+
+		map(options) {
+			return null;
+		}
+
+		/**
+		 * @param {object} options options
+		 * @param {function(string, number, number, number, number, number, number): void} onChunk called for each chunk of code
+		 * @param {function(number, string, string)} onSource called for each source
+		 * @param {function(number, string)} onName called for each name
+		 * @returns {void}
+		 */
+		streamChunks(options, onChunk, onSource, onName) {
+			if (this._value === undefined) {
+				this._value = Buffer.from(this._valueAsBuffer, "utf-8");
+			}
+			if (this._valueAsString === undefined) {
+				this._valueAsString =
+					typeof this._value === "string"
+						? this._value
+						: this._value.toString("utf-8");
+			}
+			return streamChunksOfRawSource(
+				this._valueAsString,
+				onChunk,
+				onSource,
+				onName,
+				!!(options && options.finalSource)
+			);
+		}
+
+		updateHash(hash) {
+			if (this._valueAsBuffer === undefined) {
+				this._valueAsBuffer = Buffer.from(this._value, "utf-8");
+			}
+			hash.update("RawSource");
+			hash.update(this._valueAsBuffer);
+		}
+	}
+
+	RawSource_1 = RawSource;
+	return RawSource_1;
+}
+
+var getFromStreamChunks = {};
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var createMappingsSerializer_1;
+var hasRequiredCreateMappingsSerializer;
+
+function requireCreateMappingsSerializer () {
+	if (hasRequiredCreateMappingsSerializer) return createMappingsSerializer_1;
+	hasRequiredCreateMappingsSerializer = 1;
+
+	const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(
+		""
+	);
+
+	const CONTINUATION_BIT = 0x20;
+
+	const createMappingsSerializer = options => {
+		const linesOnly = options && options.columns === false;
+		return linesOnly
+			? createLinesOnlyMappingsSerializer()
+			: createFullMappingsSerializer();
+	};
+
+	const createFullMappingsSerializer = () => {
+		let currentLine = 1;
+		let currentColumn = 0;
+		let currentSourceIndex = 0;
+		let currentOriginalLine = 1;
+		let currentOriginalColumn = 0;
+		let currentNameIndex = 0;
+		let activeMapping = false;
+		let activeName = false;
+		let initial = true;
+		return (
+			generatedLine,
+			generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			nameIndex
+		) => {
+			if (activeMapping && currentLine === generatedLine) {
+				// A mapping is still active
+				if (
+					sourceIndex === currentSourceIndex &&
+					originalLine === currentOriginalLine &&
+					originalColumn === currentOriginalColumn &&
+					!activeName &&
+					nameIndex < 0
+				) {
+					// avoid repeating the same original mapping
+					return "";
+				}
+			} else {
+				// No mapping is active
+				if (sourceIndex < 0) {
+					// avoid writing unneccessary generated mappings
+					return "";
+				}
+			}
+
+			let str;
+			if (currentLine < generatedLine) {
+				str = ";".repeat(generatedLine - currentLine);
+				currentLine = generatedLine;
+				currentColumn = 0;
+				initial = false;
+			} else if (initial) {
+				str = "";
+				initial = false;
+			} else {
+				str = ",";
+			}
+
+			const writeValue = value => {
+				const sign = (value >>> 31) & 1;
+				const mask = value >> 31;
+				const absValue = (value + mask) ^ mask;
+				let data = (absValue << 1) | sign;
+				for (;;) {
+					const sextet = data & 0x1f;
+					data >>= 5;
+					if (data === 0) {
+						str += ALPHABET[sextet];
+						break;
+					} else {
+						str += ALPHABET[sextet | CONTINUATION_BIT];
+					}
+				}
+			};
+			writeValue(generatedColumn - currentColumn);
+			currentColumn = generatedColumn;
+			if (sourceIndex >= 0) {
+				activeMapping = true;
+				if (sourceIndex === currentSourceIndex) {
+					str += "A";
+				} else {
+					writeValue(sourceIndex - currentSourceIndex);
+					currentSourceIndex = sourceIndex;
+				}
+				writeValue(originalLine - currentOriginalLine);
+				currentOriginalLine = originalLine;
+				if (originalColumn === currentOriginalColumn) {
+					str += "A";
+				} else {
+					writeValue(originalColumn - currentOriginalColumn);
+					currentOriginalColumn = originalColumn;
+				}
+				if (nameIndex >= 0) {
+					writeValue(nameIndex - currentNameIndex);
+					currentNameIndex = nameIndex;
+					activeName = true;
+				} else {
+					activeName = false;
+				}
+			} else {
+				activeMapping = false;
+			}
+			return str;
+		};
+	};
+
+	const createLinesOnlyMappingsSerializer = () => {
+		let lastWrittenLine = 0;
+		let currentLine = 1;
+		let currentSourceIndex = 0;
+		let currentOriginalLine = 1;
+		return (
+			generatedLine,
+			_generatedColumn,
+			sourceIndex,
+			originalLine,
+			_originalColumn,
+			_nameIndex
+		) => {
+			if (sourceIndex < 0) {
+				// avoid writing generated mappings at all
+				return "";
+			}
+			if (lastWrittenLine === generatedLine) {
+				// avoid writing multiple original mappings per line
+				return "";
+			}
+			let str;
+			const writeValue = value => {
+				const sign = (value >>> 31) & 1;
+				const mask = value >> 31;
+				const absValue = (value + mask) ^ mask;
+				let data = (absValue << 1) | sign;
+				for (;;) {
+					const sextet = data & 0x1f;
+					data >>= 5;
+					if (data === 0) {
+						str += ALPHABET[sextet];
+						break;
+					} else {
+						str += ALPHABET[sextet | CONTINUATION_BIT];
+					}
+				}
+			};
+			lastWrittenLine = generatedLine;
+			if (generatedLine === currentLine + 1) {
+				currentLine = generatedLine;
+				if (sourceIndex === currentSourceIndex) {
+					currentSourceIndex = sourceIndex;
+					if (originalLine === currentOriginalLine + 1) {
+						currentOriginalLine = originalLine;
+						return ";AACA";
+					} else {
+						str = ";AA";
+						writeValue(originalLine - currentOriginalLine);
+						currentOriginalLine = originalLine;
+						return str + "A";
+					}
+				} else {
+					str = ";A";
+					writeValue(sourceIndex - currentSourceIndex);
+					currentSourceIndex = sourceIndex;
+					writeValue(originalLine - currentOriginalLine);
+					currentOriginalLine = originalLine;
+					return str + "A";
+				}
+			} else {
+				str = ";".repeat(generatedLine - currentLine);
+				currentLine = generatedLine;
+				if (sourceIndex === currentSourceIndex) {
+					currentSourceIndex = sourceIndex;
+					if (originalLine === currentOriginalLine + 1) {
+						currentOriginalLine = originalLine;
+						return str + "AACA";
+					} else {
+						str += "AA";
+						writeValue(originalLine - currentOriginalLine);
+						currentOriginalLine = originalLine;
+						return str + "A";
+					}
+				} else {
+					str += "A";
+					writeValue(sourceIndex - currentSourceIndex);
+					currentSourceIndex = sourceIndex;
+					writeValue(originalLine - currentOriginalLine);
+					currentOriginalLine = originalLine;
+					return str + "A";
+				}
+			}
+		};
+	};
+
+	createMappingsSerializer_1 = createMappingsSerializer;
+	return createMappingsSerializer_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var hasRequiredGetFromStreamChunks;
+
+function requireGetFromStreamChunks () {
+	if (hasRequiredGetFromStreamChunks) return getFromStreamChunks;
+	hasRequiredGetFromStreamChunks = 1;
+
+	const createMappingsSerializer = requireCreateMappingsSerializer();
+
+	getFromStreamChunks.getSourceAndMap = (inputSource, options) => {
+		let code = "";
+		let mappings = "";
+		let sources = [];
+		let sourcesContent = [];
+		let names = [];
+		const addMapping = createMappingsSerializer(options);
+		const { source } = inputSource.streamChunks(
+			Object.assign({}, options, { finalSource: true }),
+			(
+				chunk,
+				generatedLine,
+				generatedColumn,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				nameIndex
+			) => {
+				if (chunk !== undefined) code += chunk;
+				mappings += addMapping(
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex
+				);
+			},
+			(sourceIndex, source, sourceContent) => {
+				while (sources.length < sourceIndex) {
+					sources.push(null);
+				}
+				sources[sourceIndex] = source;
+				if (sourceContent !== undefined) {
+					while (sourcesContent.length < sourceIndex) {
+						sourcesContent.push(null);
+					}
+					sourcesContent[sourceIndex] = sourceContent;
+				}
+			},
+			(nameIndex, name) => {
+				while (names.length < nameIndex) {
+					names.push(null);
+				}
+				names[nameIndex] = name;
+			}
+		);
+		return {
+			source: source !== undefined ? source : code,
+			map:
+				mappings.length > 0
+					? {
+							version: 3,
+							file: "x",
+							mappings,
+							sources,
+							sourcesContent:
+								sourcesContent.length > 0 ? sourcesContent : undefined,
+							names
+					  }
+					: null
+		};
+	};
+
+	getFromStreamChunks.getMap = (source, options) => {
+		let mappings = "";
+		let sources = [];
+		let sourcesContent = [];
+		let names = [];
+		const addMapping = createMappingsSerializer(options);
+		source.streamChunks(
+			Object.assign({}, options, { source: false, finalSource: true }),
+			(
+				chunk,
+				generatedLine,
+				generatedColumn,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				nameIndex
+			) => {
+				mappings += addMapping(
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex
+				);
+			},
+			(sourceIndex, source, sourceContent) => {
+				while (sources.length < sourceIndex) {
+					sources.push(null);
+				}
+				sources[sourceIndex] = source;
+				if (sourceContent !== undefined) {
+					while (sourcesContent.length < sourceIndex) {
+						sourcesContent.push(null);
+					}
+					sourcesContent[sourceIndex] = sourceContent;
+				}
+			},
+			(nameIndex, name) => {
+				while (names.length < nameIndex) {
+					names.push(null);
+				}
+				names[nameIndex] = name;
+			}
+		);
+		return mappings.length > 0
+			? {
+					version: 3,
+					file: "x",
+					mappings,
+					sources,
+					sourcesContent: sourcesContent.length > 0 ? sourcesContent : undefined,
+					names
+			  }
+			: null;
+	};
+	return getFromStreamChunks;
+}
+
+var splitIntoPotentialTokens_1;
+var hasRequiredSplitIntoPotentialTokens;
+
+function requireSplitIntoPotentialTokens () {
+	if (hasRequiredSplitIntoPotentialTokens) return splitIntoPotentialTokens_1;
+	hasRequiredSplitIntoPotentialTokens = 1;
+	// \n = 10
+	// ; = 59
+	// { = 123
+	// } = 125
+	// <space> = 32
+	// \r = 13
+	// \t = 9
+
+	const splitIntoPotentialTokens = str => {
+		const len = str.length;
+		if (len === 0) return null;
+		const results = [];
+		let i = 0;
+		for (; i < len; ) {
+			const s = i;
+			block: {
+				let cc = str.charCodeAt(i);
+				while (cc !== 10 && cc !== 59 && cc !== 123 && cc !== 125) {
+					if (++i >= len) break block;
+					cc = str.charCodeAt(i);
+				}
+				while (
+					cc === 59 ||
+					cc === 32 ||
+					cc === 123 ||
+					cc === 125 ||
+					cc === 13 ||
+					cc === 9
+				) {
+					if (++i >= len) break block;
+					cc = str.charCodeAt(i);
+				}
+				if (cc === 10) {
+					i++;
+				}
+			}
+			results.push(str.slice(s, i));
+		}
+		return results;
+	};
+	splitIntoPotentialTokens_1 = splitIntoPotentialTokens;
+	return splitIntoPotentialTokens_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var OriginalSource_1;
+var hasRequiredOriginalSource;
+
+function requireOriginalSource () {
+	if (hasRequiredOriginalSource) return OriginalSource_1;
+	hasRequiredOriginalSource = 1;
+
+	const { getMap, getSourceAndMap } = requireGetFromStreamChunks();
+	const splitIntoLines = requireSplitIntoLines();
+	const getGeneratedSourceInfo = requireGetGeneratedSourceInfo();
+	const Source = requireSource();
+	const splitIntoPotentialTokens = requireSplitIntoPotentialTokens();
+
+	class OriginalSource extends Source {
+		constructor(value, name) {
+			super();
+			const isBuffer = Buffer.isBuffer(value);
+			this._value = isBuffer ? undefined : value;
+			this._valueAsBuffer = isBuffer ? value : undefined;
+			this._name = name;
+		}
+
+		getName() {
+			return this._name;
+		}
+
+		source() {
+			if (this._value === undefined) {
+				this._value = this._valueAsBuffer.toString("utf-8");
+			}
+			return this._value;
+		}
+
+		buffer() {
+			if (this._valueAsBuffer === undefined) {
+				this._valueAsBuffer = Buffer.from(this._value, "utf-8");
+			}
+			return this._valueAsBuffer;
+		}
+
+		map(options) {
+			return getMap(this, options);
+		}
+
+		sourceAndMap(options) {
+			return getSourceAndMap(this, options);
+		}
+
+		/**
+		 * @param {object} options options
+		 * @param {function(string, number, number, number, number, number, number): void} onChunk called for each chunk of code
+		 * @param {function(number, string, string)} onSource called for each source
+		 * @param {function(number, string)} onName called for each name
+		 * @returns {void}
+		 */
+		streamChunks(options, onChunk, onSource, onName) {
+			if (this._value === undefined) {
+				this._value = this._valueAsBuffer.toString("utf-8");
+			}
+			onSource(0, this._name, this._value);
+			const finalSource = !!(options && options.finalSource);
+			if (!options || options.columns !== false) {
+				// With column info we need to read all lines and split them
+				const matches = splitIntoPotentialTokens(this._value);
+				let line = 1;
+				let column = 0;
+				if (matches !== null) {
+					for (const match of matches) {
+						const isEndOfLine = match.endsWith("\n");
+						if (isEndOfLine && match.length === 1) {
+							if (!finalSource) onChunk(match, line, column, -1, -1, -1, -1);
+						} else {
+							const chunk = finalSource ? undefined : match;
+							onChunk(chunk, line, column, 0, line, column, -1);
+						}
+						if (isEndOfLine) {
+							line++;
+							column = 0;
+						} else {
+							column += match.length;
+						}
+					}
+				}
+				return {
+					generatedLine: line,
+					generatedColumn: column,
+					source: finalSource ? this._value : undefined
+				};
+			} else if (finalSource) {
+				// Without column info and with final source we only
+				// need meta info to generate mapping
+				const result = getGeneratedSourceInfo(this._value);
+				const { generatedLine, generatedColumn } = result;
+				if (generatedColumn === 0) {
+					for (let line = 1; line < generatedLine; line++)
+						onChunk(undefined, line, 0, 0, line, 0, -1);
+				} else {
+					for (let line = 1; line <= generatedLine; line++)
+						onChunk(undefined, line, 0, 0, line, 0, -1);
+				}
+				return result;
+			} else {
+				// Without column info, but also without final source
+				// we need to split source by lines
+				let line = 1;
+				const matches = splitIntoLines(this._value);
+				let match;
+				for (match of matches) {
+					onChunk(finalSource ? undefined : match, line, 0, 0, line, 0, -1);
+					line++;
+				}
+				return matches.length === 0 || match.endsWith("\n")
+					? {
+							generatedLine: matches.length + 1,
+							generatedColumn: 0,
+							source: finalSource ? this._value : undefined
+					  }
+					: {
+							generatedLine: matches.length,
+							generatedColumn: match.length,
+							source: finalSource ? this._value : undefined
+					  };
+			}
+		}
+
+		updateHash(hash) {
+			if (this._valueAsBuffer === undefined) {
+				this._valueAsBuffer = Buffer.from(this._value, "utf-8");
+			}
+			hash.update("OriginalSource");
+			hash.update(this._valueAsBuffer);
+			hash.update(this._name || "");
+		}
+	}
+
+	OriginalSource_1 = OriginalSource;
+	return OriginalSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var getSource_1;
+var hasRequiredGetSource;
+
+function requireGetSource () {
+	if (hasRequiredGetSource) return getSource_1;
+	hasRequiredGetSource = 1;
+
+	const getSource = (sourceMap, index) => {
+		if (index < 0) return null;
+		const { sourceRoot, sources } = sourceMap;
+		const source = sources[index];
+		if (!sourceRoot) return source;
+		if (sourceRoot.endsWith("/")) return sourceRoot + source;
+		return sourceRoot + "/" + source;
+	};
+
+	getSource_1 = getSource;
+	return getSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var readMappings_1;
+var hasRequiredReadMappings;
+
+function requireReadMappings () {
+	if (hasRequiredReadMappings) return readMappings_1;
+	hasRequiredReadMappings = 1;
+
+	const ALPHABET =
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+	const CONTINUATION_BIT = 0x20;
+	const END_SEGMENT_BIT = 0x40;
+	const NEXT_LINE = END_SEGMENT_BIT | 0x01;
+	const INVALID = END_SEGMENT_BIT | 0x02;
+	const DATA_MASK = 0x1f;
+
+	const ccToValue = new Uint8Array("z".charCodeAt(0) + 1);
+	{
+		ccToValue.fill(INVALID);
+		for (let i = 0; i < ALPHABET.length; i++) {
+			ccToValue[ALPHABET.charCodeAt(i)] = i;
+		}
+		ccToValue[",".charCodeAt(0)] = END_SEGMENT_BIT;
+		ccToValue[";".charCodeAt(0)] = NEXT_LINE;
+	}
+	const ccMax = ccToValue.length - 1;
+
+	/**
+	 * @param {string} mappings the mappings string
+	 * @param {function(number, number, number, number, number, number): void} onMapping called for each mapping
+	 * @returns {void}
+	 */
+	const readMappings = (mappings, onMapping) => {
+		// generatedColumn, [sourceIndex, originalLine, orignalColumn, [nameIndex]]
+		const currentData = new Uint32Array([0, 0, 1, 0, 0]);
+		let currentDataPos = 0;
+		// currentValue will include a sign bit at bit 0
+		let currentValue = 0;
+		let currentValuePos = 0;
+		let generatedLine = 1;
+		let generatedColumn = -1;
+		for (let i = 0; i < mappings.length; i++) {
+			const cc = mappings.charCodeAt(i);
+			if (cc > ccMax) continue;
+			const value = ccToValue[cc];
+			if ((value & END_SEGMENT_BIT) !== 0) {
+				// End current segment
+				if (currentData[0] > generatedColumn) {
+					if (currentDataPos === 1) {
+						onMapping(generatedLine, currentData[0], -1, -1, -1, -1);
+					} else if (currentDataPos === 4) {
+						onMapping(
+							generatedLine,
+							currentData[0],
+							currentData[1],
+							currentData[2],
+							currentData[3],
+							-1
+						);
+					} else if (currentDataPos === 5) {
+						onMapping(
+							generatedLine,
+							currentData[0],
+							currentData[1],
+							currentData[2],
+							currentData[3],
+							currentData[4]
+						);
+					}
+					generatedColumn = currentData[0];
+				}
+				currentDataPos = 0;
+				if (value === NEXT_LINE) {
+					// Start new line
+					generatedLine++;
+					currentData[0] = 0;
+					generatedColumn = -1;
+				}
+			} else if ((value & CONTINUATION_BIT) === 0) {
+				// last sextet
+				currentValue |= value << currentValuePos;
+				const finalValue =
+					currentValue & 1 ? -(currentValue >> 1) : currentValue >> 1;
+				currentData[currentDataPos++] += finalValue;
+				currentValuePos = 0;
+				currentValue = 0;
+			} else {
+				currentValue |= (value & DATA_MASK) << currentValuePos;
+				currentValuePos += 5;
+			}
+		}
+		// End current segment
+		if (currentDataPos === 1) {
+			onMapping(generatedLine, currentData[0], -1, -1, -1, -1);
+		} else if (currentDataPos === 4) {
+			onMapping(
+				generatedLine,
+				currentData[0],
+				currentData[1],
+				currentData[2],
+				currentData[3],
+				-1
+			);
+		} else if (currentDataPos === 5) {
+			onMapping(
+				generatedLine,
+				currentData[0],
+				currentData[1],
+				currentData[2],
+				currentData[3],
+				currentData[4]
+			);
+		}
+	};
+
+	readMappings_1 = readMappings;
+	return readMappings_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var streamChunksOfSourceMap;
+var hasRequiredStreamChunksOfSourceMap;
+
+function requireStreamChunksOfSourceMap () {
+	if (hasRequiredStreamChunksOfSourceMap) return streamChunksOfSourceMap;
+	hasRequiredStreamChunksOfSourceMap = 1;
+
+	const getGeneratedSourceInfo = requireGetGeneratedSourceInfo();
+	const getSource = requireGetSource();
+	const readMappings = requireReadMappings();
+	const splitIntoLines = requireSplitIntoLines();
+
+	const streamChunksOfSourceMapFull = (
+		source,
+		sourceMap,
+		onChunk,
+		onSource,
+		onName
+	) => {
+		const lines = splitIntoLines(source);
+		if (lines.length === 0) {
+			return {
+				generatedLine: 1,
+				generatedColumn: 0
+			};
+		}
+		const { sources, sourcesContent, names, mappings } = sourceMap;
+		for (let i = 0; i < sources.length; i++) {
+			onSource(
+				i,
+				getSource(sourceMap, i),
+				(sourcesContent && sourcesContent[i]) || undefined
+			);
+		}
+		if (names) {
+			for (let i = 0; i < names.length; i++) {
+				onName(i, names[i]);
+			}
+		}
+
+		const lastLine = lines[lines.length - 1];
+		const lastNewLine = lastLine.endsWith("\n");
+		const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+		const finalColumn = lastNewLine ? 0 : lastLine.length;
+
+		let currentGeneratedLine = 1;
+		let currentGeneratedColumn = 0;
+
+		let mappingActive = false;
+		let activeMappingSourceIndex = -1;
+		let activeMappingOriginalLine = -1;
+		let activeMappingOriginalColumn = -1;
+		let activeMappingNameIndex = -1;
+
+		const onMapping = (
+			generatedLine,
+			generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			nameIndex
+		) => {
+			if (mappingActive && currentGeneratedLine <= lines.length) {
+				let chunk;
+				const mappingLine = currentGeneratedLine;
+				const mappingColumn = currentGeneratedColumn;
+				const line = lines[currentGeneratedLine - 1];
+				if (generatedLine !== currentGeneratedLine) {
+					chunk = line.slice(currentGeneratedColumn);
+					currentGeneratedLine++;
+					currentGeneratedColumn = 0;
+				} else {
+					chunk = line.slice(currentGeneratedColumn, generatedColumn);
+					currentGeneratedColumn = generatedColumn;
+				}
+				if (chunk) {
+					onChunk(
+						chunk,
+						mappingLine,
+						mappingColumn,
+						activeMappingSourceIndex,
+						activeMappingOriginalLine,
+						activeMappingOriginalColumn,
+						activeMappingNameIndex
+					);
+				}
+				mappingActive = false;
+			}
+			if (generatedLine > currentGeneratedLine && currentGeneratedColumn > 0) {
+				if (currentGeneratedLine <= lines.length) {
+					const chunk = lines[currentGeneratedLine - 1].slice(
+						currentGeneratedColumn
+					);
+					onChunk(
+						chunk,
+						currentGeneratedLine,
+						currentGeneratedColumn,
+						-1,
+						-1,
+						-1,
+						-1
+					);
+				}
+				currentGeneratedLine++;
+				currentGeneratedColumn = 0;
+			}
+			while (generatedLine > currentGeneratedLine) {
+				if (currentGeneratedLine <= lines.length) {
+					onChunk(
+						lines[currentGeneratedLine - 1],
+						currentGeneratedLine,
+						0,
+						-1,
+						-1,
+						-1,
+						-1
+					);
+				}
+				currentGeneratedLine++;
+			}
+			if (generatedColumn > currentGeneratedColumn) {
+				if (currentGeneratedLine <= lines.length) {
+					const chunk = lines[currentGeneratedLine - 1].slice(
+						currentGeneratedColumn,
+						generatedColumn
+					);
+					onChunk(
+						chunk,
+						currentGeneratedLine,
+						currentGeneratedColumn,
+						-1,
+						-1,
+						-1,
+						-1
+					);
+				}
+				currentGeneratedColumn = generatedColumn;
+			}
+			if (
+				sourceIndex >= 0 &&
+				(generatedLine < finalLine ||
+					(generatedLine === finalLine && generatedColumn < finalColumn))
+			) {
+				mappingActive = true;
+				activeMappingSourceIndex = sourceIndex;
+				activeMappingOriginalLine = originalLine;
+				activeMappingOriginalColumn = originalColumn;
+				activeMappingNameIndex = nameIndex;
+			}
+		};
+		readMappings(mappings, onMapping);
+		onMapping(finalLine, finalColumn, -1, -1, -1, -1);
+		return {
+			generatedLine: finalLine,
+			generatedColumn: finalColumn
+		};
+	};
+
+	const streamChunksOfSourceMapLinesFull = (
+		source,
+		sourceMap,
+		onChunk,
+		onSource,
+		_onName
+	) => {
+		const lines = splitIntoLines(source);
+		if (lines.length === 0) {
+			return {
+				generatedLine: 1,
+				generatedColumn: 0
+			};
+		}
+		const { sources, sourcesContent, mappings } = sourceMap;
+		for (let i = 0; i < sources.length; i++) {
+			onSource(
+				i,
+				getSource(sourceMap, i),
+				(sourcesContent && sourcesContent[i]) || undefined
+			);
+		}
+
+		let currentGeneratedLine = 1;
+
+		const onMapping = (
+			generatedLine,
+			_generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			_nameIndex
+		) => {
+			if (
+				sourceIndex < 0 ||
+				generatedLine < currentGeneratedLine ||
+				generatedLine > lines.length
+			) {
+				return;
+			}
+			while (generatedLine > currentGeneratedLine) {
+				if (currentGeneratedLine <= lines.length) {
+					onChunk(
+						lines[currentGeneratedLine - 1],
+						currentGeneratedLine,
+						0,
+						-1,
+						-1,
+						-1,
+						-1
+					);
+				}
+				currentGeneratedLine++;
+			}
+			if (generatedLine <= lines.length) {
+				onChunk(
+					lines[generatedLine - 1],
+					generatedLine,
+					0,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					-1
+				);
+				currentGeneratedLine++;
+			}
+		};
+		readMappings(mappings, onMapping);
+		for (; currentGeneratedLine <= lines.length; currentGeneratedLine++) {
+			onChunk(
+				lines[currentGeneratedLine - 1],
+				currentGeneratedLine,
+				0,
+				-1,
+				-1,
+				-1,
+				-1
+			);
+		}
+
+		const lastLine = lines[lines.length - 1];
+		const lastNewLine = lastLine.endsWith("\n");
+
+		const finalLine = lastNewLine ? lines.length + 1 : lines.length;
+		const finalColumn = lastNewLine ? 0 : lastLine.length;
+
+		return {
+			generatedLine: finalLine,
+			generatedColumn: finalColumn
+		};
+	};
+
+	const streamChunksOfSourceMapFinal = (
+		source,
+		sourceMap,
+		onChunk,
+		onSource,
+		onName
+	) => {
+		const result = getGeneratedSourceInfo(source);
+		const { generatedLine: finalLine, generatedColumn: finalColumn } = result;
+
+		if (finalLine === 1 && finalColumn === 0) return result;
+		const { sources, sourcesContent, names, mappings } = sourceMap;
+		for (let i = 0; i < sources.length; i++) {
+			onSource(
+				i,
+				getSource(sourceMap, i),
+				(sourcesContent && sourcesContent[i]) || undefined
+			);
+		}
+		if (names) {
+			for (let i = 0; i < names.length; i++) {
+				onName(i, names[i]);
+			}
+		}
+
+		let mappingActiveLine = 0;
+
+		const onMapping = (
+			generatedLine,
+			generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			nameIndex
+		) => {
+			if (
+				generatedLine >= finalLine &&
+				(generatedColumn >= finalColumn || generatedLine > finalLine)
+			) {
+				return;
+			}
+			if (sourceIndex >= 0) {
+				onChunk(
+					undefined,
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex
+				);
+				mappingActiveLine = generatedLine;
+			} else if (mappingActiveLine === generatedLine) {
+				onChunk(undefined, generatedLine, generatedColumn, -1, -1, -1, -1);
+				mappingActiveLine = 0;
+			}
+		};
+		readMappings(mappings, onMapping);
+		return result;
+	};
+
+	const streamChunksOfSourceMapLinesFinal = (
+		source,
+		sourceMap,
+		onChunk,
+		onSource,
+		_onName
+	) => {
+		const result = getGeneratedSourceInfo(source);
+		const { generatedLine, generatedColumn } = result;
+		if (generatedLine === 1 && generatedColumn === 0) {
+			return {
+				generatedLine: 1,
+				generatedColumn: 0
+			};
+		}
+
+		const { sources, sourcesContent, mappings } = sourceMap;
+		for (let i = 0; i < sources.length; i++) {
+			onSource(
+				i,
+				getSource(sourceMap, i),
+				(sourcesContent && sourcesContent[i]) || undefined
+			);
+		}
+
+		const finalLine = generatedColumn === 0 ? generatedLine - 1 : generatedLine;
+
+		let currentGeneratedLine = 1;
+
+		const onMapping = (
+			generatedLine,
+			_generatedColumn,
+			sourceIndex,
+			originalLine,
+			originalColumn,
+			_nameIndex
+		) => {
+			if (
+				sourceIndex >= 0 &&
+				currentGeneratedLine <= generatedLine &&
+				generatedLine <= finalLine
+			) {
+				onChunk(
+					undefined,
+					generatedLine,
+					0,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					-1
+				);
+				currentGeneratedLine = generatedLine + 1;
+			}
+		};
+		readMappings(mappings, onMapping);
+		return result;
+	};
+
+	streamChunksOfSourceMap = (
+		source,
+		sourceMap,
+		onChunk,
+		onSource,
+		onName,
+		finalSource,
+		columns
+	) => {
+		if (columns) {
+			return finalSource
+				? streamChunksOfSourceMapFinal(
+						source,
+						sourceMap,
+						onChunk,
+						onSource,
+						onName
+				  )
+				: streamChunksOfSourceMapFull(
+						source,
+						sourceMap,
+						onChunk,
+						onSource,
+						onName
+				  );
+		} else {
+			return finalSource
+				? streamChunksOfSourceMapLinesFinal(
+						source,
+						sourceMap,
+						onChunk,
+						onSource)
+				: streamChunksOfSourceMapLinesFull(
+						source,
+						sourceMap,
+						onChunk,
+						onSource);
+		}
+	};
+	return streamChunksOfSourceMap;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var streamChunksOfCombinedSourceMap_1;
+var hasRequiredStreamChunksOfCombinedSourceMap;
+
+function requireStreamChunksOfCombinedSourceMap () {
+	if (hasRequiredStreamChunksOfCombinedSourceMap) return streamChunksOfCombinedSourceMap_1;
+	hasRequiredStreamChunksOfCombinedSourceMap = 1;
+
+	const streamChunksOfSourceMap = requireStreamChunksOfSourceMap();
+	const splitIntoLines = requireSplitIntoLines();
+
+	const streamChunksOfCombinedSourceMap = (
+		source,
+		sourceMap,
+		innerSourceName,
+		innerSource,
+		innerSourceMap,
+		removeInnerSource,
+		onChunk,
+		onSource,
+		onName,
+		finalSource,
+		columns
+	) => {
+		let sourceMapping = new Map();
+		let nameMapping = new Map();
+		const sourceIndexMapping = [];
+		const nameIndexMapping = [];
+		const nameIndexValueMapping = [];
+		let innerSourceIndex = -2;
+		const innerSourceIndexMapping = [];
+		const innerSourceIndexValueMapping = [];
+		const innerSourceContents = [];
+		const innerSourceContentLines = [];
+		const innerNameIndexMapping = [];
+		const innerNameIndexValueMapping = [];
+		const innerSourceMapLineData = [];
+		const findInnerMapping = (line, column) => {
+			if (line > innerSourceMapLineData.length) return -1;
+			const { mappingsData } = innerSourceMapLineData[line - 1];
+			let l = 0;
+			let r = mappingsData.length / 5;
+			while (l < r) {
+				let m = (l + r) >> 1;
+				if (mappingsData[m * 5] <= column) {
+					l = m + 1;
+				} else {
+					r = m;
+				}
+			}
+			if (l === 0) return -1;
+			return l - 1;
+		};
+		return streamChunksOfSourceMap(
+			source,
+			sourceMap,
+			(
+				chunk,
+				generatedLine,
+				generatedColumn,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				nameIndex
+			) => {
+				// Check if this is a mapping to the inner source
+				if (sourceIndex === innerSourceIndex) {
+					// Check if there is a mapping in the inner source
+					const idx = findInnerMapping(originalLine, originalColumn);
+					if (idx !== -1) {
+						const { chunks, mappingsData } = innerSourceMapLineData[
+							originalLine - 1
+						];
+						const mi = idx * 5;
+						const innerSourceIndex = mappingsData[mi + 1];
+						const innerOriginalLine = mappingsData[mi + 2];
+						let innerOriginalColumn = mappingsData[mi + 3];
+						let innerNameIndex = mappingsData[mi + 4];
+						if (innerSourceIndex >= 0) {
+							// Check for an identity mapping
+							// where we are allowed to adjust the original column
+							const innerChunk = chunks[idx];
+							const innerGeneratedColumn = mappingsData[mi];
+							const locationInChunk = originalColumn - innerGeneratedColumn;
+							if (locationInChunk > 0) {
+								let originalSourceLines =
+									innerSourceIndex < innerSourceContentLines.length
+										? innerSourceContentLines[innerSourceIndex]
+										: null;
+								if (originalSourceLines === undefined) {
+									const originalSource = innerSourceContents[innerSourceIndex];
+									originalSourceLines = originalSource
+										? splitIntoLines(originalSource)
+										: null;
+									innerSourceContentLines[innerSourceIndex] = originalSourceLines;
+								}
+								if (originalSourceLines !== null) {
+									const originalChunk =
+										innerOriginalLine <= originalSourceLines.length
+											? originalSourceLines[innerOriginalLine - 1].slice(
+													innerOriginalColumn,
+													innerOriginalColumn + locationInChunk
+											  )
+											: "";
+									if (innerChunk.slice(0, locationInChunk) === originalChunk) {
+										innerOriginalColumn += locationInChunk;
+										innerNameIndex = -1;
+									}
+								}
+							}
+
+							// We have a inner mapping to original source
+
+							// emit source when needed and compute global source index
+							let sourceIndex =
+								innerSourceIndex < innerSourceIndexMapping.length
+									? innerSourceIndexMapping[innerSourceIndex]
+									: -2;
+							if (sourceIndex === -2) {
+								const [source, sourceContent] =
+									innerSourceIndex < innerSourceIndexValueMapping.length
+										? innerSourceIndexValueMapping[innerSourceIndex]
+										: [null, undefined];
+								let globalIndex = sourceMapping.get(source);
+								if (globalIndex === undefined) {
+									sourceMapping.set(source, (globalIndex = sourceMapping.size));
+									onSource(globalIndex, source, sourceContent);
+								}
+								sourceIndex = globalIndex;
+								innerSourceIndexMapping[innerSourceIndex] = sourceIndex;
+							}
+
+							// emit name when needed and compute global name index
+							let finalNameIndex = -1;
+							if (innerNameIndex >= 0) {
+								// when we have a inner name
+								finalNameIndex =
+									innerNameIndex < innerNameIndexMapping.length
+										? innerNameIndexMapping[innerNameIndex]
+										: -2;
+								if (finalNameIndex === -2) {
+									const name =
+										innerNameIndex < innerNameIndexValueMapping.length
+											? innerNameIndexValueMapping[innerNameIndex]
+											: undefined;
+									if (name) {
+										let globalIndex = nameMapping.get(name);
+										if (globalIndex === undefined) {
+											nameMapping.set(name, (globalIndex = nameMapping.size));
+											onName(globalIndex, name);
+										}
+										finalNameIndex = globalIndex;
+									} else {
+										finalNameIndex = -1;
+									}
+									innerNameIndexMapping[innerNameIndex] = finalNameIndex;
+								}
+							} else if (nameIndex >= 0) {
+								// when we don't have an inner name,
+								// but we have an outer name
+								// it can be used when inner original code equals to the name
+								let originalSourceLines =
+									innerSourceContentLines[innerSourceIndex];
+								if (originalSourceLines === undefined) {
+									const originalSource = innerSourceContents[innerSourceIndex];
+									originalSourceLines = originalSource
+										? splitIntoLines(originalSource)
+										: null;
+									innerSourceContentLines[innerSourceIndex] = originalSourceLines;
+								}
+								if (originalSourceLines !== null) {
+									const name = nameIndexValueMapping[nameIndex];
+									const originalName =
+										innerOriginalLine <= originalSourceLines.length
+											? originalSourceLines[innerOriginalLine - 1].slice(
+													innerOriginalColumn,
+													innerOriginalColumn + name.length
+											  )
+											: "";
+									if (name === originalName) {
+										finalNameIndex =
+											nameIndex < nameIndexMapping.length
+												? nameIndexMapping[nameIndex]
+												: -2;
+										if (finalNameIndex === -2) {
+											const name = nameIndexValueMapping[nameIndex];
+											if (name) {
+												let globalIndex = nameMapping.get(name);
+												if (globalIndex === undefined) {
+													nameMapping.set(name, (globalIndex = nameMapping.size));
+													onName(globalIndex, name);
+												}
+												finalNameIndex = globalIndex;
+											} else {
+												finalNameIndex = -1;
+											}
+											nameIndexMapping[nameIndex] = finalNameIndex;
+										}
+									}
+								}
+							}
+							onChunk(
+								chunk,
+								generatedLine,
+								generatedColumn,
+								sourceIndex,
+								innerOriginalLine,
+								innerOriginalColumn,
+								finalNameIndex
+							);
+							return;
+						}
+					}
+
+					// We have a mapping to the inner source, but no inner mapping
+					if (removeInnerSource) {
+						onChunk(chunk, generatedLine, generatedColumn, -1, -1, -1, -1);
+						return;
+					} else {
+						if (sourceIndexMapping[sourceIndex] === -2) {
+							let globalIndex = sourceMapping.get(innerSourceName);
+							if (globalIndex === undefined) {
+								sourceMapping.set(source, (globalIndex = sourceMapping.size));
+								onSource(globalIndex, innerSourceName, innerSource);
+							}
+							sourceIndexMapping[sourceIndex] = globalIndex;
+						}
+					}
+				}
+
+				const finalSourceIndex =
+					sourceIndex < 0 || sourceIndex >= sourceIndexMapping.length
+						? -1
+						: sourceIndexMapping[sourceIndex];
+				if (finalSourceIndex < 0) {
+					// no source, so we make it a generated chunk
+					onChunk(chunk, generatedLine, generatedColumn, -1, -1, -1, -1);
+				} else {
+					// Pass through the chunk with mapping
+					let finalNameIndex = -1;
+					if (nameIndex >= 0 && nameIndex < nameIndexMapping.length) {
+						finalNameIndex = nameIndexMapping[nameIndex];
+						if (finalNameIndex === -2) {
+							const name = nameIndexValueMapping[nameIndex];
+							let globalIndex = nameMapping.get(name);
+							if (globalIndex === undefined) {
+								nameMapping.set(name, (globalIndex = nameMapping.size));
+								onName(globalIndex, name);
+							}
+							finalNameIndex = globalIndex;
+							nameIndexMapping[nameIndex] = finalNameIndex;
+						}
+					}
+					onChunk(
+						chunk,
+						generatedLine,
+						generatedColumn,
+						finalSourceIndex,
+						originalLine,
+						originalColumn,
+						finalNameIndex
+					);
+				}
+			},
+			(i, source, sourceContent) => {
+				if (source === innerSourceName) {
+					innerSourceIndex = i;
+					if (innerSource !== undefined) sourceContent = innerSource;
+					else innerSource = sourceContent;
+					sourceIndexMapping[i] = -2;
+					streamChunksOfSourceMap(
+						sourceContent,
+						innerSourceMap,
+						(
+							chunk,
+							generatedLine,
+							generatedColumn,
+							sourceIndex,
+							originalLine,
+							originalColumn,
+							nameIndex
+						) => {
+							while (innerSourceMapLineData.length < generatedLine) {
+								innerSourceMapLineData.push({
+									mappingsData: [],
+									chunks: []
+								});
+							}
+							const data = innerSourceMapLineData[generatedLine - 1];
+							data.mappingsData.push(
+								generatedColumn,
+								sourceIndex,
+								originalLine,
+								originalColumn,
+								nameIndex
+							);
+							data.chunks.push(chunk);
+						},
+						(i, source, sourceContent) => {
+							innerSourceContents[i] = sourceContent;
+							innerSourceContentLines[i] = undefined;
+							innerSourceIndexMapping[i] = -2;
+							innerSourceIndexValueMapping[i] = [source, sourceContent];
+						},
+						(i, name) => {
+							innerNameIndexMapping[i] = -2;
+							innerNameIndexValueMapping[i] = name;
+						},
+						false,
+						columns
+					);
+				} else {
+					let globalIndex = sourceMapping.get(source);
+					if (globalIndex === undefined) {
+						sourceMapping.set(source, (globalIndex = sourceMapping.size));
+						onSource(globalIndex, source, sourceContent);
+					}
+					sourceIndexMapping[i] = globalIndex;
+				}
+			},
+			(i, name) => {
+				nameIndexMapping[i] = -2;
+				nameIndexValueMapping[i] = name;
+			},
+			finalSource,
+			columns
+		);
+	};
+
+	streamChunksOfCombinedSourceMap_1 = streamChunksOfCombinedSourceMap;
+	return streamChunksOfCombinedSourceMap_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var SourceMapSource_1;
+var hasRequiredSourceMapSource;
+
+function requireSourceMapSource () {
+	if (hasRequiredSourceMapSource) return SourceMapSource_1;
+	hasRequiredSourceMapSource = 1;
+
+	const Source = requireSource();
+	const streamChunksOfSourceMap = requireStreamChunksOfSourceMap();
+	const streamChunksOfCombinedSourceMap = requireStreamChunksOfCombinedSourceMap();
+	const { getMap, getSourceAndMap } = requireGetFromStreamChunks();
+
+	class SourceMapSource extends Source {
+		constructor(
+			value,
+			name,
+			sourceMap,
+			originalSource,
+			innerSourceMap,
+			removeOriginalSource
+		) {
+			super();
+			const valueIsBuffer = Buffer.isBuffer(value);
+			this._valueAsString = valueIsBuffer ? undefined : value;
+			this._valueAsBuffer = valueIsBuffer ? value : undefined;
+
+			this._name = name;
+
+			this._hasSourceMap = !!sourceMap;
+			const sourceMapIsBuffer = Buffer.isBuffer(sourceMap);
+			const sourceMapIsString = typeof sourceMap === "string";
+			this._sourceMapAsObject =
+				sourceMapIsBuffer || sourceMapIsString ? undefined : sourceMap;
+			this._sourceMapAsString = sourceMapIsString ? sourceMap : undefined;
+			this._sourceMapAsBuffer = sourceMapIsBuffer ? sourceMap : undefined;
+
+			this._hasOriginalSource = !!originalSource;
+			const originalSourceIsBuffer = Buffer.isBuffer(originalSource);
+			this._originalSourceAsString = originalSourceIsBuffer
+				? undefined
+				: originalSource;
+			this._originalSourceAsBuffer = originalSourceIsBuffer
+				? originalSource
+				: undefined;
+
+			this._hasInnerSourceMap = !!innerSourceMap;
+			const innerSourceMapIsBuffer = Buffer.isBuffer(innerSourceMap);
+			const innerSourceMapIsString = typeof innerSourceMap === "string";
+			this._innerSourceMapAsObject =
+				innerSourceMapIsBuffer || innerSourceMapIsString
+					? undefined
+					: innerSourceMap;
+			this._innerSourceMapAsString = innerSourceMapIsString
+				? innerSourceMap
+				: undefined;
+			this._innerSourceMapAsBuffer = innerSourceMapIsBuffer
+				? innerSourceMap
+				: undefined;
+
+			this._removeOriginalSource = removeOriginalSource;
+		}
+
+		_ensureValueBuffer() {
+			if (this._valueAsBuffer === undefined) {
+				this._valueAsBuffer = Buffer.from(this._valueAsString, "utf-8");
+			}
+		}
+
+		_ensureValueString() {
+			if (this._valueAsString === undefined) {
+				this._valueAsString = this._valueAsBuffer.toString("utf-8");
+			}
+		}
+
+		_ensureOriginalSourceBuffer() {
+			if (this._originalSourceAsBuffer === undefined && this._hasOriginalSource) {
+				this._originalSourceAsBuffer = Buffer.from(
+					this._originalSourceAsString,
+					"utf-8"
+				);
+			}
+		}
+
+		_ensureOriginalSourceString() {
+			if (this._originalSourceAsString === undefined && this._hasOriginalSource) {
+				this._originalSourceAsString = this._originalSourceAsBuffer.toString(
+					"utf-8"
+				);
+			}
+		}
+
+		_ensureInnerSourceMapObject() {
+			if (this._innerSourceMapAsObject === undefined && this._hasInnerSourceMap) {
+				this._ensureInnerSourceMapString();
+				this._innerSourceMapAsObject = JSON.parse(this._innerSourceMapAsString);
+			}
+		}
+
+		_ensureInnerSourceMapBuffer() {
+			if (this._innerSourceMapAsBuffer === undefined && this._hasInnerSourceMap) {
+				this._ensureInnerSourceMapString();
+				this._innerSourceMapAsBuffer = Buffer.from(
+					this._innerSourceMapAsString,
+					"utf-8"
+				);
+			}
+		}
+
+		_ensureInnerSourceMapString() {
+			if (this._innerSourceMapAsString === undefined && this._hasInnerSourceMap) {
+				if (this._innerSourceMapAsBuffer !== undefined) {
+					this._innerSourceMapAsString = this._innerSourceMapAsBuffer.toString(
+						"utf-8"
+					);
+				} else {
+					this._innerSourceMapAsString = JSON.stringify(
+						this._innerSourceMapAsObject
+					);
+				}
+			}
+		}
+
+		_ensureSourceMapObject() {
+			if (this._sourceMapAsObject === undefined) {
+				this._ensureSourceMapString();
+				this._sourceMapAsObject = JSON.parse(this._sourceMapAsString);
+			}
+		}
+
+		_ensureSourceMapBuffer() {
+			if (this._sourceMapAsBuffer === undefined) {
+				this._ensureSourceMapString();
+				this._sourceMapAsBuffer = Buffer.from(this._sourceMapAsString, "utf-8");
+			}
+		}
+
+		_ensureSourceMapString() {
+			if (this._sourceMapAsString === undefined) {
+				if (this._sourceMapAsBuffer !== undefined) {
+					this._sourceMapAsString = this._sourceMapAsBuffer.toString("utf-8");
+				} else {
+					this._sourceMapAsString = JSON.stringify(this._sourceMapAsObject);
+				}
+			}
+		}
+
+		getArgsAsBuffers() {
+			this._ensureValueBuffer();
+			this._ensureSourceMapBuffer();
+			this._ensureOriginalSourceBuffer();
+			this._ensureInnerSourceMapBuffer();
+			return [
+				this._valueAsBuffer,
+				this._name,
+				this._sourceMapAsBuffer,
+				this._originalSourceAsBuffer,
+				this._innerSourceMapAsBuffer,
+				this._removeOriginalSource
+			];
+		}
+
+		buffer() {
+			this._ensureValueBuffer();
+			return this._valueAsBuffer;
+		}
+
+		source() {
+			this._ensureValueString();
+			return this._valueAsString;
+		}
+
+		map(options) {
+			if (!this._hasInnerSourceMap) {
+				this._ensureSourceMapObject();
+				return this._sourceMapAsObject;
+			}
+			return getMap(this, options);
+		}
+
+		sourceAndMap(options) {
+			if (!this._hasInnerSourceMap) {
+				this._ensureValueString();
+				this._ensureSourceMapObject();
+				return {
+					source: this._valueAsString,
+					map: this._sourceMapAsObject
+				};
+			}
+			return getSourceAndMap(this, options);
+		}
+
+		streamChunks(options, onChunk, onSource, onName) {
+			this._ensureValueString();
+			this._ensureSourceMapObject();
+			this._ensureOriginalSourceString();
+			if (this._hasInnerSourceMap) {
+				this._ensureInnerSourceMapObject();
+				return streamChunksOfCombinedSourceMap(
+					this._valueAsString,
+					this._sourceMapAsObject,
+					this._name,
+					this._originalSourceAsString,
+					this._innerSourceMapAsObject,
+					this._removeOriginalSource,
+					onChunk,
+					onSource,
+					onName,
+					!!(options && options.finalSource),
+					!!(options && options.columns !== false)
+				);
+			} else {
+				return streamChunksOfSourceMap(
+					this._valueAsString,
+					this._sourceMapAsObject,
+					onChunk,
+					onSource,
+					onName,
+					!!(options && options.finalSource),
+					!!(options && options.columns !== false)
+				);
+			}
+		}
+
+		updateHash(hash) {
+			this._ensureValueBuffer();
+			this._ensureSourceMapBuffer();
+			this._ensureOriginalSourceBuffer();
+			this._ensureInnerSourceMapBuffer();
+
+			hash.update("SourceMapSource");
+
+			hash.update(this._valueAsBuffer);
+
+			hash.update(this._sourceMapAsBuffer);
+
+			if (this._hasOriginalSource) {
+				hash.update(this._originalSourceAsBuffer);
+			}
+
+			if (this._hasInnerSourceMap) {
+				hash.update(this._innerSourceMapAsBuffer);
+			}
+
+			hash.update(this._removeOriginalSource ? "true" : "false");
+		}
+	}
+
+	SourceMapSource_1 = SourceMapSource;
+	return SourceMapSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var streamChunks;
+var hasRequiredStreamChunks;
+
+function requireStreamChunks () {
+	if (hasRequiredStreamChunks) return streamChunks;
+	hasRequiredStreamChunks = 1;
+
+	const streamChunksOfRawSource = requireStreamChunksOfRawSource();
+	const streamChunksOfSourceMap = requireStreamChunksOfSourceMap();
+
+	streamChunks = (source, options, onChunk, onSource, onName) => {
+		if (typeof source.streamChunks === "function") {
+			return source.streamChunks(options, onChunk, onSource, onName);
+		} else {
+			const sourceAndMap = source.sourceAndMap(options);
+			if (sourceAndMap.map) {
+				return streamChunksOfSourceMap(
+					sourceAndMap.source,
+					sourceAndMap.map,
+					onChunk,
+					onSource,
+					onName,
+					!!(options && options.finalSource),
+					!!(options && options.columns !== false)
+				);
+			} else {
+				return streamChunksOfRawSource(
+					sourceAndMap.source,
+					onChunk,
+					onSource,
+					onName,
+					!!(options && options.finalSource)
+				);
+			}
+		}
+	};
+	return streamChunks;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var streamAndGetSourceAndMap_1;
+var hasRequiredStreamAndGetSourceAndMap;
+
+function requireStreamAndGetSourceAndMap () {
+	if (hasRequiredStreamAndGetSourceAndMap) return streamAndGetSourceAndMap_1;
+	hasRequiredStreamAndGetSourceAndMap = 1;
+
+	const createMappingsSerializer = requireCreateMappingsSerializer();
+	const streamChunks = requireStreamChunks();
+
+	const streamAndGetSourceAndMap = (
+		inputSource,
+		options,
+		onChunk,
+		onSource,
+		onName
+	) => {
+		let code = "";
+		let mappings = "";
+		let sources = [];
+		let sourcesContent = [];
+		let names = [];
+		const addMapping = createMappingsSerializer(
+			Object.assign({}, options, { columns: true })
+		);
+		const finalSource = !!(options && options.finalSource);
+		const { generatedLine, generatedColumn, source } = streamChunks(
+			inputSource,
+			options,
+			(
+				chunk,
+				generatedLine,
+				generatedColumn,
+				sourceIndex,
+				originalLine,
+				originalColumn,
+				nameIndex
+			) => {
+				if (chunk !== undefined) code += chunk;
+				mappings += addMapping(
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex
+				);
+				return onChunk(
+					finalSource ? undefined : chunk,
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex
+				);
+			},
+			(sourceIndex, source, sourceContent) => {
+				while (sources.length < sourceIndex) {
+					sources.push(null);
+				}
+				sources[sourceIndex] = source;
+				if (sourceContent !== undefined) {
+					while (sourcesContent.length < sourceIndex) {
+						sourcesContent.push(null);
+					}
+					sourcesContent[sourceIndex] = sourceContent;
+				}
+				return onSource(sourceIndex, source, sourceContent);
+			},
+			(nameIndex, name) => {
+				while (names.length < nameIndex) {
+					names.push(null);
+				}
+				names[nameIndex] = name;
+				return onName(nameIndex, name);
+			}
+		);
+		const resultSource = source !== undefined ? source : code;
+		return {
+			result: {
+				generatedLine,
+				generatedColumn,
+				source: finalSource ? resultSource : undefined
+			},
+			source: resultSource,
+			map:
+				mappings.length > 0
+					? {
+							version: 3,
+							file: "x",
+							mappings,
+							sources,
+							sourcesContent:
+								sourcesContent.length > 0 ? sourcesContent : undefined,
+							names
+					  }
+					: null
+		};
+	};
+
+	streamAndGetSourceAndMap_1 = streamAndGetSourceAndMap;
+	return streamAndGetSourceAndMap_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var CachedSource_1;
+var hasRequiredCachedSource;
+
+function requireCachedSource () {
+	if (hasRequiredCachedSource) return CachedSource_1;
+	hasRequiredCachedSource = 1;
+
+	const Source = requireSource();
+	const streamChunksOfSourceMap = requireStreamChunksOfSourceMap();
+	const streamChunksOfRawSource = requireStreamChunksOfRawSource();
+	const streamAndGetSourceAndMap = requireStreamAndGetSourceAndMap();
+
+	const mapToBufferedMap = map => {
+		if (typeof map !== "object" || !map) return map;
+		const bufferedMap = Object.assign({}, map);
+		if (map.mappings) {
+			bufferedMap.mappings = Buffer.from(map.mappings, "utf-8");
+		}
+		if (map.sourcesContent) {
+			bufferedMap.sourcesContent = map.sourcesContent.map(
+				str => str && Buffer.from(str, "utf-8")
+			);
+		}
+		return bufferedMap;
+	};
+
+	const bufferedMapToMap = bufferedMap => {
+		if (typeof bufferedMap !== "object" || !bufferedMap) return bufferedMap;
+		const map = Object.assign({}, bufferedMap);
+		if (bufferedMap.mappings) {
+			map.mappings = bufferedMap.mappings.toString("utf-8");
+		}
+		if (bufferedMap.sourcesContent) {
+			map.sourcesContent = bufferedMap.sourcesContent.map(
+				buffer => buffer && buffer.toString("utf-8")
+			);
+		}
+		return map;
+	};
+
+	class CachedSource extends Source {
+		constructor(source, cachedData) {
+			super();
+			this._source = source;
+			this._cachedSourceType = cachedData ? cachedData.source : undefined;
+			this._cachedSource = undefined;
+			this._cachedBuffer = cachedData ? cachedData.buffer : undefined;
+			this._cachedSize = cachedData ? cachedData.size : undefined;
+			this._cachedMaps = cachedData ? cachedData.maps : new Map();
+			this._cachedHashUpdate = cachedData ? cachedData.hash : undefined;
+		}
+
+		getCachedData() {
+			const bufferedMaps = new Map();
+			for (const pair of this._cachedMaps) {
+				let cacheEntry = pair[1];
+				if (cacheEntry.bufferedMap === undefined) {
+					cacheEntry.bufferedMap = mapToBufferedMap(
+						this._getMapFromCacheEntry(cacheEntry)
+					);
+				}
+				bufferedMaps.set(pair[0], {
+					map: undefined,
+					bufferedMap: cacheEntry.bufferedMap
+				});
+			}
+			// We don't want to cache strings
+			// So if we have a caches sources
+			// create a buffer from it and only store
+			// if it was a Buffer or string
+			if (this._cachedSource) {
+				this.buffer();
+			}
+			return {
+				buffer: this._cachedBuffer,
+				source:
+					this._cachedSourceType !== undefined
+						? this._cachedSourceType
+						: typeof this._cachedSource === "string"
+						? true
+						: Buffer.isBuffer(this._cachedSource)
+						? false
+						: undefined,
+				size: this._cachedSize,
+				maps: bufferedMaps,
+				hash: this._cachedHashUpdate
+			};
+		}
+
+		originalLazy() {
+			return this._source;
+		}
+
+		original() {
+			if (typeof this._source === "function") this._source = this._source();
+			return this._source;
+		}
+
+		source() {
+			const source = this._getCachedSource();
+			if (source !== undefined) return source;
+			return (this._cachedSource = this.original().source());
+		}
+
+		_getMapFromCacheEntry(cacheEntry) {
+			if (cacheEntry.map !== undefined) {
+				return cacheEntry.map;
+			} else if (cacheEntry.bufferedMap !== undefined) {
+				return (cacheEntry.map = bufferedMapToMap(cacheEntry.bufferedMap));
+			}
+		}
+
+		_getCachedSource() {
+			if (this._cachedSource !== undefined) return this._cachedSource;
+			if (this._cachedBuffer && this._cachedSourceType !== undefined) {
+				return (this._cachedSource = this._cachedSourceType
+					? this._cachedBuffer.toString("utf-8")
+					: this._cachedBuffer);
+			}
+		}
+
+		buffer() {
+			if (this._cachedBuffer !== undefined) return this._cachedBuffer;
+			if (this._cachedSource !== undefined) {
+				if (Buffer.isBuffer(this._cachedSource)) {
+					return (this._cachedBuffer = this._cachedSource);
+				}
+				return (this._cachedBuffer = Buffer.from(this._cachedSource, "utf-8"));
+			}
+			if (typeof this.original().buffer === "function") {
+				return (this._cachedBuffer = this.original().buffer());
+			}
+			const bufferOrString = this.source();
+			if (Buffer.isBuffer(bufferOrString)) {
+				return (this._cachedBuffer = bufferOrString);
+			}
+			return (this._cachedBuffer = Buffer.from(bufferOrString, "utf-8"));
+		}
+
+		size() {
+			if (this._cachedSize !== undefined) return this._cachedSize;
+			if (this._cachedBuffer !== undefined) {
+				return (this._cachedSize = this._cachedBuffer.length);
+			}
+			const source = this._getCachedSource();
+			if (source !== undefined) {
+				return (this._cachedSize = Buffer.byteLength(source));
+			}
+			return (this._cachedSize = this.original().size());
+		}
+
+		sourceAndMap(options) {
+			const key = options ? JSON.stringify(options) : "{}";
+			const cacheEntry = this._cachedMaps.get(key);
+			// Look for a cached map
+			if (cacheEntry !== undefined) {
+				// We have a cached map in some representation
+				const map = this._getMapFromCacheEntry(cacheEntry);
+				// Either get the cached source or compute it
+				return { source: this.source(), map };
+			}
+			// Look for a cached source
+			let source = this._getCachedSource();
+			// Compute the map
+			let map;
+			if (source !== undefined) {
+				map = this.original().map(options);
+			} else {
+				// Compute the source and map together.
+				const sourceAndMap = this.original().sourceAndMap(options);
+				source = sourceAndMap.source;
+				map = sourceAndMap.map;
+				this._cachedSource = source;
+			}
+			this._cachedMaps.set(key, {
+				map,
+				bufferedMap: undefined
+			});
+			return { source, map };
+		}
+
+		streamChunks(options, onChunk, onSource, onName) {
+			const key = options ? JSON.stringify(options) : "{}";
+			if (
+				this._cachedMaps.has(key) &&
+				(this._cachedBuffer !== undefined || this._cachedSource !== undefined)
+			) {
+				const { source, map } = this.sourceAndMap(options);
+				if (map) {
+					return streamChunksOfSourceMap(
+						source,
+						map,
+						onChunk,
+						onSource,
+						onName,
+						!!(options && options.finalSource),
+						true
+					);
+				} else {
+					return streamChunksOfRawSource(
+						source,
+						onChunk,
+						onSource,
+						onName,
+						!!(options && options.finalSource)
+					);
+				}
+			}
+			const { result, source, map } = streamAndGetSourceAndMap(
+				this.original(),
+				options,
+				onChunk,
+				onSource,
+				onName
+			);
+			this._cachedSource = source;
+			this._cachedMaps.set(key, {
+				map,
+				bufferedMap: undefined
+			});
+			return result;
+		}
+
+		map(options) {
+			const key = options ? JSON.stringify(options) : "{}";
+			const cacheEntry = this._cachedMaps.get(key);
+			if (cacheEntry !== undefined) {
+				return this._getMapFromCacheEntry(cacheEntry);
+			}
+			const map = this.original().map(options);
+			this._cachedMaps.set(key, {
+				map,
+				bufferedMap: undefined
+			});
+			return map;
+		}
+
+		updateHash(hash) {
+			if (this._cachedHashUpdate !== undefined) {
+				for (const item of this._cachedHashUpdate) hash.update(item);
+				return;
+			}
+			const update = [];
+			let currentString = undefined;
+			const tracker = {
+				update: item => {
+					if (typeof item === "string" && item.length < 10240) {
+						if (currentString === undefined) {
+							currentString = item;
+						} else {
+							currentString += item;
+							if (currentString.length > 102400) {
+								update.push(Buffer.from(currentString));
+								currentString = undefined;
+							}
+						}
+					} else {
+						if (currentString !== undefined) {
+							update.push(Buffer.from(currentString));
+							currentString = undefined;
+						}
+						update.push(item);
+					}
+				}
+			};
+			this.original().updateHash(tracker);
+			if (currentString !== undefined) {
+				update.push(Buffer.from(currentString));
+			}
+			for (const item of update) hash.update(item);
+			this._cachedHashUpdate = update;
+		}
+	}
+
+	CachedSource_1 = CachedSource;
+	return CachedSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var ConcatSource_1;
+var hasRequiredConcatSource;
+
+function requireConcatSource () {
+	if (hasRequiredConcatSource) return ConcatSource_1;
+	hasRequiredConcatSource = 1;
+
+	const Source = requireSource();
+	const RawSource = requireRawSource();
+	const streamChunks = requireStreamChunks();
+	const { getMap, getSourceAndMap } = requireGetFromStreamChunks();
+
+	const stringsAsRawSources = new WeakSet();
+
+	class ConcatSource extends Source {
+		constructor() {
+			super();
+			this._children = [];
+			for (let i = 0; i < arguments.length; i++) {
+				const item = arguments[i];
+				if (item instanceof ConcatSource) {
+					for (const child of item._children) {
+						this._children.push(child);
+					}
+				} else {
+					this._children.push(item);
+				}
+			}
+			this._isOptimized = arguments.length === 0;
+		}
+
+		getChildren() {
+			if (!this._isOptimized) this._optimize();
+			return this._children;
+		}
+
+		add(item) {
+			if (item instanceof ConcatSource) {
+				for (const child of item._children) {
+					this._children.push(child);
+				}
+			} else {
+				this._children.push(item);
+			}
+			this._isOptimized = false;
+		}
+
+		addAllSkipOptimizing(items) {
+			for (const item of items) {
+				this._children.push(item);
+			}
+		}
+
+		buffer() {
+			if (!this._isOptimized) this._optimize();
+			const buffers = [];
+			for (const child of this._children) {
+				if (typeof child.buffer === "function") {
+					buffers.push(child.buffer());
+				} else {
+					const bufferOrString = child.source();
+					if (Buffer.isBuffer(bufferOrString)) {
+						buffers.push(bufferOrString);
+					} else {
+						// This will not happen
+						buffers.push(Buffer.from(bufferOrString, "utf-8"));
+					}
+				}
+			}
+			return Buffer.concat(buffers);
+		}
+
+		source() {
+			if (!this._isOptimized) this._optimize();
+			let source = "";
+			for (const child of this._children) {
+				source += child.source();
+			}
+			return source;
+		}
+
+		size() {
+			if (!this._isOptimized) this._optimize();
+			let size = 0;
+			for (const child of this._children) {
+				size += child.size();
+			}
+			return size;
+		}
+
+		map(options) {
+			return getMap(this, options);
+		}
+
+		sourceAndMap(options) {
+			return getSourceAndMap(this, options);
+		}
+
+		streamChunks(options, onChunk, onSource, onName) {
+			if (!this._isOptimized) this._optimize();
+			if (this._children.length === 1)
+				return this._children[0].streamChunks(options, onChunk, onSource, onName);
+			let currentLineOffset = 0;
+			let currentColumnOffset = 0;
+			let sourceMapping = new Map();
+			let nameMapping = new Map();
+			const finalSource = !!(options && options.finalSource);
+			let code = "";
+			let needToCloseMapping = false;
+			for (const item of this._children) {
+				const sourceIndexMapping = [];
+				const nameIndexMapping = [];
+				let lastMappingLine = 0;
+				const { generatedLine, generatedColumn, source } = streamChunks(
+					item,
+					options,
+					// eslint-disable-next-line no-loop-func
+					(
+						chunk,
+						generatedLine,
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn,
+						nameIndex
+					) => {
+						const line = generatedLine + currentLineOffset;
+						const column =
+							generatedLine === 1
+								? generatedColumn + currentColumnOffset
+								: generatedColumn;
+						if (needToCloseMapping) {
+							if (generatedLine !== 1 || generatedColumn !== 0) {
+								onChunk(
+									undefined,
+									currentLineOffset + 1,
+									currentColumnOffset,
+									-1,
+									-1,
+									-1,
+									-1
+								);
+							}
+							needToCloseMapping = false;
+						}
+						const resultSourceIndex =
+							sourceIndex < 0 || sourceIndex >= sourceIndexMapping.length
+								? -1
+								: sourceIndexMapping[sourceIndex];
+						const resultNameIndex =
+							nameIndex < 0 || nameIndex >= nameIndexMapping.length
+								? -1
+								: nameIndexMapping[nameIndex];
+						lastMappingLine = resultSourceIndex < 0 ? 0 : generatedLine;
+						if (finalSource) {
+							if (chunk !== undefined) code += chunk;
+							if (resultSourceIndex >= 0) {
+								onChunk(
+									undefined,
+									line,
+									column,
+									resultSourceIndex,
+									originalLine,
+									originalColumn,
+									resultNameIndex
+								);
+							}
+						} else {
+							if (resultSourceIndex < 0) {
+								onChunk(chunk, line, column, -1, -1, -1, -1);
+							} else {
+								onChunk(
+									chunk,
+									line,
+									column,
+									resultSourceIndex,
+									originalLine,
+									originalColumn,
+									resultNameIndex
+								);
+							}
+						}
+					},
+					(i, source, sourceContent) => {
+						let globalIndex = sourceMapping.get(source);
+						if (globalIndex === undefined) {
+							sourceMapping.set(source, (globalIndex = sourceMapping.size));
+							onSource(globalIndex, source, sourceContent);
+						}
+						sourceIndexMapping[i] = globalIndex;
+					},
+					(i, name) => {
+						let globalIndex = nameMapping.get(name);
+						if (globalIndex === undefined) {
+							nameMapping.set(name, (globalIndex = nameMapping.size));
+							onName(globalIndex, name);
+						}
+						nameIndexMapping[i] = globalIndex;
+					}
+				);
+				if (source !== undefined) code += source;
+				if (needToCloseMapping) {
+					if (generatedLine !== 1 || generatedColumn !== 0) {
+						onChunk(
+							undefined,
+							currentLineOffset + 1,
+							currentColumnOffset,
+							-1,
+							-1,
+							-1,
+							-1
+						);
+						needToCloseMapping = false;
+					}
+				}
+				if (generatedLine > 1) {
+					currentColumnOffset = generatedColumn;
+				} else {
+					currentColumnOffset += generatedColumn;
+				}
+				needToCloseMapping =
+					needToCloseMapping ||
+					(finalSource && lastMappingLine === generatedLine);
+				currentLineOffset += generatedLine - 1;
+			}
+			return {
+				generatedLine: currentLineOffset + 1,
+				generatedColumn: currentColumnOffset,
+				source: finalSource ? code : undefined
+			};
+		}
+
+		updateHash(hash) {
+			if (!this._isOptimized) this._optimize();
+			hash.update("ConcatSource");
+			for (const item of this._children) {
+				item.updateHash(hash);
+			}
+		}
+
+		_optimize() {
+			const newChildren = [];
+			let currentString = undefined;
+			let currentRawSources = undefined;
+			const addStringToRawSources = string => {
+				if (currentRawSources === undefined) {
+					currentRawSources = string;
+				} else if (Array.isArray(currentRawSources)) {
+					currentRawSources.push(string);
+				} else {
+					currentRawSources = [
+						typeof currentRawSources === "string"
+							? currentRawSources
+							: currentRawSources.source(),
+						string
+					];
+				}
+			};
+			const addSourceToRawSources = source => {
+				if (currentRawSources === undefined) {
+					currentRawSources = source;
+				} else if (Array.isArray(currentRawSources)) {
+					currentRawSources.push(source.source());
+				} else {
+					currentRawSources = [
+						typeof currentRawSources === "string"
+							? currentRawSources
+							: currentRawSources.source(),
+						source.source()
+					];
+				}
+			};
+			const mergeRawSources = () => {
+				if (Array.isArray(currentRawSources)) {
+					const rawSource = new RawSource(currentRawSources.join(""));
+					stringsAsRawSources.add(rawSource);
+					newChildren.push(rawSource);
+				} else if (typeof currentRawSources === "string") {
+					const rawSource = new RawSource(currentRawSources);
+					stringsAsRawSources.add(rawSource);
+					newChildren.push(rawSource);
+				} else {
+					newChildren.push(currentRawSources);
+				}
+			};
+			for (const child of this._children) {
+				if (typeof child === "string") {
+					if (currentString === undefined) {
+						currentString = child;
+					} else {
+						currentString += child;
+					}
+				} else {
+					if (currentString !== undefined) {
+						addStringToRawSources(currentString);
+						currentString = undefined;
+					}
+					if (stringsAsRawSources.has(child)) {
+						addSourceToRawSources(child);
+					} else {
+						if (currentRawSources !== undefined) {
+							mergeRawSources();
+							currentRawSources = undefined;
+						}
+						newChildren.push(child);
+					}
+				}
+			}
+			if (currentString !== undefined) {
+				addStringToRawSources(currentString);
+			}
+			if (currentRawSources !== undefined) {
+				mergeRawSources();
+			}
+			this._children = newChildren;
+			this._isOptimized = true;
+		}
+	}
+
+	ConcatSource_1 = ConcatSource;
+	return ConcatSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var ReplaceSource_1;
+var hasRequiredReplaceSource;
+
+function requireReplaceSource () {
+	if (hasRequiredReplaceSource) return ReplaceSource_1;
+	hasRequiredReplaceSource = 1;
+
+	const { getMap, getSourceAndMap } = requireGetFromStreamChunks();
+	const streamChunks = requireStreamChunks();
+	const Source = requireSource();
+	const splitIntoLines = requireSplitIntoLines();
+
+	// since v8 7.0, Array.prototype.sort is stable
+	const hasStableSort =
+		typeof process === "object" &&
+		process.versions &&
+		typeof process.versions.v8 === "string" &&
+		!/^[0-6]\./.test(process.versions.v8);
+
+	// This is larger than max string length
+	const MAX_SOURCE_POSITION = 0x20000000;
+
+	class Replacement {
+		constructor(start, end, content, name) {
+			this.start = start;
+			this.end = end;
+			this.content = content;
+			this.name = name;
+			if (!hasStableSort) {
+				this.index = -1;
+			}
+		}
+	}
+
+	class ReplaceSource extends Source {
+		constructor(source, name) {
+			super();
+			this._source = source;
+			this._name = name;
+			/** @type {Replacement[]} */
+			this._replacements = [];
+			this._isSorted = true;
+		}
+
+		getName() {
+			return this._name;
+		}
+
+		getReplacements() {
+			this._sortReplacements();
+			return this._replacements;
+		}
+
+		replace(start, end, newValue, name) {
+			if (typeof newValue !== "string")
+				throw new Error(
+					"insertion must be a string, but is a " + typeof newValue
+				);
+			this._replacements.push(new Replacement(start, end, newValue, name));
+			this._isSorted = false;
+		}
+
+		insert(pos, newValue, name) {
+			if (typeof newValue !== "string")
+				throw new Error(
+					"insertion must be a string, but is a " +
+						typeof newValue +
+						": " +
+						newValue
+				);
+			this._replacements.push(new Replacement(pos, pos - 1, newValue, name));
+			this._isSorted = false;
+		}
+
+		source() {
+			if (this._replacements.length === 0) {
+				return this._source.source();
+			}
+			let current = this._source.source();
+			let pos = 0;
+			const result = [];
+
+			this._sortReplacements();
+			for (const replacement of this._replacements) {
+				const start = Math.floor(replacement.start);
+				const end = Math.floor(replacement.end + 1);
+				if (pos < start) {
+					const offset = start - pos;
+					result.push(current.slice(0, offset));
+					current = current.slice(offset);
+					pos = start;
+				}
+				result.push(replacement.content);
+				if (pos < end) {
+					const offset = end - pos;
+					current = current.slice(offset);
+					pos = end;
+				}
+			}
+			result.push(current);
+			return result.join("");
+		}
+
+		map(options) {
+			if (this._replacements.length === 0) {
+				return this._source.map(options);
+			}
+			return getMap(this, options);
+		}
+
+		sourceAndMap(options) {
+			if (this._replacements.length === 0) {
+				return this._source.sourceAndMap(options);
+			}
+			return getSourceAndMap(this, options);
+		}
+
+		original() {
+			return this._source;
+		}
+
+		_sortReplacements() {
+			if (this._isSorted) return;
+			if (hasStableSort) {
+				this._replacements.sort(function (a, b) {
+					const diff1 = a.start - b.start;
+					if (diff1 !== 0) return diff1;
+					const diff2 = a.end - b.end;
+					if (diff2 !== 0) return diff2;
+					return 0;
+				});
+			} else {
+				this._replacements.forEach((repl, i) => (repl.index = i));
+				this._replacements.sort(function (a, b) {
+					const diff1 = a.start - b.start;
+					if (diff1 !== 0) return diff1;
+					const diff2 = a.end - b.end;
+					if (diff2 !== 0) return diff2;
+					return a.index - b.index;
+				});
+			}
+			this._isSorted = true;
+		}
+
+		streamChunks(options, onChunk, onSource, onName) {
+			this._sortReplacements();
+			const repls = this._replacements;
+			let pos = 0;
+			let i = 0;
+			let replacmentEnd = -1;
+			let nextReplacement =
+				i < repls.length ? Math.floor(repls[i].start) : MAX_SOURCE_POSITION;
+			let generatedLineOffset = 0;
+			let generatedColumnOffset = 0;
+			let generatedColumnOffsetLine = 0;
+			const sourceContents = [];
+			const nameMapping = new Map();
+			const nameIndexMapping = [];
+			const checkOriginalContent = (sourceIndex, line, column, expectedChunk) => {
+				let content =
+					sourceIndex < sourceContents.length
+						? sourceContents[sourceIndex]
+						: undefined;
+				if (content === undefined) return false;
+				if (typeof content === "string") {
+					content = splitIntoLines(content);
+					sourceContents[sourceIndex] = content;
+				}
+				const contentLine = line <= content.length ? content[line - 1] : null;
+				if (contentLine === null) return false;
+				return (
+					contentLine.slice(column, column + expectedChunk.length) ===
+					expectedChunk
+				);
+			};
+			let { generatedLine, generatedColumn } = streamChunks(
+				this._source,
+				Object.assign({}, options, { finalSource: false }),
+				(
+					chunk,
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex
+				) => {
+					let chunkPos = 0;
+					let endPos = pos + chunk.length;
+
+					// Skip over when it has been replaced
+					if (replacmentEnd > pos) {
+						// Skip over the whole chunk
+						if (replacmentEnd >= endPos) {
+							const line = generatedLine + generatedLineOffset;
+							if (chunk.endsWith("\n")) {
+								generatedLineOffset--;
+								if (generatedColumnOffsetLine === line) {
+									// undo exiting corrections form the current line
+									generatedColumnOffset += generatedColumn;
+								}
+							} else if (generatedColumnOffsetLine === line) {
+								generatedColumnOffset -= chunk.length;
+							} else {
+								generatedColumnOffset = -chunk.length;
+								generatedColumnOffsetLine = line;
+							}
+							pos = endPos;
+							return;
+						}
+
+						// Partially skip over chunk
+						chunkPos = replacmentEnd - pos;
+						if (
+							checkOriginalContent(
+								sourceIndex,
+								originalLine,
+								originalColumn,
+								chunk.slice(0, chunkPos)
+							)
+						) {
+							originalColumn += chunkPos;
+						}
+						pos += chunkPos;
+						const line = generatedLine + generatedLineOffset;
+						if (generatedColumnOffsetLine === line) {
+							generatedColumnOffset -= chunkPos;
+						} else {
+							generatedColumnOffset = -chunkPos;
+							generatedColumnOffsetLine = line;
+						}
+						generatedColumn += chunkPos;
+					}
+
+					// Is a replacement in the chunk?
+					if (nextReplacement < endPos) {
+						do {
+							let line = generatedLine + generatedLineOffset;
+							if (nextReplacement > pos) {
+								// Emit chunk until replacement
+								const offset = nextReplacement - pos;
+								const chunkSlice = chunk.slice(chunkPos, chunkPos + offset);
+								onChunk(
+									chunkSlice,
+									line,
+									generatedColumn +
+										(line === generatedColumnOffsetLine
+											? generatedColumnOffset
+											: 0),
+									sourceIndex,
+									originalLine,
+									originalColumn,
+									nameIndex < 0 || nameIndex >= nameIndexMapping.length
+										? -1
+										: nameIndexMapping[nameIndex]
+								);
+								generatedColumn += offset;
+								chunkPos += offset;
+								pos = nextReplacement;
+								if (
+									checkOriginalContent(
+										sourceIndex,
+										originalLine,
+										originalColumn,
+										chunkSlice
+									)
+								) {
+									originalColumn += chunkSlice.length;
+								}
+							}
+
+							// Insert replacement content splitted into chunks by lines
+							const { content, name } = repls[i];
+							let matches = splitIntoLines(content);
+							let replacementNameIndex = nameIndex;
+							if (sourceIndex >= 0 && name) {
+								let globalIndex = nameMapping.get(name);
+								if (globalIndex === undefined) {
+									globalIndex = nameMapping.size;
+									nameMapping.set(name, globalIndex);
+									onName(globalIndex, name);
+								}
+								replacementNameIndex = globalIndex;
+							}
+							for (let m = 0; m < matches.length; m++) {
+								const contentLine = matches[m];
+								onChunk(
+									contentLine,
+									line,
+									generatedColumn +
+										(line === generatedColumnOffsetLine
+											? generatedColumnOffset
+											: 0),
+									sourceIndex,
+									originalLine,
+									originalColumn,
+									replacementNameIndex
+								);
+
+								// Only the first chunk has name assigned
+								replacementNameIndex = -1;
+
+								if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
+									if (generatedColumnOffsetLine === line) {
+										generatedColumnOffset += contentLine.length;
+									} else {
+										generatedColumnOffset = contentLine.length;
+										generatedColumnOffsetLine = line;
+									}
+								} else {
+									generatedLineOffset++;
+									line++;
+									generatedColumnOffset = -generatedColumn;
+									generatedColumnOffsetLine = line;
+								}
+							}
+
+							// Remove replaced content by settings this variable
+							replacmentEnd = Math.max(
+								replacmentEnd,
+								Math.floor(repls[i].end + 1)
+							);
+
+							// Move to next replacment
+							i++;
+							nextReplacement =
+								i < repls.length
+									? Math.floor(repls[i].start)
+									: MAX_SOURCE_POSITION;
+
+							// Skip over when it has been replaced
+							const offset = chunk.length - endPos + replacmentEnd - chunkPos;
+							if (offset > 0) {
+								// Skip over whole chunk
+								if (replacmentEnd >= endPos) {
+									let line = generatedLine + generatedLineOffset;
+									if (chunk.endsWith("\n")) {
+										generatedLineOffset--;
+										if (generatedColumnOffsetLine === line) {
+											// undo exiting corrections form the current line
+											generatedColumnOffset += generatedColumn;
+										}
+									} else if (generatedColumnOffsetLine === line) {
+										generatedColumnOffset -= chunk.length - chunkPos;
+									} else {
+										generatedColumnOffset = chunkPos - chunk.length;
+										generatedColumnOffsetLine = line;
+									}
+									pos = endPos;
+									return;
+								}
+
+								// Partially skip over chunk
+								const line = generatedLine + generatedLineOffset;
+								if (
+									checkOriginalContent(
+										sourceIndex,
+										originalLine,
+										originalColumn,
+										chunk.slice(chunkPos, chunkPos + offset)
+									)
+								) {
+									originalColumn += offset;
+								}
+								chunkPos += offset;
+								pos += offset;
+								if (generatedColumnOffsetLine === line) {
+									generatedColumnOffset -= offset;
+								} else {
+									generatedColumnOffset = -offset;
+									generatedColumnOffsetLine = line;
+								}
+								generatedColumn += offset;
+							}
+						} while (nextReplacement < endPos);
+					}
+
+					// Emit remaining chunk
+					if (chunkPos < chunk.length) {
+						const chunkSlice = chunkPos === 0 ? chunk : chunk.slice(chunkPos);
+						const line = generatedLine + generatedLineOffset;
+						onChunk(
+							chunkSlice,
+							line,
+							generatedColumn +
+								(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
+							sourceIndex,
+							originalLine,
+							originalColumn,
+							nameIndex < 0 ? -1 : nameIndexMapping[nameIndex]
+						);
+					}
+					pos = endPos;
+				},
+				(sourceIndex, source, sourceContent) => {
+					while (sourceContents.length < sourceIndex)
+						sourceContents.push(undefined);
+					sourceContents[sourceIndex] = sourceContent;
+					onSource(sourceIndex, source, sourceContent);
+				},
+				(nameIndex, name) => {
+					let globalIndex = nameMapping.get(name);
+					if (globalIndex === undefined) {
+						globalIndex = nameMapping.size;
+						nameMapping.set(name, globalIndex);
+						onName(globalIndex, name);
+					}
+					nameIndexMapping[nameIndex] = globalIndex;
+				}
+			);
+
+			// Handle remaining replacements
+			let remainer = "";
+			for (; i < repls.length; i++) {
+				remainer += repls[i].content;
+			}
+
+			// Insert remaining replacements content splitted into chunks by lines
+			let line = generatedLine + generatedLineOffset;
+			let matches = splitIntoLines(remainer);
+			for (let m = 0; m < matches.length; m++) {
+				const contentLine = matches[m];
+				onChunk(
+					contentLine,
+					line,
+					generatedColumn +
+						(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
+					-1,
+					-1,
+					-1,
+					-1
+				);
+
+				if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
+					if (generatedColumnOffsetLine === line) {
+						generatedColumnOffset += contentLine.length;
+					} else {
+						generatedColumnOffset = contentLine.length;
+						generatedColumnOffsetLine = line;
+					}
+				} else {
+					generatedLineOffset++;
+					line++;
+					generatedColumnOffset = -generatedColumn;
+					generatedColumnOffsetLine = line;
+				}
+			}
+
+			return {
+				generatedLine: line,
+				generatedColumn:
+					generatedColumn +
+					(line === generatedColumnOffsetLine ? generatedColumnOffset : 0)
+			};
+		}
+
+		updateHash(hash) {
+			this._sortReplacements();
+			hash.update("ReplaceSource");
+			this._source.updateHash(hash);
+			hash.update(this._name || "");
+			for (const repl of this._replacements) {
+				hash.update(`${repl.start}${repl.end}${repl.content}${repl.name}`);
+			}
+		}
+	}
+
+	ReplaceSource_1 = ReplaceSource;
+	return ReplaceSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var PrefixSource_1;
+var hasRequiredPrefixSource;
+
+function requirePrefixSource () {
+	if (hasRequiredPrefixSource) return PrefixSource_1;
+	hasRequiredPrefixSource = 1;
+
+	const Source = requireSource();
+	const RawSource = requireRawSource();
+	const streamChunks = requireStreamChunks();
+	const { getMap, getSourceAndMap } = requireGetFromStreamChunks();
+
+	const REPLACE_REGEX = /\n(?=.|\s)/g;
+
+	class PrefixSource extends Source {
+		constructor(prefix, source) {
+			super();
+			this._source =
+				typeof source === "string" || Buffer.isBuffer(source)
+					? new RawSource(source, true)
+					: source;
+			this._prefix = prefix;
+		}
+
+		getPrefix() {
+			return this._prefix;
+		}
+
+		original() {
+			return this._source;
+		}
+
+		source() {
+			const node = this._source.source();
+			const prefix = this._prefix;
+			return prefix + node.replace(REPLACE_REGEX, "\n" + prefix);
+		}
+
+		// TODO efficient buffer() implementation
+
+		map(options) {
+			return getMap(this, options);
+		}
+
+		sourceAndMap(options) {
+			return getSourceAndMap(this, options);
+		}
+
+		streamChunks(options, onChunk, onSource, onName) {
+			const prefix = this._prefix;
+			const prefixOffset = prefix.length;
+			const linesOnly = !!(options && options.columns === false);
+			const { generatedLine, generatedColumn, source } = streamChunks(
+				this._source,
+				options,
+				(
+					chunk,
+					generatedLine,
+					generatedColumn,
+					sourceIndex,
+					originalLine,
+					originalColumn,
+					nameIndex
+				) => {
+					if (generatedColumn !== 0) {
+						// In the middle of the line, we just adject the column
+						generatedColumn += prefixOffset;
+					} else if (chunk !== undefined) {
+						// At the start of the line, when we have source content
+						// add the prefix as generated mapping
+						// (in lines only mode we just add it to the original mapping
+						// for performance reasons)
+						if (linesOnly || sourceIndex < 0) {
+							chunk = prefix + chunk;
+						} else if (prefixOffset > 0) {
+							onChunk(prefix, generatedLine, generatedColumn, -1, -1, -1, -1);
+							generatedColumn += prefixOffset;
+						}
+					} else if (!linesOnly) {
+						// Without source content, we only need to adject the column info
+						// expect in lines only mode where prefix is added to original mapping
+						generatedColumn += prefixOffset;
+					}
+					onChunk(
+						chunk,
+						generatedLine,
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn,
+						nameIndex
+					);
+				},
+				onSource,
+				onName
+			);
+			return {
+				generatedLine,
+				generatedColumn:
+					generatedColumn === 0 ? 0 : prefixOffset + generatedColumn,
+				source:
+					source !== undefined
+						? prefix + source.replace(REPLACE_REGEX, "\n" + prefix)
+						: undefined
+			};
+		}
+
+		updateHash(hash) {
+			hash.update("PrefixSource");
+			this._source.updateHash(hash);
+			hash.update(this._prefix);
+		}
+	}
+
+	PrefixSource_1 = PrefixSource;
+	return PrefixSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var SizeOnlySource_1;
+var hasRequiredSizeOnlySource;
+
+function requireSizeOnlySource () {
+	if (hasRequiredSizeOnlySource) return SizeOnlySource_1;
+	hasRequiredSizeOnlySource = 1;
+
+	const Source = requireSource();
+
+	class SizeOnlySource extends Source {
+		constructor(size) {
+			super();
+			this._size = size;
+		}
+
+		_error() {
+			return new Error(
+				"Content and Map of this Source is not available (only size() is supported)"
+			);
+		}
+
+		size() {
+			return this._size;
+		}
+
+		source() {
+			throw this._error();
+		}
+
+		buffer() {
+			throw this._error();
+		}
+
+		map(options) {
+			throw this._error();
+		}
+
+		updateHash() {
+			throw this._error();
+		}
+	}
+
+	SizeOnlySource_1 = SizeOnlySource;
+	return SizeOnlySource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var CompatSource_1;
+var hasRequiredCompatSource;
+
+function requireCompatSource () {
+	if (hasRequiredCompatSource) return CompatSource_1;
+	hasRequiredCompatSource = 1;
+
+	const Source = requireSource();
+
+	class CompatSource extends Source {
+		static from(sourceLike) {
+			return sourceLike instanceof Source
+				? sourceLike
+				: new CompatSource(sourceLike);
+		}
+
+		constructor(sourceLike) {
+			super();
+			this._sourceLike = sourceLike;
+		}
+
+		source() {
+			return this._sourceLike.source();
+		}
+
+		buffer() {
+			if (typeof this._sourceLike.buffer === "function") {
+				return this._sourceLike.buffer();
+			}
+			return super.buffer();
+		}
+
+		size() {
+			if (typeof this._sourceLike.size === "function") {
+				return this._sourceLike.size();
+			}
+			return super.size();
+		}
+
+		map(options) {
+			if (typeof this._sourceLike.map === "function") {
+				return this._sourceLike.map(options);
+			}
+			return super.map(options);
+		}
+
+		sourceAndMap(options) {
+			if (typeof this._sourceLike.sourceAndMap === "function") {
+				return this._sourceLike.sourceAndMap(options);
+			}
+			return super.sourceAndMap(options);
+		}
+
+		updateHash(hash) {
+			if (typeof this._sourceLike.updateHash === "function") {
+				return this._sourceLike.updateHash(hash);
+			}
+			if (typeof this._sourceLike.map === "function") {
+				throw new Error(
+					"A Source-like object with a 'map' method must also provide an 'updateHash' method"
+				);
+			}
+			hash.update(this.buffer());
+		}
+	}
+
+	CompatSource_1 = CompatSource;
+	return CompatSource_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+(function (exports) {
+	const defineExport = (name, fn) => {
+		let value;
+		Object.defineProperty(exports, name, {
+			get: () => {
+				if (fn !== undefined) {
+					value = fn();
+					fn = undefined;
+				}
+				return value;
+			},
+			configurable: true
+		});
+	};
+
+	defineExport("Source", () => requireSource());
+
+	defineExport("RawSource", () => requireRawSource());
+	defineExport("OriginalSource", () => requireOriginalSource());
+	defineExport("SourceMapSource", () => requireSourceMapSource());
+	defineExport("CachedSource", () => requireCachedSource());
+	defineExport("ConcatSource", () => requireConcatSource());
+	defineExport("ReplaceSource", () => requireReplaceSource());
+	defineExport("PrefixSource", () => requirePrefixSource());
+	defineExport("SizeOnlySource", () => requireSizeOnlySource());
+	defineExport("CompatSource", () => requireCompatSource()); 
+} (lib$1));
+
+var sources2 = /*@__PURE__*/getDefaultExportFromCjs(lib$1);
+
 var virtualStats = {};
 
 var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
@@ -30966,11 +34375,6 @@ function getReadDirBackend(fileSystem) {
         throw new Error("Couldn't find a readDirStorage from Webpack Internals");
     }
 }
-function getRealpathBackend(fileSystem) {
-    if (fileSystem._realpathBackend) {
-        return fileSystem._realpathBackend;
-    }
-}
 class VirtualModulesPlugin {
     constructor(modules) {
         this._compiler = null;
@@ -31073,7 +34477,6 @@ class VirtualModulesPlugin {
                     const statStorage = getStatStorage(finalInputFileSystem);
                     const fileStorage = getFileStorage(finalInputFileSystem);
                     const readDirStorage = getReadDirBackend(finalInputFileSystem);
-                    const realPathStorage = getRealpathBackend(finalInputFileSystem);
                     finalInputFileSystem._virtualFiles = finalInputFileSystem._virtualFiles || {};
                     finalInputFileSystem._virtualFiles[file] = { stats: stats, contents: contents };
                     setData(statStorage, file, createWebpackData(stats));
@@ -31105,9 +34508,6 @@ class VirtualModulesPlugin {
                                 birthtime: time,
                             });
                             setData(readDirStorage, dir, createWebpackData([]));
-                            if (realPathStorage) {
-                                setData(realPathStorage, dir, createWebpackData(dir));
-                            }
                             setData(statStorage, dir, createWebpackData(dirStats));
                         }
                         let dirData = getData(getReadDirBackend(finalInputFileSystem), dir);
@@ -31168,12 +34568,12 @@ var lib = VirtualModulesPlugin;
 
 var VirtualModulesPlugin$1 = /*@__PURE__*/getDefaultExportFromCjs(lib);
 
-// node_modules/.pnpm/tsup@8.2.4_jiti@1.21.6_typescript@5.5.4/node_modules/tsup/assets/esm_shims.js
+// node_modules/.pnpm/tsup@8.0.2_typescript@5.4.5/node_modules/tsup/assets/esm_shims.js
 var getFilename = () => fileURLToPath$1(import.meta.url);
 var getDirname = () => require$$1.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
-// node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+// node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.15/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -31184,41 +34584,6 @@ for (let i = 0; i < chars.length; i++) {
   intToChar[i] = c;
   charToInt[c] = i;
 }
-function decodeInteger(reader, relative) {
-  let value = 0;
-  let shift = 0;
-  let integer = 0;
-  do {
-    const c = reader.next();
-    integer = charToInt[c];
-    value |= (integer & 31) << shift;
-    shift += 5;
-  } while (integer & 32);
-  const shouldNegate = value & 1;
-  value >>>= 1;
-  if (shouldNegate) {
-    value = -2147483648 | -value;
-  }
-  return relative + value;
-}
-function encodeInteger(builder, num, relative) {
-  let delta = num - relative;
-  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
-  do {
-    let clamped = delta & 31;
-    delta >>>= 5;
-    if (delta > 0)
-      clamped |= 32;
-    builder.write(intToChar[clamped]);
-  } while (delta > 0);
-  return num;
-}
-function hasMoreVlq(reader, max) {
-  if (reader.pos >= max)
-    return false;
-  return reader.peek() !== comma;
-}
-var bufLength = 1024 * 16;
 var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
   decode(buf) {
     const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
@@ -31233,86 +34598,72 @@ var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder()
     return out;
   }
 };
-var StringWriter = class {
-  constructor() {
-    this.pos = 0;
-    this.out = "";
-    this.buffer = new Uint8Array(bufLength);
-  }
-  write(v) {
-    const { buffer } = this;
-    buffer[this.pos++] = v;
-    if (this.pos === bufLength) {
-      this.out += td.decode(buffer);
-      this.pos = 0;
-    }
-  }
-  flush() {
-    const { buffer, out, pos } = this;
-    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
-  }
-};
-var StringReader = class {
-  constructor(buffer) {
-    this.pos = 0;
-    this.buffer = buffer;
-  }
-  next() {
-    return this.buffer.charCodeAt(this.pos++);
-  }
-  peek() {
-    return this.buffer.charCodeAt(this.pos);
-  }
-  indexOf(char) {
-    const { buffer, pos } = this;
-    const idx = buffer.indexOf(char, pos);
-    return idx === -1 ? buffer.length : idx;
-  }
-};
 function decode(mappings) {
-  const { length } = mappings;
-  const reader = new StringReader(mappings);
+  const state = new Int32Array(5);
   const decoded = [];
-  let genColumn = 0;
-  let sourcesIndex = 0;
-  let sourceLine = 0;
-  let sourceColumn = 0;
-  let namesIndex = 0;
+  let index = 0;
   do {
-    const semi = reader.indexOf(";");
+    const semi = indexOf(mappings, index);
     const line = [];
     let sorted = true;
     let lastCol = 0;
-    genColumn = 0;
-    while (reader.pos < semi) {
+    state[0] = 0;
+    for (let i = index; i < semi; i++) {
       let seg;
-      genColumn = decodeInteger(reader, genColumn);
-      if (genColumn < lastCol)
+      i = decodeInteger(mappings, i, state, 0);
+      const col = state[0];
+      if (col < lastCol)
         sorted = false;
-      lastCol = genColumn;
-      if (hasMoreVlq(reader, semi)) {
-        sourcesIndex = decodeInteger(reader, sourcesIndex);
-        sourceLine = decodeInteger(reader, sourceLine);
-        sourceColumn = decodeInteger(reader, sourceColumn);
-        if (hasMoreVlq(reader, semi)) {
-          namesIndex = decodeInteger(reader, namesIndex);
-          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+      lastCol = col;
+      if (hasMoreVlq(mappings, i, semi)) {
+        i = decodeInteger(mappings, i, state, 1);
+        i = decodeInteger(mappings, i, state, 2);
+        i = decodeInteger(mappings, i, state, 3);
+        if (hasMoreVlq(mappings, i, semi)) {
+          i = decodeInteger(mappings, i, state, 4);
+          seg = [col, state[1], state[2], state[3], state[4]];
         } else {
-          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+          seg = [col, state[1], state[2], state[3]];
         }
       } else {
-        seg = [genColumn];
+        seg = [col];
       }
       line.push(seg);
-      reader.pos++;
     }
     if (!sorted)
       sort(line);
     decoded.push(line);
-    reader.pos = semi + 1;
-  } while (reader.pos <= length);
+    index = semi + 1;
+  } while (index <= mappings.length);
   return decoded;
 }
+function indexOf(mappings, index) {
+  const idx = mappings.indexOf(";", index);
+  return idx === -1 ? mappings.length : idx;
+}
+function decodeInteger(mappings, pos, state, j) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = mappings.charCodeAt(pos++);
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  state[j] += value;
+  return pos;
+}
+function hasMoreVlq(mappings, i, length) {
+  if (i >= length)
+    return false;
+  return mappings.charCodeAt(i) !== comma;
+}
 function sort(line) {
   line.sort(sortComparator);
 }
@@ -31320,34 +34671,60 @@ function sortComparator(a, b) {
   return a[0] - b[0];
 }
 function encode(decoded) {
-  const writer = new StringWriter();
-  let sourcesIndex = 0;
-  let sourceLine = 0;
-  let sourceColumn = 0;
-  let namesIndex = 0;
+  const state = new Int32Array(5);
+  const bufLength = 1024 * 16;
+  const subLength = bufLength - 36;
+  const buf = new Uint8Array(bufLength);
+  const sub = buf.subarray(0, subLength);
+  let pos = 0;
+  let out = "";
   for (let i = 0; i < decoded.length; i++) {
     const line = decoded[i];
-    if (i > 0)
-      writer.write(semicolon);
+    if (i > 0) {
+      if (pos === bufLength) {
+        out += td.decode(buf);
+        pos = 0;
+      }
+      buf[pos++] = semicolon;
+    }
     if (line.length === 0)
       continue;
-    let genColumn = 0;
+    state[0] = 0;
     for (let j = 0; j < line.length; j++) {
       const segment = line[j];
+      if (pos > subLength) {
+        out += td.decode(sub);
+        buf.copyWithin(0, subLength, pos);
+        pos -= subLength;
+      }
       if (j > 0)
-        writer.write(comma);
-      genColumn = encodeInteger(writer, segment[0], genColumn);
+        buf[pos++] = comma;
+      pos = encodeInteger(buf, pos, state, segment, 0);
       if (segment.length === 1)
         continue;
-      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
-      sourceLine = encodeInteger(writer, segment[2], sourceLine);
-      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      pos = encodeInteger(buf, pos, state, segment, 1);
+      pos = encodeInteger(buf, pos, state, segment, 2);
+      pos = encodeInteger(buf, pos, state, segment, 3);
       if (segment.length === 4)
         continue;
-      namesIndex = encodeInteger(writer, segment[4], namesIndex);
+      pos = encodeInteger(buf, pos, state, segment, 4);
     }
   }
-  return writer.flush();
+  return out + td.decode(buf.subarray(0, pos));
+}
+function encodeInteger(buf, pos, state, segment, j) {
+  const next = segment[j];
+  let num = next - state[j];
+  state[j] = next;
+  num = num < 0 ? -num << 1 | 1 : num << 1;
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0)
+      clamped |= 32;
+    buf[pos++] = intToChar[clamped];
+  } while (num > 0);
+  return pos;
 }
 
 // node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
@@ -31617,16 +34994,16 @@ var TraceMap = class {
     if (!isString2 && map._decodedMemo)
       return map;
     const parsed = isString2 ? JSON.parse(map) : map;
-    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    const { version, file, names, sourceRoot, sources: sources3, sourcesContent } = parsed;
     this.version = version;
     this.file = file;
     this.names = names || [];
     this.sourceRoot = sourceRoot;
-    this.sources = sources;
+    this.sources = sources3;
     this.sourcesContent = sourcesContent;
     this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
     const from = resolve2(sourceRoot || "", stripFilename(mapUrl));
-    this.resolvedSources = sources.map((s) => resolve2(s || "", from));
+    this.resolvedSources = sources3.map((s) => resolve2(s || "", from));
     const { mappings } = parsed;
     if (typeof mappings === "string") {
       this._encoded = mappings;
@@ -31725,13 +35102,13 @@ var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn
   return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name);
 };
 function setSourceContent(map, source, content) {
-  const { _sources: sources, _sourcesContent: sourcesContent } = cast3(map);
-  const index = put(sources, source);
+  const { _sources: sources3, _sourcesContent: sourcesContent } = cast3(map);
+  const index = put(sources3, source);
   sourcesContent[index] = content;
 }
 function setIgnore(map, source, ignore = true) {
-  const { _sources: sources, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast3(map);
-  const index = put(sources, source);
+  const { _sources: sources3, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast3(map);
+  const index = put(sources3, source);
   if (index === sourcesContent.length)
     sourcesContent[index] = null;
   if (ignore)
@@ -31740,14 +35117,14 @@ function setIgnore(map, source, ignore = true) {
     remove(ignoreList, index);
 }
 function toDecodedMap(map) {
-  const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList } = cast3(map);
+  const { _mappings: mappings, _sources: sources3, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList } = cast3(map);
   removeEmptyFinalLines(mappings);
   return {
     version: 3,
     file: map.file || void 0,
     names: names.array,
     sourceRoot: map.sourceRoot || void 0,
-    sources: sources.array,
+    sources: sources3.array,
     sourcesContent,
     mappings,
     ignoreList: ignoreList.array
@@ -31758,7 +35135,7 @@ function toEncodedMap(map) {
   return Object.assign(Object.assign({}, decoded), { mappings: encode(decoded.mappings) });
 }
 function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
-  const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names } = cast3(map);
+  const { _mappings: mappings, _sources: sources3, _sourcesContent: sourcesContent, _names: names } = cast3(map);
   const line = getLine(mappings, genLine);
   const index = getColumnIndex(line, genColumn);
   if (!source) {
@@ -31766,7 +35143,7 @@ function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLin
       return;
     return insert(line, index, [genColumn]);
   }
-  const sourcesIndex = put(sources, source);
+  const sourcesIndex = put(sources3, source);
   const namesIndex = name ? put(names, name) : NO_NAME;
   if (sourcesIndex === sourcesContent.length)
     sourcesContent[sourcesIndex] = null;
@@ -31827,17 +35204,17 @@ var EMPTY_SOURCES = [];
 function SegmentObject(source, line, column, name, content, ignore) {
   return { source, line, column, name, content, ignore };
 }
-function Source(map, sources, source, content, ignore) {
+function Source(map, sources3, source, content, ignore) {
   return {
     map,
-    sources,
+    sources: sources3,
     source,
     content,
     ignore
   };
 }
-function MapSource(map, sources) {
-  return Source(map, sources, "", null, false);
+function MapSource(map, sources3) {
+  return Source(map, sources3, "", null, false);
 }
 function OriginalSource(source, content, ignore) {
   return Source(null, EMPTY_SOURCES, source, content, ignore);
@@ -32002,7 +35379,7 @@ function unwrapLoader(loader, code, id) {
   return loader;
 }
 function fixSourceMap(map) {
-  if (!Object.prototype.hasOwnProperty.call(map, "toString")) {
+  if (!("toString" in map)) {
     Object.defineProperty(map, "toString", {
       enumerable: false,
       value: function toString() {
@@ -32010,7 +35387,7 @@ function fixSourceMap(map) {
       }
     });
   }
-  if (!Object.prototype.hasOwnProperty.call(map, "toUrl")) {
+  if (!("toUrl" in map)) {
     Object.defineProperty(map, "toUrl", {
       enumerable: false,
       value: function toUrl() {
@@ -32028,9 +35405,8 @@ var nullSourceMap = {
 };
 function combineSourcemaps(filename, sourcemapList) {
   sourcemapList = sourcemapList.filter((m) => m.sources);
-  if (sourcemapList.length === 0 || sourcemapList.every((m) => m.sources.length === 0)) {
+  if (sourcemapList.length === 0 || sourcemapList.every((m) => m.sources.length === 0))
     return { ...nullSourceMap };
-  }
   let map;
   let mapIndex = 1;
   const useArrayInterface = sourcemapList.slice(0, -1).find((m) => m.sources.length !== 1) === void 0;
@@ -32052,9 +35428,8 @@ function combineSourcemaps(filename, sourcemapList) {
     delete map.file;
   return map;
 }
-function createBuildContext(build2) {
+function createBuildContext(initialOptions) {
   const watchFiles = [];
-  const { initialOptions } = build2;
   return {
     parse(code, opts = {}) {
       return Parser.parse(code, {
@@ -32079,9 +35454,6 @@ function createBuildContext(build2) {
     },
     getWatchFiles() {
       return watchFiles;
-    },
-    getNativeBuildContext() {
-      return { framework: "esbuild", build: build2 };
     }
   };
 }
@@ -32090,12 +35462,28 @@ function createPluginContext(context) {
   const warnings = [];
   const pluginContext = {
     error(message) {
-      errors.push(normalizeMessage(message));
+      errors.push(normalizeMessage2(message));
     },
     warn(message) {
-      warnings.push(normalizeMessage(message));
+      warnings.push(normalizeMessage2(message));
     }
   };
+  function normalizeMessage2(message) {
+    if (typeof message === "string")
+      message = { message };
+    return {
+      id: message.id,
+      pluginName: message.plugin,
+      text: message.message,
+      location: message.loc ? {
+        file: message.loc.file,
+        line: message.loc.line,
+        column: message.loc.column
+      } : null,
+      detail: message.meta,
+      notes: []
+    };
+  }
   const mixedContext = {
     ...context,
     ...pluginContext,
@@ -32109,22 +35497,6 @@ function createPluginContext(context) {
     mixedContext
   };
 }
-function normalizeMessage(message) {
-  if (typeof message === "string")
-    message = { message };
-  return {
-    id: message.id,
-    pluginName: message.plugin,
-    text: message.message,
-    location: message.loc ? {
-      file: message.loc.file,
-      line: message.loc.line,
-      column: message.loc.column
-    } : null,
-    detail: message.meta,
-    notes: []
-  };
-}
 function processCodeWithSourceMap(map, code) {
   if (map) {
     if (!map.sourcesContent || map.sourcesContent.length === 0)
@@ -32210,14 +35582,17 @@ function getEsbuildPlugin(factory) {
 }
 function buildSetup(meta) {
   return (plugin) => {
-    return (_build) => {
-      var _a, _b, _c, _d, _e;
-      const build2 = meta.build = _build;
-      const context = createBuildContext(build2);
+    var _a;
+    if ((_a = plugin.esbuild) == null ? void 0 : _a.setup)
+      return plugin.esbuild.setup;
+    return (build2) => {
+      var _a2, _b, _c, _d;
+      meta.build = build2;
       const { onStart, onEnd, onResolve, onLoad, onTransform, initialOptions } = build2;
-      const onResolveFilter = ((_a = plugin.esbuild) == null ? void 0 : _a.onResolveFilter) ?? /.*/;
+      const onResolveFilter = ((_a2 = plugin.esbuild) == null ? void 0 : _a2.onResolveFilter) ?? /.*/;
       const onLoadFilter = ((_b = plugin.esbuild) == null ? void 0 : _b.onLoadFilter) ?? /.*/;
       const loader = ((_c = plugin.esbuild) == null ? void 0 : _c.loader) ?? guessLoader;
+      const context = createBuildContext(initialOptions);
       if ((_d = plugin.esbuild) == null ? void 0 : _d.config)
         plugin.esbuild.config.call(context, initialOptions);
       if (plugin.buildStart)
@@ -32232,8 +35607,8 @@ function buildSetup(meta) {
       }
       if (plugin.resolveId) {
         onResolve({ filter: onResolveFilter }, async (args) => {
-          var _a2;
-          if ((_a2 = initialOptions.external) == null ? void 0 : _a2.includes(args.path)) {
+          var _a3;
+          if ((_a3 = initialOptions.external) == null ? void 0 : _a3.includes(args.path)) {
             return void 0;
           }
           const { errors, warnings, mixedContext } = createPluginContext(context);
@@ -32338,8 +35713,6 @@ function buildSetup(meta) {
           }
         });
       }
-      if ((_e = plugin.esbuild) == null ? void 0 : _e.setup)
-        return plugin.esbuild.setup(meta.build);
     };
   };
 }
@@ -32369,9 +35742,6 @@ function createFarmContext(context, currentResolveId) {
     },
     getWatchFiles() {
       return context.getWatchFiles();
-    },
-    getNativeBuildContext() {
-      return { framework: "farm", context };
     }
   };
 }
@@ -32560,9 +35930,8 @@ function toFarmPlugin(plugin, options) {
       async executor(params, context) {
         if (params.query.length)
           transformQuery(params);
-        if (plugin.transformInclude && !plugin.transformInclude(params.resolvedPath)) {
+        if (plugin.transformInclude && !plugin.transformInclude(params.resolvedPath))
           return null;
-        }
         const loader = params.moduleType ?? guessIdLoader(params.resolvedPath);
         const shouldTransformInclude = plugin.transformInclude && plugin.transformInclude(params.resolvedPath);
         const farmContext = createFarmContext(context, params.resolvedPath);
@@ -32667,22 +36036,8 @@ function getRolldownPlugin(factory) {
     return plugins.length === 1 ? plugins[0] : plugins;
   };
 }
-function createBuildContext2(compiler, compilation, loaderContext) {
+function createBuildContext2(compilation) {
   return {
-    getNativeBuildContext() {
-      return {
-        framework: "rspack",
-        compiler,
-        compilation,
-        loaderContext
-      };
-    },
-    addWatchFile(file) {
-      compilation.fileDependencies.add(resolve$1(process.cwd(), file));
-    },
-    getWatchFiles() {
-      return Array.from(compilation.fileDependencies);
-    },
     parse(code, opts = {}) {
       return Parser.parse(code, {
         sourceType: "module",
@@ -32691,59 +36046,25 @@ function createBuildContext2(compiler, compilation, loaderContext) {
         ...opts
       });
     },
+    addWatchFile() {
+    },
     emitFile(emittedFile) {
       const outFileName = emittedFile.fileName || emittedFile.name;
       if (emittedFile.source && outFileName) {
-        const { sources } = compilation.compiler.webpack;
         compilation.emitAsset(
           outFileName,
-          new sources.RawSource(
+          new sources2.RawSource(
+            // @ts-expect-error types mismatch
             typeof emittedFile.source === "string" ? emittedFile.source : Buffer$1.from(emittedFile.source)
           )
         );
       }
+    },
+    getWatchFiles() {
+      return [];
     }
   };
 }
-function normalizeMessage2(error) {
-  const err = new Error(typeof error === "string" ? error : error.message);
-  if (typeof error === "object") {
-    err.stack = error.stack;
-    err.cause = error.meta;
-  }
-  return err;
-}
-function encodeVirtualModuleId(id, plugin) {
-  return resolve$1(plugin.__virtualModulePrefix, encodeURIComponent(id));
-}
-function decodeVirtualModuleId(encoded, _plugin) {
-  return decodeURIComponent(basename(encoded));
-}
-function isVirtualModuleId(encoded, plugin) {
-  return dirname(encoded) === plugin.__virtualModulePrefix;
-}
-var FakeVirtualModulesPlugin = class {
-  constructor(plugin) {
-    this.plugin = plugin;
-  }
-  name = "FakeVirtualModulesPlugin";
-  apply(compiler) {
-    const dir = this.plugin.__virtualModulePrefix;
-    if (!fs$j.existsSync(dir)) {
-      fs$j.mkdirSync(dir, { recursive: true });
-    }
-    compiler.hooks.shutdown.tap(this.name, () => {
-      if (fs$j.existsSync(dir)) {
-        fs$j.rmdirSync(dir, { recursive: true });
-      }
-    });
-  }
-  async writeModule(file) {
-    const path6 = encodeVirtualModuleId(file, this.plugin);
-    await fs$j.promises.writeFile(path6, "");
-    return path6;
-  }
-};
 
 // src/rspack/index.ts
 var TRANSFORM_LOADER = resolve$1(
@@ -32758,7 +36079,7 @@ function getRspackPlugin(factory) {
   return (userOptions) => {
     return {
       apply(compiler) {
-        const VIRTUAL_MODULE_PREFIX = resolve$1(compiler.options.context ?? process.cwd(), "node_modules/.virtual");
+        const VIRTUAL_MODULE_PREFIX = resolve$1(compiler.options.context ?? process.cwd(), "_virtual_");
         const injected = compiler.$unpluginContext || {};
         compiler.$unpluginContext = injected;
         const meta = {
@@ -32785,66 +36106,18 @@ function getRspackPlugin(factory) {
             });
           });
           const externalModules = /* @__PURE__ */ new Set();
-          if (plugin.resolveId) {
-            const vfs = new FakeVirtualModulesPlugin(plugin);
-            vfs.apply(compiler);
-            plugin.__vfsModules = /* @__PURE__ */ new Set();
-            compiler.hooks.compilation.tap(plugin.name, (compilation, { normalModuleFactory }) => {
-              normalModuleFactory.hooks.resolve.tapPromise(plugin.name, async (resolveData) => {
-                const id = normalizeAbsolutePath(resolveData.request);
-                const requestContext = resolveData.contextInfo;
-                const importer = requestContext.issuer !== "" ? requestContext.issuer : void 0;
-                const isEntry = requestContext.issuer === "";
-                const context = createBuildContext2(compiler, compilation);
-                let error;
-                const pluginContext = {
-                  error(msg) {
-                    if (error == null)
-                      error = normalizeMessage2(msg);
-                    else
-                      console.error(`unplugin/rspack: multiple errors returned from resolveId hook: ${msg}`);
-                  },
-                  warn(msg) {
-                    console.warn(`unplugin/rspack: warning from resolveId hook: ${msg}`);
-                  }
-                };
-                const resolveIdResult = await plugin.resolveId.call({ ...context, ...pluginContext }, id, importer, { isEntry });
-                if (error != null)
-                  throw error;
-                if (resolveIdResult == null)
-                  return;
-                let resolved = typeof resolveIdResult === "string" ? resolveIdResult : resolveIdResult.id;
-                const isExternal = typeof resolveIdResult === "string" ? false : resolveIdResult.external === true;
-                if (isExternal)
-                  externalModules.add(resolved);
-                if (!fs$j.existsSync(resolved)) {
-                  if (!plugin.__vfsModules.has(resolved)) {
-                    plugin.__vfsModules.add(resolved);
-                    await vfs.writeModule(resolved);
-                  }
-                  resolved = encodeVirtualModuleId(resolved, plugin);
-                }
-                resolveData.request = resolved;
-              });
-            });
-          }
           if (plugin.load) {
             compiler.options.module.rules.unshift({
               enforce: plugin.enforce,
               include(id) {
-                if (isVirtualModuleId(id, plugin))
-                  id = decodeVirtualModuleId(id);
-                if (plugin.loadInclude && !plugin.loadInclude(id))
-                  return false;
-                return !externalModules.has(id);
+                return shouldLoad(id, plugin, externalModules);
               },
               use: [{
                 loader: LOAD_LOADER,
                 options: {
                   unpluginName: plugin.name
                 }
-              }],
-              type: "javascript/auto"
+              }]
             });
           }
           if (plugin.transform) {
@@ -32857,30 +36130,15 @@ function getRspackPlugin(factory) {
           }
           if (plugin.rspack)
             plugin.rspack(compiler);
-          if (plugin.watchChange || plugin.buildStart) {
+          if (plugin.buildStart) {
             compiler.hooks.make.tapPromise(plugin.name, async (compilation) => {
-              const context = createBuildContext2(compiler, compilation);
-              if (plugin.watchChange && (compiler.modifiedFiles || compiler.removedFiles)) {
-                const promises = [];
-                if (compiler.modifiedFiles) {
-                  compiler.modifiedFiles.forEach(
-                    (file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "update" })))
-                  );
-                }
-                if (compiler.removedFiles) {
-                  compiler.removedFiles.forEach(
-                    (file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "delete" })))
-                  );
-                }
-                await Promise.all(promises);
-              }
-              if (plugin.buildStart)
-                return await plugin.buildStart.call(context);
+              const context = createBuildContext2(compilation);
+              return plugin.buildStart.call(context);
             });
           }
           if (plugin.buildEnd) {
             compiler.hooks.emit.tapPromise(plugin.name, async (compilation) => {
-              await plugin.buildEnd.call(createBuildContext2(compiler, compilation));
+              await plugin.buildEnd.call(createBuildContext2(compilation));
             });
           }
           if (plugin.writeBundle) {
@@ -32920,9 +36178,7 @@ function contextOptionsFromCompilation(compilation) {
     }
   };
 }
-function createBuildContext3(options, compiler, compilation, loaderContext) {
-  const require2 = createRequire(import.meta.url);
-  const sources = require2("webpack-sources");
+function createBuildContext3(options, compilation) {
   return {
     parse(code, opts = {}) {
       return Parser.parse(code, {
@@ -32942,7 +36198,7 @@ function createBuildContext3(options, compiler, compilation, loaderContext) {
           throw new Error("unplugin/webpack: emitFile outside supported hooks  (buildStart, buildEnd, load, transform, watchChange)");
         compilation.emitAsset(
           outFileName,
-          sources ? new sources.RawSource(
+          sources2 ? new sources2.RawSource(
             // @ts-expect-error types mismatch
             typeof emittedFile.source === "string" ? emittedFile.source : Buffer$1.from(emittedFile.source)
           ) : {
@@ -32954,13 +36210,10 @@ function createBuildContext3(options, compiler, compilation, loaderContext) {
     },
     getWatchFiles() {
       return options.getWatchFiles();
-    },
-    getNativeBuildContext() {
-      return { framework: "webpack", compiler, compilation, loaderContext };
     }
   };
 }
-function normalizeMessage3(error) {
+function normalizeMessage(error) {
   const err = new Error(typeof error === "string" ? error : error.message);
   if (typeof error === "object") {
     err.stack = error.stack;
@@ -33037,12 +36290,12 @@ function getWebpackPlugin(factory) {
                     getWatchFiles() {
                       return Array.from(fileDependencies);
                     }
-                  }, compiler);
+                  });
                   let error;
                   const pluginContext = {
                     error(msg) {
                       if (error == null)
-                        error = normalizeMessage3(msg);
+                        error = normalizeMessage(msg);
                       else
                         console.error(`unplugin/webpack: multiple errors returned from resolveId hook: ${msg}`);
                     },
@@ -33091,8 +36344,7 @@ function getWebpackPlugin(factory) {
                 options: {
                   unpluginName: plugin.name
                 }
-              }],
-              type: "javascript/auto"
+              }]
             });
           }
           if (plugin.transform) {
@@ -33107,7 +36359,7 @@ function getWebpackPlugin(factory) {
             plugin.webpack(compiler);
           if (plugin.watchChange || plugin.buildStart) {
             compiler.hooks.make.tapPromise(plugin.name, async (compilation) => {
-              const context = createBuildContext3(contextOptionsFromCompilation(compilation), compiler, compilation);
+              const context = createBuildContext3(contextOptionsFromCompilation(compilation), compilation);
               if (plugin.watchChange && (compiler.modifiedFiles || compiler.removedFiles)) {
                 const promises = [];
                 if (compiler.modifiedFiles) {
@@ -33128,7 +36380,7 @@ function getWebpackPlugin(factory) {
           }
           if (plugin.buildEnd) {
             compiler.hooks.emit.tapPromise(plugin.name, async (compilation) => {
-              await plugin.buildEnd.call(createBuildContext3(contextOptionsFromCompilation(compilation), compiler, compilation));
+              await plugin.buildEnd.call(createBuildContext3(contextOptionsFromCompilation(compilation), compilation));
             });
           }
           if (plugin.writeBundle) {
@@ -33161,6 +36413,7 @@ function createUnplugin(factory) {
     get webpack() {
       return getWebpackPlugin(factory);
     },
+    /** @experimental do not use it in production */
     get rspack() {
       return getRspackPlugin(factory);
     },
@@ -33216,7 +36469,7 @@ const buildPluginFactory = ({
 
 var name = "@datadog/esbuild-plugin";
 var packageManager = "yarn@4.0.2";
-var version$1 = "2.3.1-dev-1";
+var version$1 = "2.3.1-dev-3";
 var license = "MIT";
 var author = "Datadog";
 var description = "Datadog ESBuild Plugin";