@rollup/wasm-node 4.23.0 → 4.24.0

package/dist/es/shared/node-entry.js

@@ -1,13 +1,13 @@
 /*
   @license
-	Rollup.js v4.23.0
-	Tue, 01 Oct 2024 07:09:35 GMT - commit ed98e0821e6ad064839f0af46ceca061adbe3f14
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
-import { ExportDefaultDeclaration as ExportDefaultDeclaration$1, CallExpression as CallExpression$1, EMPTY_ARRAY, LOGLEVEL_WARN, logUnusedExternalImports, ANNOTATION_KEY, INVALID_ANNOTATION_KEY, Program as Program$1, BLANK, logIllegalImportReassignment, logRedeclarationError, StaticBlock as StaticBlock$1, CatchClause as CatchClause$1, logDuplicateArgumentNameError, logModuleLevelDirective, ReturnStatement as ReturnStatement$1, VariableDeclarator as VariableDeclarator$1, ExpressionStatement as ExpressionStatement$1, logMissingExport, normalize, getImportPath, logMissingNodeBuiltins, logReservedNamespace, error, logIllegalIdentifierAsName, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, Property as Property$1, logConstVariableReassignError, ArrowFunctionExpression as ArrowFunctionExpression$1, EMPTY_SET, logCannotCallNamespace, logEval, BlockStatement as BlockStatement$1, getRollupError, logParseError, logModuleParseError, LOGLEVEL_INFO, logFirstSideEffect, locate, logInvalidAnnotation, Identifier as Identifier$1, logThisIsUndefined, getAstBuffer, convertAnnotations, FIXED_STRINGS, convertNode as convertNode$1, EMPTY_OBJECT, logImportAttributeIsInvalid, logImportOptionsAreInvalid, logSyntheticNamedExportsNeedNamespaceExport, logMissingEntryExport, logDuplicateExportError, logInvalidSourcemapForError, augmentCodeLocation, logInconsistentImportAttributes, logNamespaceConflict, logAmbiguousExternalNamespaces, logShimmedExport, parseAst, logCircularReexport, logInvalidFormatForTopLevelAwait, TemplateLiteral as TemplateLiteral$1, Literal as Literal$1, logAddonNotGenerated, logIncompatibleExportOptionValue, logMixedExport, logFailedValidation, isPathFragment, logCyclicCrossChunkReexport, getAliasName, logUnexpectedNamedImport, isAbsolute as isAbsolute$1, relative as relative$1, logUnexpectedNamespaceReexport, logEmptyChunk, logMissingGlobalName, logOptimizeChunkStatus, logSourcemapBroken, logConflictingSourcemapSources, logChunkInvalid, logInvalidOption, URL_OUTPUT_FORMAT, URL_OUTPUT_DIR, URL_OUTPUT_SOURCEMAPFILE, URL_OUTPUT_AMD_ID, logCannotAssignModuleToChunk, logAnonymousPluginCache, logDuplicatePluginName, logUnknownOption, printQuotedStringList, LOGLEVEL_ERROR, logLevelPriority, LOGLEVEL_DEBUG, logInvalidSetAssetSourceCall, logPluginError, logNoTransformMapOrAstWithoutCode, relativeId, logBadLoader, logExternalModulesCannotBeTransformedToModules, logInternalIdCannotBeExternal, isRelative, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logExternalSyntheticExports, logUnresolvedEntry, logUnresolvedImplicitDependant, logExternalModulesCannotBeIncludedInManualChunks, logEntryCannotBeExternal, logImplicitDependantCannotBeExternal, logNoAssetSourceSet, logFileReferenceIdNotFoundForFilename, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logInvalidRollupPhaseForChunkEmission, warnDeprecation, URL_GENERATEBUNDLE, logFileNameConflict, logAssetNotFinalisedForFileName, logChunkNotGeneratedForFileName, logInvalidLogPosition, logInputHookInOutputPlugin, logInvalidFunctionPluginHook, logInvalidAddonPluginHook, logImplicitDependantIsNotIncluded, logCircularDependency, augmentLogMessage, URL_TREESHAKE, URL_TREESHAKE_MODULESIDEEFFECTS, logInvalidExportOptionValue, URL_OUTPUT_INTEROP, isValidUrl, addTrailingSlashIfMissed, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_PRESERVEENTRYSIGNATURES, URL_OUTPUT_AMD_BASEPATH, URL_OUTPUT_GENERATEDCODE, URL_OUTPUT_MANUALCHUNKS, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, logAlreadyClosed, logMissingFileOrDirOption, logCannotEmitFromOptionsHook, URL_WATCH } from './parseAst.js';
+import { ExportDefaultDeclaration as ExportDefaultDeclaration$1, CallExpression as CallExpression$1, EMPTY_ARRAY, LOGLEVEL_WARN, logUnusedExternalImports, ANNOTATION_KEY, INVALID_ANNOTATION_KEY, Program as Program$1, logIllegalImportReassignment, BLANK, logRedeclarationError, StaticBlock as StaticBlock$1, CatchClause as CatchClause$1, logDuplicateArgumentNameError, logModuleLevelDirective, ReturnStatement as ReturnStatement$1, VariableDeclarator as VariableDeclarator$1, ExpressionStatement as ExpressionStatement$1, logMissingExport, normalize, getImportPath, logMissingNodeBuiltins, logReservedNamespace, error, logIllegalIdentifierAsName, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, Property as Property$1, logConstVariableReassignError, ArrowFunctionExpression as ArrowFunctionExpression$1, EMPTY_SET, logCannotCallNamespace, logEval, BlockStatement as BlockStatement$1, getRollupError, logParseError, logModuleParseError, LOGLEVEL_INFO, logFirstSideEffect, locate, logInvalidAnnotation, Identifier as Identifier$1, logThisIsUndefined, getAstBuffer, convertAnnotations, FIXED_STRINGS, convertNode as convertNode$1, EMPTY_OBJECT, logImportAttributeIsInvalid, logImportOptionsAreInvalid, logSyntheticNamedExportsNeedNamespaceExport, logMissingEntryExport, logDuplicateExportError, logInvalidSourcemapForError, augmentCodeLocation, logInconsistentImportAttributes, logMissingJsxExport, logNamespaceConflict, logAmbiguousExternalNamespaces, logShimmedExport, parseAst, logCircularReexport, logInvalidFormatForTopLevelAwait, TemplateLiteral as TemplateLiteral$1, Literal as Literal$1, logAddonNotGenerated, logIncompatibleExportOptionValue, logMixedExport, logFailedValidation, isPathFragment, logCyclicCrossChunkReexport, getAliasName, logUnexpectedNamedImport, isAbsolute as isAbsolute$1, relative as relative$1, logUnexpectedNamespaceReexport, logEmptyChunk, logMissingGlobalName, logOptimizeChunkStatus, logSourcemapBroken, logConflictingSourcemapSources, logChunkInvalid, logInvalidOption, URL_OUTPUT_FORMAT, URL_OUTPUT_DIR, URL_OUTPUT_SOURCEMAPFILE, URL_OUTPUT_AMD_ID, logCannotAssignModuleToChunk, logAnonymousPluginCache, logDuplicatePluginName, logUnknownOption, printQuotedStringList, LOGLEVEL_ERROR, logLevelPriority, LOGLEVEL_DEBUG, logInvalidSetAssetSourceCall, logPluginError, logNoTransformMapOrAstWithoutCode, relativeId, logBadLoader, logExternalModulesCannotBeTransformedToModules, logInternalIdCannotBeExternal, isRelative, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logExternalSyntheticExports, logUnresolvedEntry, logUnresolvedImplicitDependant, logExternalModulesCannotBeIncludedInManualChunks, logEntryCannotBeExternal, logImplicitDependantCannotBeExternal, logNoAssetSourceSet, logFileReferenceIdNotFoundForFilename, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logInvalidRollupPhaseForChunkEmission, warnDeprecation, URL_GENERATEBUNDLE, logFileNameConflict, logAssetNotFinalisedForFileName, logChunkNotGeneratedForFileName, logInvalidLogPosition, logInputHookInOutputPlugin, logInvalidFunctionPluginHook, logInvalidAddonPluginHook, logImplicitDependantIsNotIncluded, logCircularDependency, augmentLogMessage, URL_JSX, URL_TREESHAKE, URL_TREESHAKE_MODULESIDEEFFECTS, logInvalidExportOptionValue, URL_OUTPUT_INTEROP, isValidUrl, addTrailingSlashIfMissed, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_PRESERVEENTRYSIGNATURES, URL_OUTPUT_AMD_BASEPATH, URL_OUTPUT_GENERATEDCODE, URL_OUTPUT_MANUALCHUNKS, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, logAlreadyClosed, logMissingFileOrDirOption, logCannotEmitFromOptionsHook, URL_WATCH } from './parseAst.js';
 import { relative, dirname, basename, extname, resolve as resolve$1 } from 'node:path';
 import require$$0, { posix, win32, isAbsolute, resolve } from 'path';
 import { parseAsync, xxhashBase64Url, xxhashBase36, xxhashBase16 } from '../../native.js';
@@ -16,7 +16,7 @@ import { performance } from 'node:perf_hooks';
 import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import * as tty from 'tty';
 
-var version = "4.23.0";
+var version = "4.24.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -2182,6 +2182,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;
@@ -2227,6 +2228,9 @@ class Variable extends ExpressionEntity {
             this.name);
     }
     getName(getPropertyAccess, useOriginalName) {
+        if (this.globalName) {
+            return this.globalName;
+        }
         if (useOriginalName?.(this)) {
             return this.name;
         }
@@ -2240,10 +2244,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;
@@ -2731,6 +2735,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'],
@@ -4845,11 +4864,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 */)) {
@@ -4861,55 +4880,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);
     }
