@rollup/wasm-node 4.23.0 → 4.24.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.23.0
-	Tue, 01 Oct 2024 07:09:35 GMT - commit ed98e0821e6ad064839f0af46ceca061adbe3f14
+	Rollup.js v4.24.1
+	Sun, 27 Oct 2024 06:42:30 GMT - commit 88a54d892dacbb0efdbcade263a32d9df1a77b37
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.23.0";
+var version = "4.24.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -698,6 +698,32 @@ const treeshakePresets = {
         unknownGlobalSideEffects: false
     }
 };
+const jsxPresets = {
+    preserve: {
+        factory: null,
+        fragment: null,
+        importSource: null,
+        mode: 'preserve'
+    },
+    'preserve-react': {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'preserve'
+    },
+    react: {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'classic'
+    },
+    'react-jsx': {
+        factory: 'React.createElement',
+        importSource: 'react',
+        jsxImportSource: 'react/jsx-runtime',
+        mode: 'automatic'
+    }
+};
 const generatedCodePresets = {
     es2015: {
         arrowFunctions: true,
@@ -1260,6 +1286,7 @@ function mergeInputOptions(config, overrides, plugins, log, onLog) {
         experimentalLogSideEffects: getOption('experimentalLogSideEffects'),
         external: getExternal(config, overrides),
         input: getOption('input') || [],
+        jsx: getObjectOption(config, overrides, 'jsx', objectifyOptionWithPresets(jsxPresets, 'jsx', parseAst_js.URL_JSX, 'false, ')),
         logLevel: getOption('logLevel'),
         makeAbsoluteExternalsRelative: getOption('makeAbsoluteExternalsRelative'),
         maxParallelFileOps: getOption('maxParallelFileOps'),
@@ -2110,27 +2137,6 @@ class Mappings {
 		let charInHiresBoundary = false;
 
 		while (originalCharIndex < chunk.end) {
-			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
-				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
-
-				if (this.hires === 'boundary') {
-					// in hires "boundary", group segments per word boundary than per char
-					if (wordRegex.test(original[originalCharIndex])) {
-						// for first char in the boundary found, start the boundary by pushing a segment
-						if (!charInHiresBoundary) {
-							this.rawSegments.push(segment);
-							charInHiresBoundary = true;
-						}
-					} else {
-						// for non-word char, end the boundary by pushing a segment
-						this.rawSegments.push(segment);
-						charInHiresBoundary = false;
-					}
-				} else {
-					this.rawSegments.push(segment);
-				}
-			}
-
 			if (original[originalCharIndex] === '\n') {
 				loc.line += 1;
 				loc.column = 0;
@@ -2139,6 +2145,27 @@ class Mappings {
 				this.generatedCodeColumn = 0;
 				first = true;
 			} else {
+				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+					const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+					if (this.hires === 'boundary') {
+						// in hires "boundary", group segments per word boundary than per char
+						if (wordRegex.test(original[originalCharIndex])) {
+							// for first char in the boundary found, start the boundary by pushing a segment
+							if (!charInHiresBoundary) {
+								this.rawSegments.push(segment);
+								charInHiresBoundary = true;
+							}
+						} else {
+							// for non-word char, end the boundary by pushing a segment
+							this.rawSegments.push(segment);
+							charInHiresBoundary = false;
+						}
+					} else {
+						this.rawSegments.push(segment);
+					}
+				}
+
 				loc.column += 1;
 				this.generatedCodeColumn += 1;
 				first = false;
@@ -3711,6 +3738,7 @@ class Variable extends ExpressionEntity {
         this.name = name;
         this.alwaysRendered = false;
         this.forbiddenNames = null;
+        this.globalName = null;
         this.initReached = false;
         this.isId = false;
         this.kind = null;
@@ -3756,6 +3784,9 @@ class Variable extends ExpressionEntity {
             this.name);
     }
     getName(getPropertyAccess, useOriginalName) {
+        if (this.globalName) {
+            return this.globalName;
+        }
         if (useOriginalName?.(this)) {
             return this.name;
         }
@@ -3769,10 +3800,10 @@ class Variable extends ExpressionEntity {
         return type !== INTERACTION_ACCESSED || path.length > 0;
     }
     /**
-     * Marks this variable as being part of the bundle, which is usually the case when one of
-     * its identifiers becomes part of the bundle. Returns true if it has not been included
-     * previously.
-     * Once a variable is included, it should take care all its declarations are included.
+     * Marks this variable as being part of the bundle, which is usually the case
+     * when one of its identifiers becomes part of the bundle. Returns true if it
+     * has not been included previously. Once a variable is included, it should
+     * take care all its declarations are included.
      */
     include() {
         this.included = true;
@@ -4258,6 +4289,21 @@ const childNodeKeys = {
     ImportExpression: ['source', 'options'],
     ImportNamespaceSpecifier: ['local'],
     ImportSpecifier: ['imported', 'local'],
+    JSXAttribute: ['name', 'value'],
+    JSXClosingElement: ['name'],
+    JSXClosingFragment: [],
+    JSXElement: ['openingElement', 'children', 'closingElement'],
+    JSXEmptyExpression: [],
+    JSXExpressionContainer: ['expression'],
+    JSXFragment: ['openingFragment', 'children', 'closingFragment'],
+    JSXIdentifier: [],
+    JSXMemberExpression: ['object', 'property'],
+    JSXNamespacedName: ['namespace', 'name'],
+    JSXOpeningElement: ['name', 'attributes'],
+    JSXOpeningFragment: [],
+    JSXSpreadAttribute: ['argument'],
+    JSXSpreadChild: ['expression'],
+    JSXText: [],
     LabeledStatement: ['label', 'body'],
     Literal: [],
     LogicalExpression: ['left', 'right'],
@@ -6372,11 +6418,11 @@ class LocalVariable extends Variable {
 }
 
 const tdzVariableKinds = new Set(['class', 'const', 'let', 'var', 'using', 'await using']);
-class Identifier extends NodeBase {
+class IdentifierBase extends NodeBase {
     constructor() {
         super(...arguments);
         this.variable = null;
-        this.isReferenceVariable = false;
+        this.isVariableReference = false;
     }
     get isTDZAccess() {
         if (!isFlagSet(this.flags, 4 /* Flag.tdzAccessDefined */)) {
@@ -6388,55 +6434,6 @@ class Identifier extends NodeBase {
         this.flags = setFlag(this.flags, 4 /* Flag.tdzAccessDefined */, true);
         this.flags = setFlag(this.flags, 8 /* Flag.tdzAccess */, value);
     }
-    addExportedVariables(variables, exportNamesByVariable) {
-        if (exportNamesByVariable.has(this.variable)) {
-            variables.push(this.variable);
-        }
-    }
-    bind() {
-        if (!this.variable && is_reference(this, this.parent)) {
-            this.variable = this.scope.findVariable(this.name);
-            this.variable.addReference(this);
-            this.isReferenceVariable = true;
-        }
-    }
-    declare(kind, init) {
-        let variable;
-        const { treeshake } = this.scope.context.options;
-        switch (kind) {
-            case 'var': {
-                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
-                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
-                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
-                    variable.markInitializersForDeoptimization();
-                }
-                break;
-            }
-            case 'function': {
-                // in strict mode, functions are only hoisted within a scope but not across block scopes
-                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
-                break;
-            }
-            case 'let':
-            case 'const':
-            case 'using':
-            case 'await using':
-            case 'class': {
-                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
-                break;
-            }
-            case 'parameter': {
-                variable = this.scope.addParameterDeclaration(this);
-                break;
-            }
-            /* istanbul ignore next */
-            default: {
-                /* istanbul ignore next */
-                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
-            }
-        }
-        return [(this.variable = variable)];
-    }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
     }
@@ -6527,32 +6524,6 @@ class Identifier extends NodeBase {
         }
         return (this.isTDZAccess = false);
     }
-    markDeclarationReached() {
-        this.variable.initReached = true;
-    }
-    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = parseAst_js.BLANK) {
-        if (this.variable) {
-            const name = this.variable.getName(getPropertyAccess, useOriginalName);
-            if (name !== this.name) {
-                code.overwrite(this.start, this.end, name, {
-                    contentOnly: true,
-                    storeName: true
-                });
-                if (isShorthandProperty) {
-                    code.prependRight(this.start, `${this.name}: `);
-                }
-            }
-            // In strict mode, any variable named "eval" must be the actual "eval" function
-            if (name === 'eval' &&
-                renderedParentType === parseAst_js.CallExpression &&
-                isCalleeOfRenderedParent) {
-                code.appendRight(this.start, '0, ');
-            }
-        }
-    }
-    disallowImportReassignment() {
-        return this.scope.context.error(parseAst_js.logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
-    }
     applyDeoptimizations() {
         this.deoptimized = true;
         if (this.variable instanceof LocalVariable) {
@@ -6565,11 +6536,14 @@ class Identifier extends NodeBase {
             this.variable.consolidateInitializers();
             this.scope.context.requestTreeshakingPass();
         }
-        if (this.isReferenceVariable) {
+        if (this.isVariableReference) {
             this.variable.addUsedPlace(this);
             this.scope.context.requestTreeshakingPass();
         }
     }
+    disallowImportReassignment() {
+        return this.scope.context.error(parseAst_js.logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
+    }
     getVariableRespectingTDZ() {
         if (this.isPossibleTDZ()) {
             return UNKNOWN_EXPRESSION;
@@ -6600,6 +6574,85 @@ function closestParentFunctionOrProgram(node) {
     return node;
 }
 
+class Identifier extends IdentifierBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        if (exportNamesByVariable.has(this.variable)) {
+            variables.push(this.variable);
+        }
+    }
+    bind() {
+        if (!this.variable && is_reference(this, this.parent)) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+            this.isVariableReference = true;
+        }
+    }
+    declare(kind, init) {
+        let variable;
+        const { treeshake } = this.scope.context.options;
+        switch (kind) {
+            case 'var': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
+                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
+                    variable.markInitializersForDeoptimization();
+                }
+                break;
+            }
+            case 'function': {
+                // in strict mode, functions are only hoisted within a scope but not across block scopes
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'let':
+            case 'const':
+            case 'using':
+            case 'await using':
+            case 'class': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'parameter': {
+                variable = this.scope.addParameterDeclaration(this);
+                break;
+            }
+            /* istanbul ignore next */
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+            }
+        }
+        return [(this.variable = variable)];
+    }
+    markDeclarationReached() {
+        this.variable.initReached = true;
+    }
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = parseAst_js.BLANK) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess, useOriginalName);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+                if (isShorthandProperty) {
+                    code.prependRight(this.start, `${this.name}: `);
+                }
+            }
+            // In strict mode, any variable named "eval" must be the actual "eval" function
+            if (name === 'eval' &&
+                renderedParentType === parseAst_js.CallExpression &&
+                isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+        }
+    }
+}
+
 function getSafeName(baseName, usedNames, forbiddenNames) {
     let safeName = baseName;
     let count = 1;
@@ -6728,6 +6781,11 @@ class ChildScope extends Scope {
     findLexicalBoundary() {
         return this.parent.findLexicalBoundary();
     }
+    findGlobal(name) {
+        const variable = this.parent.findVariable(name);
+        this.accessedOutsideVariables.set(name, variable);
+        return variable;
+    }
     findVariable(name) {
         const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
         if (knownVariable) {
@@ -9997,7 +10055,6 @@ function requireConstants () {
 	if (hasRequiredConstants) return constants;
 	hasRequiredConstants = 1;
 
-	const path = require$$0;
 	const WIN_SLASH = '\\\\/';
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -10020,6 +10077,7 @@ function requireConstants () {
 	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
 	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
 	const STAR = `${QMARK}*?`;
+	const SEP = '/';
 
 	const POSIX_CHARS = {
 	  DOT_LITERAL,
@@ -10036,7 +10094,8 @@ function requireConstants () {
 	  NO_DOTS_SLASH,
 	  QMARK_NO_DOT,
 	  STAR,
-	  START_ANCHOR
+	  START_ANCHOR,
+	  SEP
 	};
 
 	/**
@@ -10056,7 +10115,8 @@ function requireConstants () {
 	  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
 	  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
 	  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+	  SEP: '\\'
 	};
 
 	/**
@@ -10150,8 +10210,6 @@ function requireConstants () {
 	  CHAR_VERTICAL_LINE: 124, /* | */
 	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-	  SEP: path.sep,
-
 	  /**
 	   * Create EXTGLOB_CHARS
 	   */
@@ -10177,6 +10235,8 @@ function requireConstants () {
 	return constants;
 }
 
+/*global navigator*/
+
 var hasRequiredUtils;
 
 function requireUtils () {
@@ -10184,8 +10244,6 @@ function requireUtils () {
 	hasRequiredUtils = 1;
 	(function (exports) {
 
-		const path = require$$0;
-		const win32 = process.platform === 'win32';
 		const {
 		  REGEX_BACKSLASH,
 		  REGEX_REMOVE_BACKSLASH,
@@ -10199,25 +10257,23 @@ function requireUtils () {
 		exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
 		exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
 
-		exports.removeBackslashes = str => {
-		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
-		    return match === '\\' ? '' : match;
-		  });
-		};
+		exports.isWindows = () => {
+		  if (typeof navigator !== 'undefined' && navigator.platform) {
+		    const platform = navigator.platform.toLowerCase();
+		    return platform === 'win32' || platform === 'windows';
+		  }
 
-		exports.supportsLookbehinds = () => {
-		  const segs = process.version.slice(1).split('.').map(Number);
-		  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
-		    return true;
+		  if (typeof process !== 'undefined' && process.platform) {
+		    return process.platform === 'win32';
 		  }
+
 		  return false;
 		};
 
-		exports.isWindows = options => {
-		  if (options && typeof options.windows === 'boolean') {
-		    return options.windows;
-		  }
-		  return win32 === true || path.sep === '\\';
+		exports.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
 		};
 
 		exports.escapeLast = (input, char, lastIdx) => {
@@ -10245,6 +10301,17 @@ function requireUtils () {
 		    output = `(?:^(?!${output}).*$)`;
 		  }
 		  return output;
+		};
+
+		exports.basename = (path, { windows } = {}) => {
+		  const segs = path.split(windows ? /[\\/]/ : '/');
+		  const last = segs[segs.length - 1];
+
+		  if (last === '') {
+		    return segs[segs.length - 2];
+		  }
+
+		  return last;
 		}; 
 	} (utils));
 	return utils;
@@ -10720,10 +10787,9 @@ function requireParse () {
 	  const tokens = [bos];
 
 	  const capture = opts.capture ? '' : '?:';
-	  const win32 = utils.isWindows(options);
 
 	  // create constants based on platform, for windows or posix
-	  const PLATFORM_CHARS = constants.globChars(win32);
+	  const PLATFORM_CHARS = constants.globChars(opts.windows);
 	  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
 
 	  const {
@@ -10859,8 +10925,8 @@ function requireParse () {
 
 	    if (tok.value || tok.output) append(tok);
 	    if (prev && prev.type === 'text' && tok.type === 'text') {
+	      prev.output = (prev.output || prev.value) + tok.value;
 	      prev.value += tok.value;
-	      prev.output = (prev.output || '') + tok.value;
 	      return;
 	    }
 
@@ -11348,10 +11414,6 @@ function requireParse () {
 	        const next = peek();
 	        let output = value;
 
-	        if (next === '<' && !utils.supportsLookbehinds()) {
-	          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
-	        }
-
 	        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
 	          output = `\\${value}`;
 	        }
@@ -11659,7 +11721,6 @@ function requireParse () {
 	  }
 
 	  input = REPLACEMENTS[input] || input;
-	  const win32 = utils.isWindows(options);
 
 	  // create constants based on platform, for windows or posix
 	  const {
@@ -11672,7 +11733,7 @@ function requireParse () {
 	    NO_DOTS_SLASH,
 	    STAR,
 	    START_ANCHOR
-	  } = constants.globChars(win32);
+	  } = constants.globChars(opts.windows);
 
 	  const nodot = opts.dot ? NO_DOTS : NO_DOT;
 	  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
@@ -11741,14 +11802,13 @@ function requireParse () {
 	return parse_1;
 }
 
-var picomatch_1;
+var picomatch_1$1;
 var hasRequiredPicomatch$1;
 
 function requirePicomatch$1 () {
-	if (hasRequiredPicomatch$1) return picomatch_1;
+	if (hasRequiredPicomatch$1) return picomatch_1$1;
 	hasRequiredPicomatch$1 = 1;
 
-	const path = require$$0;
 	const scan = /*@__PURE__*/ requireScan();
 	const parse = /*@__PURE__*/ requireParse();
 	const utils = /*@__PURE__*/ requireUtils();
@@ -11797,7 +11857,7 @@ function requirePicomatch$1 () {
 	  }
 
 	  const opts = options || {};
-	  const posix = utils.isWindows(options);
+	  const posix = opts.windows;
 	  const regex = isState
 	    ? picomatch.compileRe(glob, options)
 	    : picomatch.makeRe(glob, options, false, true);
@@ -11906,9 +11966,9 @@ function requirePicomatch$1 () {
 	 * @api public
 	 */
 
-	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+	picomatch.matchBase = (input, glob, options) => {
 	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-	  return regex.test(path.basename(input));
+	  return regex.test(utils.basename(input));
 	};
 
 	/**
@@ -12087,19 +12147,33 @@ function requirePicomatch$1 () {
 	 * Expose "picomatch"
 	 */
 
-	picomatch_1 = picomatch;
-	return picomatch_1;
+	picomatch_1$1 = picomatch;
+	return picomatch_1$1;
 }
 
-var picomatch;
+var picomatch_1;
 var hasRequiredPicomatch;
 
 function requirePicomatch () {
-	if (hasRequiredPicomatch) return picomatch;
+	if (hasRequiredPicomatch) return picomatch_1;
 	hasRequiredPicomatch = 1;
 
-	picomatch = /*@__PURE__*/ requirePicomatch$1();
-	return picomatch;
+	const pico = /*@__PURE__*/ requirePicomatch$1();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	function picomatch(glob, options, returnState = false) {
+	  // default to os.platform()
+	  if (options && (options.windows === null || options.windows === undefined)) {
+	    // don't mutate the original options object
+	    options = { ...options, windows: utils.isWindows() };
+	  }
+
+	  return pico(glob, options, returnState);
+	}
+
+	Object.assign(picomatch, pico);
+	picomatch_1 = picomatch;
+	return picomatch_1;
 }
 
 var picomatchExports = /*@__PURE__*/ requirePicomatch();
@@ -13892,6 +13966,497 @@ class ImportSpecifier extends NodeBase {
     applyDeoptimizations() { }
 }
 
+class JSXIdentifier extends IdentifierBase {
+    constructor() {
+        super(...arguments);
+        this.isNativeElement = false;
+    }
+    bind() {
+        const type = this.getType();
+        if (type === 0 /* IdentifierType.Reference */) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+        }
+        else if (type === 1 /* IdentifierType.NativeElementName */) {
+            this.isNativeElement = true;
+        }
+    }
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess, useOriginalName);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+            }
+        }
+        else if (this.isNativeElement &&
+            this.scope.context.options.jsx.mode !== 'preserve') {
+            code.update(this.start, this.end, JSON.stringify(this.name));
+        }
+    }
+    getType() {
+        switch (this.parent.type) {
+            case 'JSXOpeningElement':
+            case 'JSXClosingElement': {
+                return this.name.startsWith(this.name.charAt(0).toUpperCase())
+                    ? 0 /* IdentifierType.Reference */
+                    : 1 /* IdentifierType.NativeElementName */;
+            }
+            case 'JSXMemberExpression': {
+                return this.parent.object === this
+                    ? 0 /* IdentifierType.Reference */
+                    : 2 /* IdentifierType.Other */;
+            }
+            case 'JSXAttribute':
+            case 'JSXNamespacedName': {
+                return 2 /* IdentifierType.Other */;
+            }
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Unexpected parent node type for JSXIdentifier: ${this.parent.type}`);
+            }
+        }
+    }
+}
+
+class JSXAttribute extends NodeBase {
+    render(code, options, { jsxMode } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (['classic', 'automatic'].includes(jsxMode)) {
+            const { name, value } = this;
+            const key = name instanceof JSXIdentifier ? name.name : `${name.namespace.name}:${name.name.name}`;
+            if (!(jsxMode === 'automatic' && key === 'key')) {
+                const safeKey = stringifyObjectKeyIfNeeded(key);
+                if (key !== safeKey) {
+                    code.overwrite(name.start, name.end, safeKey, { contentOnly: true });
+                }
+                if (value) {
+                    code.overwrite(name.end, value.start, ': ', { contentOnly: true });
+                }
+                else {
+                    code.appendLeft(name.end, ': true');
+                }
+            }
+        }
+    }
+}
+
+class JSXClosingBase extends NodeBase {
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.end, ')', { contentOnly: true });
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+
+class JSXClosingElement extends JSXClosingBase {
+}
+
+class JSXClosingFragment extends JSXClosingBase {
+}
+
+class JSXSpreadAttribute extends NodeBase {
+    render(code, options) {
+        this.argument.render(code, options);
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.argument.start, '', { contentOnly: true });
+            code.overwrite(this.argument.end, this.end, '', { contentOnly: true });
+        }
+    }
+}
+
+class JSXEmptyExpression extends NodeBase {
+}
+
+class JSXExpressionContainer extends NodeBase {
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.remove(this.start, this.expression.start);
+            code.remove(this.expression.end, this.end);
+        }
+        this.expression.render(code, options);
+    }
+}
+
+function getRenderedJsxChildren(children) {
+    let renderedChildren = 0;
+    for (const child of children) {
+        if (!(child instanceof JSXExpressionContainer && child.expression instanceof JSXEmptyExpression)) {
+            renderedChildren++;
+        }
+    }
+    return renderedChildren;
+}
+
+function getAndIncludeFactoryVariable(factory, preserve, importSource, node) {
+    const [baseName, nestedName] = factory.split('.');
+    let factoryVariable;
+    if (importSource) {
+        factoryVariable = node.scope.context.getImportedJsxFactoryVariable(nestedName ? 'default' : baseName, node.start, importSource);
+        if (preserve) {
+            // This pretends we are accessing an included global variable of the same name
+            const globalVariable = node.scope.findGlobal(baseName);
+            globalVariable.include();
+            // This excludes this variable from renaming
+            factoryVariable.globalName = baseName;
+        }
+    }
+    else {
+        factoryVariable = node.scope.findGlobal(baseName);
+    }
+    node.scope.context.includeVariableInModule(factoryVariable);
+    if (factoryVariable instanceof LocalVariable) {
+        factoryVariable.consolidateInitializers();
+        factoryVariable.addUsedPlace(node);
+        node.scope.context.requestTreeshakingPass();
+    }
+    return factoryVariable;
+}
+
+class JSXElementBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.factoryVariable = null;
+        this.factory = null;
+    }
+    initialise() {
+        super.initialise();
+        const { importSource } = (this.jsxMode = this.getRenderingMode());
+        if (importSource) {
+            this.scope.context.addImportSource(importSource);
+        }
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            const { factory, importSource, mode } = this.jsxMode;
+            if (factory) {
+                this.factory = factory;
+                this.factoryVariable = getAndIncludeFactoryVariable(factory, mode === 'preserve', importSource, this);
+            }
+        }
+        super.include(context, includeChildrenRecursively);
+    }
+    applyDeoptimizations() { }
+    getRenderingMode() {
+        const jsx = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx;
+        if (mode === 'automatic') {
+            return {
+                factory: getRenderedJsxChildren(this.children) > 1 ? 'jsxs' : 'jsx',
+                importSource: jsx.jsxImportSource,
+                mode
+            };
+        }
+        return { factory, importSource, mode };
+    }
+    renderChildren(code, options, openingEnd) {
+        const { children } = this;
+        let hasMultipleChildren = false;
+        let childrenEnd = openingEnd;
+        let firstChild = null;
+        for (const child of children) {
+            if (child instanceof JSXExpressionContainer &&
+                child.expression instanceof JSXEmptyExpression) {
+                code.remove(childrenEnd, child.end);
+            }
+            else {
+                code.appendLeft(childrenEnd, ', ');
+                child.render(code, options);
+                if (firstChild) {
+                    hasMultipleChildren = true;
+                }
+                else {
+                    firstChild = child;
+                }
+            }
+            childrenEnd = child.end;
+        }
+        return { childrenEnd, firstChild, hasMultipleChildren };
+    }
+}
+
+class JSXElement extends JSXElementBase {
+    render(code, options) {
+        switch (this.jsxMode.mode) {
+            case 'classic': {
+                this.renderClassicMode(code, options);
+                break;
+            }
+            case 'automatic': {
+                this.renderAutomaticMode(code, options);
+                break;
+            }
+            default: {
+                super.render(code, options);
+            }
+        }
+    }
+    getRenderingMode() {
+        const jsx = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx;
+        if (mode === 'automatic') {
+            // In the case there is a key after a spread attribute, we fall back to
+            // classic mode, see https://github.com/facebook/react/issues/20031#issuecomment-710346866
+            // for reasoning.
+            let hasSpread = false;
+            for (const attribute of this.openingElement.attributes) {
+                if (attribute instanceof JSXSpreadAttribute) {
+                    hasSpread = true;
+                }
+                else if (hasSpread && attribute.name.name === 'key') {
+                    return { factory, importSource, mode: 'classic' };
+                }
+            }
+        }
+        return super.getRenderingMode();
+    }
+    renderClassicMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingElement, end, factory, factoryVariable, openingElement: { end: openingEnd, selfClosing } } = this;
+        const [, ...nestedName] = factory.split('.');
+        const { firstAttribute, hasAttributes, hasSpread, inObject, previousEnd } = this.renderAttributes(code, options, [factoryVariable.getName(getPropertyAccess, useOriginalName), ...nestedName].join('.'), false);
+        this.wrapAttributes(code, inObject, hasAttributes, hasSpread, firstAttribute, 'null', previousEnd);
+        this.renderChildren(code, options, openingEnd);
+        if (selfClosing) {
+            code.appendLeft(end, ')');
+        }
+        else {
+            closingElement.render(code, options);
+        }
+    }
+    renderAutomaticMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingElement, end, factoryVariable, openingElement: { end: openindEnd, selfClosing } } = this;
+        let { firstAttribute, hasAttributes, hasSpread, inObject, keyAttribute, previousEnd } = this.renderAttributes(code, options, factoryVariable.getName(getPropertyAccess, useOriginalName), true);
+        const { firstChild, hasMultipleChildren, childrenEnd } = this.renderChildren(code, options, openindEnd);
+        if (firstChild) {
+            code.prependRight(firstChild.start, `children: ${hasMultipleChildren ? '[' : ''}`);
+            if (!inObject) {
+                code.prependRight(firstChild.start, '{ ');
+                inObject = true;
+            }
+            previousEnd = closingElement.start;
+            if (hasMultipleChildren) {
+                code.appendLeft(previousEnd, ']');
+            }
+        }
+        this.wrapAttributes(code, inObject, hasAttributes || !!firstChild, hasSpread, firstAttribute || firstChild, '{}', childrenEnd);
+        if (keyAttribute) {
+            const { value } = keyAttribute;
+            // This will appear to the left of the moved code...
+            code.appendLeft(childrenEnd, ', ');
+            if (value) {
+                code.move(value.start, value.end, childrenEnd);
+            }
+            else {
+                code.appendLeft(childrenEnd, 'true');
+            }
+        }
+        if (selfClosing) {
+            // Moving the key attribute will also move the parenthesis to the right position
+            code.appendLeft(keyAttribute?.value?.end || end, ')');
+        }
+        else {
+            closingElement.render(code, options);
+        }
+    }
+    renderAttributes(code, options, factoryName, extractKeyAttribute) {
+        const { jsxMode: { mode }, openingElement } = this;
+        const { attributes, end: openingEnd, start: openingStart, name: { start: nameStart, end: nameEnd } } = openingElement;
+        code.update(openingStart, nameStart, `/*#__PURE__*/${factoryName}(`);
+        openingElement.render(code, options, { jsxMode: mode });
+        let keyAttribute = null;
+        let hasSpread = false;
+        let inObject = false;
+        let previousEnd = nameEnd;
+        let hasAttributes = false;
+        let firstAttribute = null;
+        for (const attribute of attributes) {
+            if (attribute instanceof JSXAttribute) {
+                if (extractKeyAttribute && attribute.name.name === 'key') {
+                    keyAttribute = attribute;
+                    code.remove(previousEnd, attribute.value?.start || attribute.end);
+                    continue;
+                }
+                code.appendLeft(previousEnd, ',');
+                if (!inObject) {
+                    code.prependRight(attribute.start, '{ ');
+                    inObject = true;
+                }
+                hasAttributes = true;
+            }
+            else {
+                if (inObject) {
+                    if (hasAttributes) {
+                        code.appendLeft(previousEnd, ' ');
+                    }
+                    code.appendLeft(previousEnd, '},');
+                    inObject = false;
+                }
+                else {
+                    code.appendLeft(previousEnd, ',');
+                }
+                hasSpread = true;
+            }
+            previousEnd = attribute.end;
+            if (!firstAttribute) {
+                firstAttribute = attribute;
+            }
+        }
+        code.remove(attributes.at(-1)?.end || previousEnd, openingEnd);
+        return { firstAttribute, hasAttributes, hasSpread, inObject, keyAttribute, previousEnd };
+    }
+    wrapAttributes(code, inObject, hasAttributes, hasSpread, firstAttribute, missingAttributesFallback, attributesEnd) {
+        if (inObject) {
+            code.appendLeft(attributesEnd, ' }');
+        }
+        if (hasSpread) {
+            if (hasAttributes) {
+                const { start } = firstAttribute;
+                if (firstAttribute instanceof JSXSpreadAttribute) {
+                    code.prependRight(start, '{}, ');
+                }
+                code.prependRight(start, 'Object.assign(');
+                code.appendLeft(attributesEnd, ')');
+            }
+        }
+        else if (!hasAttributes) {
+            code.appendLeft(attributesEnd, `, ${missingAttributesFallback}`);
+        }
+    }
+}
+
+class JSXFragment extends JSXElementBase {
+    render(code, options) {
+        switch (this.jsxMode.mode) {
+            case 'classic': {
+                this.renderClassicMode(code, options);
+                break;
+            }
+            case 'automatic': {
+                this.renderAutomaticMode(code, options);
+                break;
+            }
+            default: {
+                super.render(code, options);
+            }
+        }
+    }
+    renderClassicMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingFragment, factory, factoryVariable, openingFragment, start } = this;
+        const [, ...nestedName] = factory.split('.');
+        openingFragment.render(code, options);
+        code.prependRight(start, `/*#__PURE__*/${[
+            factoryVariable.getName(getPropertyAccess, useOriginalName),
+            ...nestedName
+        ].join('.')}(`);
+        code.appendLeft(openingFragment.end, ', null');
+        this.renderChildren(code, options, openingFragment.end);
+        closingFragment.render(code, options);
+    }
+    renderAutomaticMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingFragment, factoryVariable, openingFragment, start } = this;
+        openingFragment.render(code, options);
+        code.prependRight(start, `/*#__PURE__*/${factoryVariable.getName(getPropertyAccess, useOriginalName)}(`);
+        const { firstChild, hasMultipleChildren, childrenEnd } = this.renderChildren(code, options, openingFragment.end);
+        if (firstChild) {
+            code.prependRight(firstChild.start, `{ children: ${hasMultipleChildren ? '[' : ''}`);
+            if (hasMultipleChildren) {
+                code.appendLeft(closingFragment.start, ']');
+            }
+            code.appendLeft(childrenEnd, ' }');
+        }
+        else {
+            code.appendLeft(openingFragment.end, ', {}');
+        }
+        closingFragment.render(code, options);
+    }
+}
+
+class JSXMemberExpression extends NodeBase {
+}
+
+class JSXNamespacedName extends NodeBase {
+}
+
+class JSXOpeningElement extends NodeBase {
+    render(code, options, { jsxMode = this.scope.context.options.jsx.mode } = {}) {
+        this.name.render(code, options);
+        for (const attribute of this.attributes) {
+            attribute.render(code, options, { jsxMode });
+        }
+    }
+}
+
+class JSXOpeningFragment extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.fragment = null;
+        this.fragmentVariable = null;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            const jsx = this.scope.context.options.jsx;
+            if (jsx.mode === 'automatic') {
+                this.fragment = 'Fragment';
+                this.fragmentVariable = getAndIncludeFactoryVariable('Fragment', false, jsx.jsxImportSource, this);
+            }
+            else {
+                const { fragment, importSource, mode } = jsx;
+                if (fragment != null) {
+                    this.fragment = fragment;
+                    this.fragmentVariable = getAndIncludeFactoryVariable(fragment, mode === 'preserve', importSource, this);
+                }
+            }
+        }
+        super.include(context, includeChildrenRecursively);
+    }
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            const { snippets: { getPropertyAccess }, useOriginalName } = options;
+            const [, ...nestedFragment] = this.fragment.split('.');
+            const fragment = [
+                this.fragmentVariable.getName(getPropertyAccess, useOriginalName),
+                ...nestedFragment
+            ].join('.');
+            code.update(this.start, this.end, fragment);
+        }
+    }
+}
+
+class JSXSpreadChild extends NodeBase {
+    render(code, options) {
+        super.render(code, options);
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.expression.start, '...', { contentOnly: true });
+            code.overwrite(this.expression.end, this.end, '', { contentOnly: true });
+        }
+    }
+}
+
+class JSXText extends NodeBase {
+    render(code) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.end, JSON.stringify(this.value), {
+                contentOnly: true
+            });
+        }
+    }
+}
+
 class LabeledStatement extends NodeBase {
     hasEffects(context) {
         const { brokenFlow, includedLabels } = context;
@@ -15220,6 +15785,21 @@ const nodeTypeStrings = [
     'ImportExpression',
     'ImportNamespaceSpecifier',
     'ImportSpecifier',
+    'JSXAttribute',
+    'JSXClosingElement',
+    'JSXClosingFragment',
+    'JSXElement',
+    'JSXEmptyExpression',
+    'JSXExpressionContainer',
+    'JSXFragment',
+    'JSXIdentifier',
+    'JSXMemberExpression',
+    'JSXNamespacedName',
+    'JSXOpeningElement',
+    'JSXOpeningFragment',
+    'JSXSpreadAttribute',
+    'JSXSpreadChild',
+    'JSXText',
     'LabeledStatement',
     'Literal',
     'Literal',
@@ -15302,6 +15882,21 @@ const nodeConstructors$1 = [
     ImportExpression,
     ImportNamespaceSpecifier,
     ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
     LabeledStatement,
     Literal,
     Literal,
@@ -15608,6 +16203,74 @@ const bufferParsers = [
         node.imported =
             importedPosition === 0 ? node.local : convertNode(node, scope, importedPosition, buffer);
     },
+    function jsxAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.name = convertNode(node, scope, buffer[position], buffer);
+        const valuePosition = buffer[position + 1];
+        node.value = valuePosition === 0 ? null : convertNode(node, scope, valuePosition, buffer);
+    },
+    function jsxClosingElement(node, position, buffer) {
+        const { scope } = node;
+        node.name = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxClosingFragment() { },
+    function jsxElement(node, position, buffer) {
+        const { scope } = node;
+        node.openingElement = convertNode(node, scope, buffer[position], buffer);
+        node.children = convertNodeList(node, scope, buffer[position + 1], buffer);
+        const closingElementPosition = buffer[position + 2];
+        node.closingElement =
+            closingElementPosition === 0
+                ? null
+                : convertNode(node, scope, closingElementPosition, buffer);
+    },
+    function jsxEmptyExpression() { },
+    function jsxExpressionContainer(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxFragment(node, position, buffer) {
+        const { scope } = node;
+        node.openingFragment = convertNode(node, scope, buffer[position], buffer);
+        node.children = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.closingFragment = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function jsxIdentifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
+    },
+    function jsxMemberExpression(node, position, buffer) {
+        const { scope } = node;
+        node.object = convertNode(node, scope, buffer[position], buffer);
+        node.property = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function jsxNamespacedName(node, position, buffer) {
+        const { scope } = node;
+        node.namespace = convertNode(node, scope, buffer[position], buffer);
+        node.name = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function jsxOpeningElement(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.selfClosing = (flags & 1) === 1;
+        node.name = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function jsxOpeningFragment(node) {
+        node.attributes = [];
+        node.selfClosing = false;
+    },
+    function jsxSpreadAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxSpreadChild(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxText(node, position, buffer) {
+        node.value = buffer.convertString(buffer[position]);
+        node.raw = buffer.convertString(buffer[position + 1]);
+    },
     function labeledStatement(node, position, buffer) {
         const { scope } = node;
         node.label = convertNode(node, scope, buffer[position], buffer);
@@ -15897,6 +16560,21 @@ const nodeConstructors = {
     ImportExpression,
     ImportNamespaceSpecifier,
     ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
     LabeledStatement,
     Literal,
     LogicalExpression,
@@ -16757,11 +17435,13 @@ class Module {
             addExport: this.addExport.bind(this),
             addImport: this.addImport.bind(this),
             addImportMeta: this.addImportMeta.bind(this),
+            addImportSource: this.addImportSource.bind(this),
             code, // Only needed for debugging
             deoptimizationTracker: this.graph.deoptimizationTracker,
             error: this.error.bind(this),
             fileName, // Needed for warnings
             getExports: this.getExports.bind(this),
+            getImportedJsxFactoryVariable: this.getImportedJsxFactoryVariable.bind(this),
             getModuleExecIndex: () => this.execIndex,
             getModuleName: this.basename.bind(this),
             getNodeConstructor: (name) => nodeConstructors[name] || nodeConstructors.UnknownNode,
@@ -16791,7 +17471,7 @@ class Module {
         else {
             // Measuring asynchronous code does not provide reasonable results
             timeEnd('generate ast', 3);
-            const astBuffer = await native_js.parseAsync(code, false);
+            const astBuffer = await native_js.parseAsync(code, false, this.options.jsx !== false);
             timeStart('generate ast', 3);
             this.ast = convertProgram(astBuffer, programParent, this.scope);
             // Make lazy and apply LRU cache to not hog the memory
@@ -16984,6 +17664,11 @@ class Module {
             });
         }
     }
+    addImportSource(importSource) {
+        if (importSource && !this.sourcesWithAttributes.has(importSource)) {
+            this.sourcesWithAttributes.set(importSource, parseAst_js.EMPTY_OBJECT);
+        }
+    }
     addImportMeta(node) {
         this.importMetas.push(node);
     }
@@ -17047,6 +17732,15 @@ class Module {
             this.sourcesWithAttributes.set(source, parsedAttributes);
         }
     }
+    getImportedJsxFactoryVariable(baseName, nodeStart, importSource) {
+        const { id } = this.resolvedIds[importSource];
+        const module = this.graph.modulesById.get(id);
+        const [variable] = module.getVariableForExportName(baseName);
+        if (!variable) {
+            return this.error(parseAst_js.logMissingJsxExport(baseName, id, this.id), nodeStart);
+        }
+        return variable;
+    }
     getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules) {
         let foundSyntheticDeclaration = null;
         const foundInternalDeclarations = new Map();
@@ -17167,7 +17861,7 @@ class Module {
     }
     tryParse() {
         try {
-            return parseAst_js.parseAst(this.info.code);
+            return parseAst_js.parseAst(this.info.code, { jsx: this.options.jsx !== false });
         }
         catch (error_) {
             return this.error(parseAst_js.logModuleParseError(error_, this.id), error_.pos);
@@ -19791,7 +20485,7 @@ class Bundle {
             for (const file of Object.values(bundle)) {
                 if ('code' in file) {
                     try {
-                        parseAst_js.parseAst(file.code);
+                        parseAst_js.parseAst(file.code, { jsx: this.inputOptions.jsx !== false });
                     }
                     catch (error_) {
                         this.inputOptions.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logChunkInvalid(file, error_));
@@ -20866,6 +21560,7 @@ async function normalizeInputOptions(config, watchMode) {
         experimentalLogSideEffects: config.experimentalLogSideEffects || false,
         external: getIdMatcher(config.external),
         input: getInput(config),
+        jsx: getJsx(config),
         logLevel,
         makeAbsoluteExternalsRelative: config.makeAbsoluteExternalsRelative ?? 'ifRelativeSource',
         maxParallelFileOps,
@@ -20911,6 +21606,46 @@ const getInput = (config) => {
     const configInput = config.input;
     return configInput == null ? [] : typeof configInput === 'string' ? [configInput] : configInput;
 };
+const getJsx = (config) => {
+    const configJsx = config.jsx;
+    if (!configJsx)
+        return false;
+    const configWithPreset = getOptionWithPreset(configJsx, jsxPresets, 'jsx', parseAst_js.URL_JSX, 'false, ');
+    const { factory, importSource, mode } = configWithPreset;
+    switch (mode) {
+        case 'automatic': {
+            return {
+                factory: factory || 'React.createElement',
+                importSource: importSource || 'react',
+                jsxImportSource: configWithPreset.jsxImportSource || 'react/jsx-runtime',
+                mode: 'automatic'
+            };
+        }
+        case 'preserve': {
+            if (importSource && !(factory || configWithPreset.fragment)) {
+                parseAst_js.error(parseAst_js.logInvalidOption('jsx', parseAst_js.URL_JSX, 'when preserving JSX and specifying an importSource, you also need to specify a factory or fragment'));
+            }
+            return {
+                factory: factory || null,
+                fragment: configWithPreset.fragment || null,
+                importSource: importSource || null,
+                mode: 'preserve'
+            };
+        }
+        // case 'classic':
+        default: {
+            if (mode && mode !== 'classic') {
+                parseAst_js.error(parseAst_js.logInvalidOption('jsx.mode', parseAst_js.URL_JSX, 'mode must be "automatic", "classic" or "preserve"', mode));
+            }
+            return {
+                factory: factory || 'React.createElement',
+                fragment: configWithPreset.fragment || 'React.Fragment',
+                importSource: importSource || null,
+                mode: 'classic'
+            };
+        }
+    }
+};
 const getMaxParallelFileOps = (config) => {
     const maxParallelFileOps = config.maxParallelFileOps;
     if (typeof maxParallelFileOps === 'number') {