@@ -5000,32 +4970,6 @@ class Identifier extends NodeBase {
         }
         return (this.isTDZAccess = false);
     }
-    markDeclarationReached() {
-        this.variable.initReached = true;
-    }
-    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = 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 === CallExpression$1 &&
-                isCalleeOfRenderedParent) {
-                code.appendRight(this.start, '0, ');
-            }
-        }
-    }
-    disallowImportReassignment() {
-        return this.scope.context.error(logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
-    }
     applyDeoptimizations() {
         this.deoptimized = true;
         if (this.variable instanceof LocalVariable) {
@@ -5038,11 +4982,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(logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
+    }
     getVariableRespectingTDZ() {
         if (this.isPossibleTDZ()) {
             return UNKNOWN_EXPRESSION;
@@ -5073,6 +5020,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 } = 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 === CallExpression$1 &&
+                isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+        }
+    }
+}
+
 const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
 const base = 64;
 function toBase64(value) {
@@ -5213,6 +5239,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) {
@@ -12377,6 +12408,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 } = 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;
@@ -13705,6 +14227,21 @@ const nodeTypeStrings = [
     'ImportExpression',
     'ImportNamespaceSpecifier',
     'ImportSpecifier',
+    'JSXAttribute',
+    'JSXClosingElement',
+    'JSXClosingFragment',
+    'JSXElement',
+    'JSXEmptyExpression',
+    'JSXExpressionContainer',
+    'JSXFragment',
+    'JSXIdentifier',
+    'JSXMemberExpression',
+    'JSXNamespacedName',
+    'JSXOpeningElement',
+    'JSXOpeningFragment',
+    'JSXSpreadAttribute',
+    'JSXSpreadChild',
+    'JSXText',
     'LabeledStatement',
     'Literal',
     'Literal',
@@ -13787,6 +14324,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,
@@ -14093,6 +14645,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);
@@ -14382,6 +15002,21 @@ const nodeConstructors = {
     ImportExpression,
     ImportNamespaceSpecifier,
     ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
     LabeledStatement,
     Literal,
     LogicalExpression,
@@ -15249,11 +15884,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,
@@ -15283,7 +15920,7 @@ class Module {
         else {
             // Measuring asynchronous code does not provide reasonable results
             timeEnd('generate ast', 3);
-            const astBuffer = await parseAsync(code, false);
+            const astBuffer = await 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
@@ -15476,6 +16113,11 @@ class Module {
             });
         }
     }
+    addImportSource(importSource) {
+        if (importSource && !this.sourcesWithAttributes.has(importSource)) {
+            this.sourcesWithAttributes.set(importSource, EMPTY_OBJECT);
+        }
+    }
     addImportMeta(node) {
         this.importMetas.push(node);
     }
@@ -15539,6 +16181,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(logMissingJsxExport(baseName, id, this.id), nodeStart);
+        }
+        return variable;
+    }
     getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules) {
         let foundSyntheticDeclaration = null;
         const foundInternalDeclarations = new Map();
@@ -15659,7 +16310,7 @@ class Module {
     }
     tryParse() {
         try {
-            return parseAst(this.info.code);
+            return parseAst(this.info.code, { jsx: this.options.jsx !== false });
         }
         catch (error_) {
             return this.error(logModuleParseError(error_, this.id), error_.pos);
@@ -18412,7 +19063,7 @@ class Bundle {
             for (const file of Object.values(bundle)) {
                 if ('code' in file) {
                     try {
-                        parseAst(file.code);
+                        parseAst(file.code, { jsx: this.inputOptions.jsx !== false });
                     }
                     catch (error_) {
                         this.inputOptions.onLog(LOGLEVEL_WARN, logChunkInvalid(file, error_));
@@ -18807,6 +19458,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,
@@ -20471,6 +21148,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,
@@ -20516,6 +21194,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', 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)) {
+                error(logInvalidOption('jsx', 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') {
+                error(logInvalidOption('jsx.mode', 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') {
@@ -21270,6 +21988,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', URL_JSX, 'false, ')),
         logLevel: getOption('logLevel'),
         makeAbsoluteExternalsRelative: getOption('makeAbsoluteExternalsRelative'),
         maxParallelFileOps: getOption('maxParallelFileOps'),