Context Navigation

← Previous Change
Next Change →

Changeset 0c6b92a for imaps-frontend/node_modules/rollup/dist/shared/rollup.js

Timestamp:

12/12/24 17:06:06 (5 weeks ago)

Author:

stefan toskovski <stefantoska84@…>

Branches:

Parents:

Message:

Pred finalna verzija

File:

: 1 edited

imaps-frontend/node_modules/rollup/dist/shared/rollup.js (modified) (132 diffs)

Legend:

: Unmodified
: Added
: Removed

imaps-frontend/node_modules/rollup/dist/shared/rollup.js

-              rd565449
+              r0c6b92a
 /*
   @license
         Rollup.js v4.20.0
         Sat, 03 Aug 2024 04:48:21 GMT - commit df12edfea6e9c1a71bda1a01bed1ab787b7514d5
+        Rollup.js v4.27.4
+        Sat, 23 Nov 2024 06:59:50 GMT - commit e805b546405a4e6cfccd3fe73e9f4df770023824
         https://github.com/rollup/rollup
 …
 const process$1 = require('node:process');
 const tty = require('tty');
 const path$2 = require('node:path');
+const path = require('node:path');
 const require$$0 = require('path');
 const native_js = require('../native.js');
 …
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 var version = "4.20.0";
+var version = "4.27.4";
 function ensureArray$1(items) {
 …
 const hashPlaceholderOverhead = hashPlaceholderLeft.length + hashPlaceholderRight.length;
 // This is the size of a 128-bits xxhash with base64url encoding
 const MAX_HASH_SIZE = 22;
+const MAX_HASH_SIZE = 21;
 const DEFAULT_HASH_SIZE = 8;
 const getHashPlaceholderGenerator = () => {
 …
     const bundleEntries = Object.values(outputBundle);
     for (const asset of bundleEntries) {
+        asset.type === 'asset' && asset.needsCodeReference && unreferencedAssets.add(asset.fileName);
+        if (asset.type === 'asset' && asset.needsCodeReference) {
+            unreferencedAssets.add(asset.fileName);
+        }
+    }
     for (const chunk of bundleEntries) {
         if (chunk.type === 'chunk') {
             for (const referencedFile of chunk.referencedFiles) {
+                unreferencedAssets.has(referencedFile) && unreferencedAssets.delete(referencedFile);
+                if (unreferencedAssets.has(referencedFile)) {
+                    unreferencedAssets.delete(referencedFile);
+                }
+            }
+        }
 …
     if (!reservedLowercaseBundleKeys.has(name.toLowerCase()))
         return name;
     const extension = path$2.extname(name);
+    const extension = path.extname(name);
     name = name.slice(0, Math.max(0, name.length - extension.length));
     let uniqueName, uniqueIndex = 1;
 …
+}
 function generateAssetFileName(name, source, originalFileName, sourceHash, outputOptions, bundle) {
+function generateAssetFileName(name, names, source, originalFileName, originalFileNames, sourceHash, outputOptions, bundle, inputOptions) {
     const emittedName = outputOptions.sanitizeFileName(name || 'asset');
     return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
+        ? outputOptions.assetFileNames({ name, originalFileName, source, type: 'asset' })
+        ? outputOptions.assetFileNames({
+            // Additionally, this should be non-enumerable in the next major
+            get name() {
+                parseAst_js.warnDeprecation('Accessing the "name" property of emitted assets when generating the file name is deprecated. Use the "names" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, inputOptions);
+                return name;
+            },
+            names,
+            // Additionally, this should be non-enumerable in the next major
+            get originalFileName() {
+                parseAst_js.warnDeprecation('Accessing the "originalFileName" property of emitted assets when generating the file name is deprecated. Use the "originalFileNames" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, inputOptions);
+                return originalFileName;
+            },
+            originalFileNames,
+            source,
+            type: 'asset'
+        })
         : outputOptions.assetFileNames, 'output.assetFileNames', {
         ext: () => path$2.extname(emittedName).slice(1),
         extname: () => path$2.extname(emittedName),
+        ext: () => path.extname(emittedName).slice(1),
+        extname: () => path.extname(emittedName),
         hash: size => sourceHash.slice(0, Math.max(0, size || DEFAULT_HASH_SIZE)),
         name: () => emittedName.slice(0, Math.max(0, emittedName.length - path$2.extname(emittedName).length))
+        name: () => emittedName.slice(0, Math.max(0, emittedName.length - path.extname(emittedName).length))
     }), bundle);
+}
 …
             const output = (this.output = {
                 bundle,
                 fileNamesBySource: new Map(),
+                fileNamesBySourceHash: new Map(),
                 getHash,
                 outputOptions
 …
         return referenceId;
+    }
     finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySource, getHash, outputOptions }) {
         let { fileName, needsCodeReference, originalFileName, referenceId } = consumedFile;
+    finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySourceHash, getHash, outputOptions }) {
+        let { fileName, name, needsCodeReference, originalFileName, referenceId } = consumedFile;
         // Deduplicate assets if an explicit fileName is not provided
         if (!fileName) {
             const sourceHash = getHash(source);
             fileName = fileNamesBySource.get(sourceHash);
+            fileName = fileNamesBySourceHash.get(sourceHash);
             if (!fileName) {
                 fileName = generateAssetFileName(consumedFile.name, source, originalFileName, sourceHash, outputOptions, bundle);
                 fileNamesBySource.set(sourceHash, fileName);
+                fileName = generateAssetFileName(name, name ? [name] : [], source, originalFileName, originalFileName ? [originalFileName] : [], sourceHash, outputOptions, bundle, this.options);
+                fileNamesBySourceHash.set(sourceHash, fileName);
+            }
+        }
 …
         if (existingAsset?.type === 'asset') {
             existingAsset.needsCodeReference &&= needsCodeReference;
+            if (name) {
+                existingAsset.names.push(name);
+            }
+            if (originalFileName) {
+                existingAsset.originalFileNames.push(originalFileName);
+            }
+        }
         else {
+            const { options } = this;
             bundle[fileName] = {
                 fileName,
+                name: consumedFile.name,
+                get name() {
+                    // Additionally, this should be non-enumerable in the next major
+                    parseAst_js.warnDeprecation('Accessing the "name" property of emitted assets in the bundle is deprecated. Use the "names" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                    return name;
+                },
+                names: name ? [name] : [],
                 needsCodeReference,
+                originalFileName,
+                get originalFileName() {
+                    // Additionally, this should be non-enumerable in the next major
+                    parseAst_js.warnDeprecation('Accessing the "originalFileName" property of emitted assets in the bundle is deprecated. Use the "originalFileNames" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                    return originalFileName;
+                },
+                originalFileNames: originalFileName ? [originalFileName] : [],
                 source,
                 type: 'asset'
 …
+        }
+    }
+    finalizeAssetsWithSameSource(consumedFiles, sourceHash, { bundle, fileNamesBySource, outputOptions }) {
+    finalizeAssetsWithSameSource(consumedFiles, sourceHash, { bundle, fileNamesBySourceHash, outputOptions }) {
+        const { names, originalFileNames } = getNamesFromAssets(consumedFiles);
         let fileName = '';
         let usedConsumedFile;
 …
         for (const consumedFile of consumedFiles) {
             needsCodeReference &&= consumedFile.needsCodeReference;
             const assetFileName = generateAssetFileName(consumedFile.name, consumedFile.source, consumedFile.originalFileName, sourceHash, outputOptions, bundle);
+            const assetFileName = generateAssetFileName(consumedFile.name, names, consumedFile.source, consumedFile.originalFileName, originalFileNames, sourceHash, outputOptions, bundle, this.options);
             if (!fileName ||
                 assetFileName.length < fileName.length ||
 …
+            }
+        }
         fileNamesBySource.set(sourceHash, fileName);
+        fileNamesBySourceHash.set(sourceHash, fileName);
         for (const consumedFile of consumedFiles) {
             // We must not modify the original assets to avoid interaction between outputs
 …
             this.filesByReferenceId.set(consumedFile.referenceId, assetWithFileName);
+        }
+        const { options } = this;
         bundle[fileName] = {
             fileName,
+            name: usedConsumedFile.name,
+            get name() {
+                // Additionally, this should be non-enumerable in the next major
+                parseAst_js.warnDeprecation('Accessing the "name" property of emitted assets in the bundle is deprecated. Use the "names" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                return usedConsumedFile.name;
+            },
+            names,
             needsCodeReference,
+            originalFileName: usedConsumedFile.originalFileName,
+            get originalFileName() {
+                // Additionally, this should be non-enumerable in the next major
+                parseAst_js.warnDeprecation('Accessing the "originalFileName" property of emitted assets in the bundle is deprecated. Use the "originalFileNames" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                return usedConsumedFile.originalFileName;
+            },
+            originalFileNames,
             source: usedConsumedFile.source,
             type: 'asset'
 …
+    }
+}
+const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
+const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';
+function createPluginCache(cache) {
+    return {
+        delete(id) {
+            return delete cache[id];
+        },
+        get(id) {
+            const item = cache[id];
+            if (!item)
+                return;
+            item[0] = 0;
+            return item[1];
+        },
+        has(id) {
+            const item = cache[id];
+            if (!item)
+                return false;
+            item[0] = 0;
+            return true;
+        },
+        set(id, value) {
+            cache[id] = [0, value];
+        }
+    };
+}
+function getTrackedPluginCache(pluginCache, onUse) {
+    return {
+        delete(id) {
+            onUse();
+            return pluginCache.delete(id);
+        },
+        get(id) {
+            onUse();
+            return pluginCache.get(id);
+        },
+        has(id) {
+            onUse();
+            return pluginCache.has(id);
+        },
+        set(id, value) {
+            onUse();
+            return pluginCache.set(id, value);
+        }
+    };
+}
+const NO_CACHE = {
+    delete() {
+        return false;
+    },
+    get() {
+        return undefined;
+    },
+    has() {
+        return false;
+    },
+    set() { }
+};
+function uncacheablePluginError(pluginName) {
+    if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
+        pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
+        return parseAst_js.error(parseAst_js.logAnonymousPluginCache());
+    }
+    return parseAst_js.error(parseAst_js.logDuplicatePluginName(pluginName));
+}
+function getCacheForUncacheablePlugin(pluginName) {
+    return {
+        delete() {
+            return uncacheablePluginError(pluginName);
+        },
+        get() {
+            return uncacheablePluginError(pluginName);
+        },
+        has() {
+            return uncacheablePluginError(pluginName);
+        },
+        set() {
+            return uncacheablePluginError(pluginName);
+        }
+    };
+function getNamesFromAssets(consumedFiles) {
+    const names = [];
+    const originalFileNames = [];
+    for (const { name, originalFileName } of consumedFiles) {
+        if (typeof name === 'string') {
+            names.push(name);
+        }
+        if (originalFileName) {
+            originalFileNames.push(originalFileName);
+        }
+    }
+    originalFileNames.sort();
+    // Sort by length first and then alphabetically so that the order is stable
+    // and the shortest names come first
+    names.sort((a, b) => a.length - b.length || (a > b ? 1 : a === b ? 0 : -1));
+    return { names, originalFileNames };
+}
 …
+    }
 };
+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: {
 …
         log.plugin = pluginName;
         logger(level, log);
+    };
+}
+const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
+const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';
+function createPluginCache(cache) {
+    return {
+        delete(id) {
+            return delete cache[id];
+        },
+        get(id) {
+            const item = cache[id];
+            if (!item)
+                return;
+            item[0] = 0;
+            return item[1];
+        },
+        has(id) {
+            const item = cache[id];
+            if (!item)
+                return false;
+            item[0] = 0;
+            return true;
+        },
+        set(id, value) {
+            cache[id] = [0, value];
+        }
+    };
+}
+function getTrackedPluginCache(pluginCache, onUse) {
+    return {
+        delete(id) {
+            onUse();
+            return pluginCache.delete(id);
+        },
+        get(id) {
+            onUse();
+            return pluginCache.get(id);
+        },
+        has(id) {
+            onUse();
+            return pluginCache.has(id);
+        },
+        set(id, value) {
+            onUse();
+            return pluginCache.set(id, value);
+        }
+    };
+}
+const NO_CACHE = {
+    delete() {
+        return false;
+    },
+    get() {
+        return undefined;
+    },
+    has() {
+        return false;
+    },
+    set() { }
+};
+function uncacheablePluginError(pluginName) {
+    if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
+        pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
+        return parseAst_js.error(parseAst_js.logAnonymousPluginCache());
+    }
+    return parseAst_js.error(parseAst_js.logDuplicatePluginName(pluginName));
+}
+function getCacheForUncacheablePlugin(pluginName) {
+    return {
+        delete() {
+            return uncacheablePluginError(pluginName);
+        },
+        get() {
+            return uncacheablePluginError(pluginName);
+        },
+        has() {
+            return uncacheablePluginError(pluginName);
+        },
+        set() {
+            return uncacheablePluginError(pluginName);
+        }
     };
+}
 …
                 return handler;
+            }
             // eslint-disable-next-line @typescript-eslint/ban-types
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
             const hookResult = handler.apply(context, parameters);
             if (!hookResult?.then) {
 …
+        }
         try {
             // eslint-disable-next-line @typescript-eslint/ban-types
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
             return handler.apply(context, parameters);
+        }
 …
         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'),
 …
         sourcemap: getOption('sourcemap'),
         sourcemapBaseUrl: getOption('sourcemapBaseUrl'),
+        sourcemapDebugIds: getOption('sourcemapDebugIds'),
         sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
         sourcemapFile: getOption('sourcemapFile'),
 …
         strict: getOption('strict'),
         systemNullSetters: getOption('systemNullSetters'),
+        validate: getOption('validate')
+        validate: getOption('validate'),
+        virtualDirname: getOption('virtualDirname')
     };
     warnUnknownOptions(config, Object.keys(outputOptions), 'output options', log);
 …
                         this.x_google_ignoreList = properties.x_google_ignoreList;
+                }
+                if (typeof properties.debugId !== 'undefined') {
+                        this.debugId = properties.debugId;
+                }
+        }
 …
 const toString = Object.prototype.toString;
 function isObject$1(thing) {
+function isObject(thing) {
         return toString.call(thing) === '[object Object]';
+}
 …
                 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;
 …
                                 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;
 …
                 const pattern = /^[^\r\n]/gm;
                 if (isObject$1(indentStr)) {
+                if (isObject(indentStr)) {
                         options = indentStr;
                         indentStr = undefined;
 …
+                }
                 if (!isObject$1(source) || !source.content) {
+                if (!isObject(source) || !source.content) {
                         throw new Error(
                                 'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',
 …
 };
+const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
+const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
+const backSlashRegEx = /\\/g;
+function escapeId(id) {
+    if (!needsEscapeRegEx.test(id))
+        return id;
+    return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
+}
+class ExternalChunk {
+    constructor(module, options, inputBase) {
+        this.options = options;
+        this.inputBase = inputBase;
+        this.defaultVariableName = '';
+        this.namespaceVariableName = '';
+        this.variableName = '';
+        this.fileName = null;
+        this.importAttributes = null;
+        this.id = module.id;
+        this.moduleInfo = module.info;
+        this.renormalizeRenderPath = module.renormalizeRenderPath;
+        this.suggestedVariableName = module.suggestedVariableName;
+    }
+    getFileName() {
+        if (this.fileName) {
+            return this.fileName;
+        }
+        const { paths } = this.options;
+        return (this.fileName =
+            (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
+                (this.renormalizeRenderPath ? parseAst_js.normalize(path$2.relative(this.inputBase, this.id)) : this.id));
+    }
+    getImportAttributes(snippets) {
+        return (this.importAttributes ||= formatAttributes(this.options.format === 'es' &&
+            this.options.externalImportAttributes &&
+            this.moduleInfo.attributes, snippets));
+    }
+    getImportPath(importer) {
+        return escapeId(this.renormalizeRenderPath
+            ? parseAst_js.getImportPath(importer, this.getFileName(), this.options.format === 'amd', false)
+            : this.getFileName());
+    }
+}
+function formatAttributes(attributes, { getObject }) {
+    if (!attributes) {
+        return null;
+    }
+    const assertionEntries = Object.entries(attributes).map(([key, value]) => [key, `'${value}'`]);
+    if (assertionEntries.length > 0) {
+        return getObject(assertionEntries, { lineBreakIndent: null });
+    }
+    return null;
+}
+function treeshakeNode(node, code, start, end) {
+    code.remove(start, end);
+    node.removeAnnotations(code);
+}
+const NO_SEMICOLON = { isNoStatement: true };
+// This assumes there are only white-space and comments between start and the string we are looking for
+function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
+    let searchPos, charCodeAfterSlash;
+    searchPos = code.indexOf(searchString, start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start >= searchPos)
+            return searchPos;
+        charCodeAfterSlash = code.charCodeAt(++start);
+        ++start;
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        start =
+            charCodeAfterSlash === 47 /*"/"*/
+                ? code.indexOf('\n', start) + 1
+                : code.indexOf('*/', start) + 2;
+        if (start > searchPos) {
+            searchPos = code.indexOf(searchString, start);
+        }
+    }
+}
+const NON_WHITESPACE = /\S/g;
+function findNonWhiteSpace(code, index) {
+    NON_WHITESPACE.lastIndex = index;
+    const result = NON_WHITESPACE.exec(code);
+    return result.index;
+}
+const WHITESPACE = /\s/;
+function findLastWhiteSpaceReverse(code, start, end) {
+    while (true) {
+        if (start >= end) {
+            return end;
+        }
+        if (WHITESPACE.test(code[end - 1])) {
+            end--;
+        }
+        else {
+            return end;
+        }
+    }
+}
+// This assumes "code" only contains white-space and comments
+// Returns position of line-comment if applicable
+function findFirstLineBreakOutsideComment(code) {
+    let lineBreakPos, charCodeAfterSlash, start = 0;
+    lineBreakPos = code.indexOf('\n', start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start > lineBreakPos)
+            return [lineBreakPos, lineBreakPos + 1];
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        charCodeAfterSlash = code.charCodeAt(start + 1);
+        if (charCodeAfterSlash === 47 /*"/"*/)
+            return [start, lineBreakPos + 1];
+        start = code.indexOf('*/', start + 2) + 2;
+        if (start > lineBreakPos) {
+            lineBreakPos = code.indexOf('\n', start);
+        }
+    }
+}
+function renderStatementList(statements, code, start, end, options) {
+    let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
+    let nextNode = statements[0];
+    let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
+    if (nextNodeNeedsBoundaries) {
+        nextNodeStart =
+            start + findFirstLineBreakOutsideComment(code.original.slice(start, nextNode.start))[1];
+    }
+    for (let nextIndex = 1; nextIndex <= statements.length; nextIndex++) {
+        currentNode = nextNode;
+        currentNodeStart = nextNodeStart;
+        currentNodeNeedsBoundaries = nextNodeNeedsBoundaries;
+        nextNode = statements[nextIndex];
+        nextNodeNeedsBoundaries =
+            nextNode === undefined ? false : !nextNode.included || nextNode.needsBoundaries;
+        if (currentNodeNeedsBoundaries || nextNodeNeedsBoundaries) {
+            nextNodeStart =
+                currentNode.end +
+                    findFirstLineBreakOutsideComment(code.original.slice(currentNode.end, nextNode === undefined ? end : nextNode.start))[1];
+            if (currentNode.included) {
+                if (currentNodeNeedsBoundaries) {
+                    currentNode.render(code, options, {
+                        end: nextNodeStart,
+                        start: currentNodeStart
+                    });
+                }
+                else {
+                    currentNode.render(code, options);
+                }
+            }
+            else {
+                treeshakeNode(currentNode, code, currentNodeStart, nextNodeStart);
+            }
+        }
+        else {
+            currentNode.render(code, options);
+        }
+    }
+}
+// This assumes that the first character is not part of the first node
+function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
+    const splitUpNodes = [];
+    let node, nextNodeStart, contentEnd, char;
+    let separator = start - 1;
+    for (const nextNode of nodes) {
+        if (node !== undefined) {
+            separator =
+                node.end +
+                    findFirstOccurrenceOutsideComment(code.original.slice(node.end, nextNode.start), ',');
+        }
+        nextNodeStart = contentEnd =
+            separator +
++
+                findFirstLineBreakOutsideComment(code.original.slice(separator + 1, nextNode.start))[1];
+        while (((char = code.original.charCodeAt(nextNodeStart)),
+            char === 32 /*" "*/ || char === 9 /*"\t"*/ || char === 10 /*"\n"*/ || char === 13) /*"\r"*/)
+            nextNodeStart++;
+        if (node !== undefined) {
+            splitUpNodes.push({
+                contentEnd,
+                end: nextNodeStart,
+                node,
+                separator,
+                start
+            });
+        }
+        node = nextNode;
+        start = nextNodeStart;
+    }
+    splitUpNodes.push({
+        contentEnd: end,
+        end,
+        node: node,
+        separator: null,
+        start
+    });
+    return splitUpNodes;
+}
+// This assumes there are only white-space and comments between start and end
+function removeLineBreaks(code, start, end) {
+    while (true) {
+        const [removeStart, removeEnd] = findFirstLineBreakOutsideComment(code.original.slice(start, end));
+        if (removeStart === -1) {
+            break;
+        }
+        code.remove(start + removeStart, (start += removeEnd));
+    }
+}
+function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
+    if (exportedVariables.length === 1 &&
+        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
+        const variable = exportedVariables[0];
+        return `exports(${JSON.stringify(exportNamesByVariable.get(variable)[0])},${_}${variable.getName(getPropertyAccess)}${modifier})`;
+    }
+    else {
+        const fields = [];
+        for (const variable of exportedVariables) {
+            for (const exportName of exportNamesByVariable.get(variable)) {
+                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
+            }
+        }
+        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
+    }
+}
+// This is only invoked if there is exactly one export name
+function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
+    code.prependRight(expressionStart, `exports(${JSON.stringify(exportNamesByVariable.get(exportedVariable)[0])},${_}`);
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getDirectReturnIifeLeft } = options.snippets;
+    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getPropertyAccess } = options.snippets;
+    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
+    const { _ } = options.snippets;
+    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+/** @import { Node } from 'estree' */
+/**
+ * @param {Node} node
+ * @param {Node} parent
+ * @returns {boolean}
+ */
+function is_reference(node, parent) {
+        if (node.type === 'MemberExpression') {
+                return !node.computed && is_reference(node.object, node);
+        }
+        if (node.type !== 'Identifier') return false;
+        switch (parent?.type) {
+                // disregard `bar` in `foo.bar`
+                case 'MemberExpression':
+                        return parent.computed || node === parent.object;
+                // disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+                case 'MethodDefinition':
+                        return parent.computed;
+                // disregard the `meta` in `import.meta`
+                case 'MetaProperty':
+                        return parent.meta === node;
+                // disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+                case 'PropertyDefinition':
+                        return parent.computed || node === parent.value;
+                // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+                case 'Property':
+                        return parent.computed || node === parent.value;
+                // disregard the `bar` in `export { foo as bar }` or
+                // the foo in `import { foo as bar }`
+                case 'ExportSpecifier':
+                case 'ImportSpecifier':
+                        return node === parent.local;
+                // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+                case 'LabeledStatement':
+                case 'BreakStatement':
+                case 'ContinueStatement':
+                        return false;
+                default:
+                        return true;
+        }
+}
+const PureFunctionKey = Symbol('PureFunction');
+const getPureFunctions = ({ treeshake }) => {
+    const pureFunctions = Object.create(null);
+    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
+        let currentFunctions = pureFunctions;
+        for (const pathSegment of functionName.split('.')) {
+            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
+        }
+        currentFunctions[PureFunctionKey] = true;
+    }
+    return pureFunctions;
+};
 const UnknownKey = Symbol('Unknown Key');
 …
         this.alwaysRendered = false;
         this.forbiddenNames = null;
+        this.globalName = null;
         this.initReached = false;
         this.isId = false;
 …
+    }
     getName(getPropertyAccess, useOriginalName) {
+        if (this.globalName) {
+            return this.globalName;
+        }
         if (useOriginalName?.(this)) {
             return this.name;
 …
+    }
     /**
      * 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() {
 …
+}
+function getDefaultExportFromCjs (x) {
+        return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+        if (typeof f == "function") {
+                var a = function a () {
+                        if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+                        }
+                        return f.apply(this, arguments);
+                };
+                a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+        Object.keys(n).forEach(function (k) {
+                var d = Object.getOwnPropertyDescriptor(n, k);
+                Object.defineProperty(a, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () {
+                                return n[k];
+                        }
+                });
+        });
+        return a;
+}
+var utils$3 = {};
+const path$1 = require$$0;
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+/**
+ * Posix glob regex
+ */
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR = `${QMARK}*?`;
+const POSIX_CHARS = {
+  DOT_LITERAL,
+  PLUS_LITERAL,
+  QMARK_LITERAL,
+  SLASH_LITERAL,
+  ONE_CHAR,
+  QMARK,
+  END_ANCHOR,
+  DOTS_SLASH,
+  NO_DOT,
+  NO_DOTS,
+  NO_DOT_SLASH,
+  NO_DOTS_SLASH,
+  QMARK_NO_DOT,
+  STAR,
+  START_ANCHOR
+function markModuleAndImpureDependenciesAsExecuted(baseModule) {
+    baseModule.isExecuted = true;
+    const modules = [baseModule];
+    const visitedModules = new Set();
+    for (const module of modules) {
+        for (const dependency of [...module.dependencies, ...module.implicitlyLoadedBefore]) {
+            if (!(dependency instanceof ExternalModule) &&
+                !dependency.isExecuted &&
+                (dependency.info.moduleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
+                !visitedModules.has(dependency.id)) {
+                dependency.isExecuted = true;
+                visitedModules.add(dependency.id);
+                modules.push(dependency);
+            }
+        }
+    }
+}
+// This file is generated by scripts/generate-child-node-keys.js.
+// Do not edit this file directly.
+const childNodeKeys = {
+    ArrayExpression: ['elements'],
+    ArrayPattern: ['elements'],
+    ArrowFunctionExpression: ['params', 'body'],
+    AssignmentExpression: ['left', 'right'],
+    AssignmentPattern: ['left', 'right'],
+    AwaitExpression: ['argument'],
+    BinaryExpression: ['left', 'right'],
+    BlockStatement: ['body'],
+    BreakStatement: ['label'],
+    CallExpression: ['callee', 'arguments'],
+    CatchClause: ['param', 'body'],
+    ChainExpression: ['expression'],
+    ClassBody: ['body'],
+    ClassDeclaration: ['decorators', 'id', 'superClass', 'body'],
+    ClassExpression: ['decorators', 'id', 'superClass', 'body'],
+    ConditionalExpression: ['test', 'consequent', 'alternate'],
+    ContinueStatement: ['label'],
+    DebuggerStatement: [],
+    Decorator: ['expression'],
+    DoWhileStatement: ['body', 'test'],
+    EmptyStatement: [],
+    ExportAllDeclaration: ['exported', 'source', 'attributes'],
+    ExportDefaultDeclaration: ['declaration'],
+    ExportNamedDeclaration: ['specifiers', 'source', 'attributes', 'declaration'],
+    ExportSpecifier: ['local', 'exported'],
+    ExpressionStatement: ['expression'],
+    ForInStatement: ['left', 'right', 'body'],
+    ForOfStatement: ['left', 'right', 'body'],
+    ForStatement: ['init', 'test', 'update', 'body'],
+    FunctionDeclaration: ['id', 'params', 'body'],
+    FunctionExpression: ['id', 'params', 'body'],
+    Identifier: [],
+    IfStatement: ['test', 'consequent', 'alternate'],
+    ImportAttribute: ['key', 'value'],
+    ImportDeclaration: ['specifiers', 'source', 'attributes'],
+    ImportDefaultSpecifier: ['local'],
+    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'],
+    MemberExpression: ['object', 'property'],
+    MetaProperty: ['meta', 'property'],
+    MethodDefinition: ['decorators', 'key', 'value'],
+    NewExpression: ['callee', 'arguments'],
+    ObjectExpression: ['properties'],
+    ObjectPattern: ['properties'],
+    PanicError: [],
+    ParseError: [],
+    PrivateIdentifier: [],
+    Program: ['body'],
+    Property: ['key', 'value'],
+    PropertyDefinition: ['decorators', 'key', 'value'],
+    RestElement: ['argument'],
+    ReturnStatement: ['argument'],
+    SequenceExpression: ['expressions'],
+    SpreadElement: ['argument'],
+    StaticBlock: ['body'],
+    Super: [],
+    SwitchCase: ['test', 'consequent'],
+    SwitchStatement: ['discriminant', 'cases'],
+    TaggedTemplateExpression: ['tag', 'quasi'],
+    TemplateElement: [],
+    TemplateLiteral: ['quasis', 'expressions'],
+    ThisExpression: [],
+    ThrowStatement: ['argument'],
+    TryStatement: ['block', 'handler', 'finalizer'],
+    UnaryExpression: ['argument'],
+    UpdateExpression: ['argument'],
+    VariableDeclaration: ['declarations'],
+    VariableDeclarator: ['id', 'init'],
+    WhileStatement: ['test', 'body'],
+    YieldExpression: ['argument']
 };
-/**
- * Windows glob regex
- */
-const WINDOWS_CHARS = {
-  ...POSIX_CHARS,
-  SLASH_LITERAL: `[${WIN_SLASH}]`,
-  QMARK: WIN_NO_SLASH,
-  STAR: `${WIN_NO_SLASH}*?`,
-  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
-  NO_DOT: `(?!${DOT_LITERAL})`,
-  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
-  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
-  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
-};
-/**
- * POSIX Bracket Regex
- */
-const POSIX_REGEX_SOURCE$1 = {
-  alnum: 'a-zA-Z0-9',
-  alpha: 'a-zA-Z',
-  ascii: '\\x00-\\x7F',
-  blank: ' \\t',
-  cntrl: '\\x00-\\x1F\\x7F',
-  digit: '0-9',
-  graph: '\\x21-\\x7E',
-  lower: 'a-z',
-  print: '\\x20-\\x7E ',
-  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
-  space: ' \\t\\r\\n\\v\\f',
-  upper: 'A-Z',
-  word: 'A-Za-z0-9_',
-  xdigit: 'A-Fa-f0-9'
-};
-var constants$2 = {
-  MAX_LENGTH: 1024 * 64,
-  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
-  // regular expressions
-  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-  // Replace globs with equivalent patterns to reduce parsing time.
-  REPLACEMENTS: {
-    '***': '*',
-    '**/**': '**',
-    '**/**/**': '**'
-  },
-  // Digits
-  CHAR_0: 48, /* 0 */
-  CHAR_9: 57, /* 9 */
-  // Alphabet chars.
-  CHAR_UPPERCASE_A: 65, /* A */
-  CHAR_LOWERCASE_A: 97, /* a */
-  CHAR_UPPERCASE_Z: 90, /* Z */
-  CHAR_LOWERCASE_Z: 122, /* z */
-  CHAR_LEFT_PARENTHESES: 40, /* ( */
-  CHAR_RIGHT_PARENTHESES: 41, /* ) */
-  CHAR_ASTERISK: 42, /* * */
-  // Non-alphabetic chars.
-  CHAR_AMPERSAND: 38, /* & */
-  CHAR_AT: 64, /* @ */
-  CHAR_BACKWARD_SLASH: 92, /* \ */
-  CHAR_CARRIAGE_RETURN: 13, /* \r */
-  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
-  CHAR_COLON: 58, /* : */
-  CHAR_COMMA: 44, /* , */
-  CHAR_DOT: 46, /* . */
-  CHAR_DOUBLE_QUOTE: 34, /* " */
-  CHAR_EQUAL: 61, /* = */
-  CHAR_EXCLAMATION_MARK: 33, /* ! */
-  CHAR_FORM_FEED: 12, /* \f */
-  CHAR_FORWARD_SLASH: 47, /* / */
-  CHAR_GRAVE_ACCENT: 96, /* ` */
-  CHAR_HASH: 35, /* # */
-  CHAR_HYPHEN_MINUS: 45, /* - */
-  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
-  CHAR_LEFT_CURLY_BRACE: 123, /* { */
-  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
-  CHAR_LINE_FEED: 10, /* \n */
-  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
-  CHAR_PERCENT: 37, /* % */
-  CHAR_PLUS: 43, /* + */
-  CHAR_QUESTION_MARK: 63, /* ? */
-  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
-  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
-  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
-  CHAR_SEMICOLON: 59, /* ; */
-  CHAR_SINGLE_QUOTE: 39, /* ' */
-  CHAR_SPACE: 32, /*   */
-  CHAR_TAB: 9, /* \t */
-  CHAR_UNDERSCORE: 95, /* _ */
-  CHAR_VERTICAL_LINE: 124, /* | */
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
-  SEP: path$1.sep,
-  /**
-   * Create EXTGLOB_CHARS
-   */
-  extglobChars(chars) {
-    return {
-      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
-      '?': { type: 'qmark', open: '(?:', close: ')?' },
-      '+': { type: 'plus', open: '(?:', close: ')+' },
-      '*': { type: 'star', open: '(?:', close: ')*' },
-      '@': { type: 'at', open: '(?:', close: ')' }
-    };
-  },
-  /**
-   * Create GLOB_CHARS
-   */
-  globChars(win32) {
-    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+  }
-};
-(function (exports) {
-        const path = require$$0;
-        const win32 = process.platform === 'win32';
-        const {
-          REGEX_BACKSLASH,
-          REGEX_REMOVE_BACKSLASH,
-          REGEX_SPECIAL_CHARS,
-          REGEX_SPECIAL_CHARS_GLOBAL
-        } = constants$2;
-        exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
-        exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
-        exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
-        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.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;
+          }
-          return false;
-        };
-        exports.isWindows = options => {
-          if (options && typeof options.windows === 'boolean') {
-            return options.windows;
+          }
-          return win32 === true || path.sep === '\\';
-        };
-        exports.escapeLast = (input, char, lastIdx) => {
-          const idx = input.lastIndexOf(char, lastIdx);
-          if (idx === -1) return input;
-          if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
-          return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-        };
-        exports.removePrefix = (input, state = {}) => {
-          let output = input;
-          if (output.startsWith('./')) {
-            output = output.slice(2);
-            state.prefix = './';
+          }
-          return output;
-        };
-        exports.wrapOutput = (input, state = {}, options = {}) => {
-          const prepend = options.contains ? '' : '^';
-          const append = options.contains ? '' : '$';
-          let output = `${prepend}(?:${input})${append}`;
-          if (state.negated === true) {
-            output = `(?:^(?!${output}).*$)`;
+          }
-          return output;
-        };
-} (utils$3));
-const utils$2 = utils$3;
-const {
-  CHAR_ASTERISK,             /* * */
-  CHAR_AT,                   /* @ */
-  CHAR_BACKWARD_SLASH,       /* \ */
-  CHAR_COMMA,                /* , */
-  CHAR_DOT,                  /* . */
-  CHAR_EXCLAMATION_MARK,     /* ! */
-  CHAR_FORWARD_SLASH,        /* / */
-  CHAR_LEFT_CURLY_BRACE,     /* { */
-  CHAR_LEFT_PARENTHESES,     /* ( */
-  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
-  CHAR_PLUS,                 /* + */
-  CHAR_QUESTION_MARK,        /* ? */
-  CHAR_RIGHT_CURLY_BRACE,    /* } */
-  CHAR_RIGHT_PARENTHESES,    /* ) */
-  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
-} = constants$2;
-const isPathSeparator = code => {
-  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-};
-const depth = token => {
-  if (token.isPrefix !== true) {
-    token.depth = token.isGlobstar ? Infinity : 1;
+  }
-};
-/**
- * Quickly scans a glob pattern and returns an object with a handful of
- * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
- * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
- * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+ *
- * ```js
- * const pm = require('picomatch');
- * console.log(pm.scan('foo/bar/*.js'));
- * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {Object} Returns an object with tokens and regex source string.
- * @api public
- */
-const scan$1 = (input, options) => {
-  const opts = options || {};
-  const length = input.length - 1;
-  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-  const slashes = [];
-  const tokens = [];
-  const parts = [];
-  let str = input;
-  let index = -1;
-  let start = 0;
-  let lastIndex = 0;
-  let isBrace = false;
-  let isBracket = false;
-  let isGlob = false;
-  let isExtglob = false;
-  let isGlobstar = false;
-  let braceEscaped = false;
-  let backslashes = false;
-  let negated = false;
-  let negatedExtglob = false;
-  let finished = false;
-  let braces = 0;
-  let prev;
-  let code;
-  let token = { value: '', depth: 0, isGlob: false };
-  const eos = () => index >= length;
-  const peek = () => str.charCodeAt(index + 1);
-  const advance = () => {
-    prev = code;
-    return str.charCodeAt(++index);
-  };
-  while (index < length) {
-    code = advance();
-    let next;
-    if (code === CHAR_BACKWARD_SLASH) {
-      backslashes = token.backslashes = true;
-      code = advance();
-      if (code === CHAR_LEFT_CURLY_BRACE) {
-        braceEscaped = true;
+      }
-      continue;
+    }
-    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-      braces++;
-      while (eos() !== true && (code = advance())) {
-        if (code === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
+        }
-        if (code === CHAR_LEFT_CURLY_BRACE) {
-          braces++;
-          continue;
+        }
-        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          if (scanToEnd === true) {
-            continue;
+          }
-          break;
+        }
-        if (braceEscaped !== true && code === CHAR_COMMA) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          if (scanToEnd === true) {
-            continue;
+          }
-          break;
+        }
-        if (code === CHAR_RIGHT_CURLY_BRACE) {
-          braces--;
-          if (braces === 0) {
-            braceEscaped = false;
-            isBrace = token.isBrace = true;
-            finished = true;
-            break;
+          }
+        }
+      }
-      if (scanToEnd === true) {
-        continue;
+      }
-      break;
+    }
-    if (code === CHAR_FORWARD_SLASH) {
-      slashes.push(index);
-      tokens.push(token);
-      token = { value: '', depth: 0, isGlob: false };
-      if (finished === true) continue;
-      if (prev === CHAR_DOT && index === (start + 1)) {
-        start += 2;
-        continue;
+      }
-      lastIndex = index + 1;
-      continue;
+    }
-    if (opts.noext !== true) {
-      const isExtglobChar = code === CHAR_PLUS
-        || code === CHAR_AT
-        || code === CHAR_ASTERISK
-        || code === CHAR_QUESTION_MARK
-        || code === CHAR_EXCLAMATION_MARK;
-      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
-        isGlob = token.isGlob = true;
-        isExtglob = token.isExtglob = true;
-        finished = true;
-        if (code === CHAR_EXCLAMATION_MARK && index === start) {
-          negatedExtglob = true;
+        }
-        if (scanToEnd === true) {
-          while (eos() !== true && (code = advance())) {
-            if (code === CHAR_BACKWARD_SLASH) {
-              backslashes = token.backslashes = true;
-              code = advance();
-              continue;
+            }
-            if (code === CHAR_RIGHT_PARENTHESES) {
-              isGlob = token.isGlob = true;
-              finished = true;
-              break;
+            }
+          }
-          continue;
+        }
-        break;
+      }
+    }
-    if (code === CHAR_ASTERISK) {
-      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
-      isGlob = token.isGlob = true;
-      finished = true;
-      if (scanToEnd === true) {
-        continue;
+      }
-      break;
+    }
-    if (code === CHAR_QUESTION_MARK) {
-      isGlob = token.isGlob = true;
-      finished = true;
-      if (scanToEnd === true) {
-        continue;
+      }
-      break;
+    }
-    if (code === CHAR_LEFT_SQUARE_BRACKET) {
-      while (eos() !== true && (next = advance())) {
-        if (next === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
+        }
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-          isBracket = token.isBracket = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          break;
+        }
+      }
-      if (scanToEnd === true) {
-        continue;
+      }
-      break;
+    }
-    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-      negated = token.negated = true;
-      start++;
-      continue;
+    }
-    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-      isGlob = token.isGlob = true;
-      if (scanToEnd === true) {
-        while (eos() !== true && (code = advance())) {
-          if (code === CHAR_LEFT_PARENTHESES) {
-            backslashes = token.backslashes = true;
-            code = advance();
-            continue;
+          }
-          if (code === CHAR_RIGHT_PARENTHESES) {
-            finished = true;
-            break;
+          }
+        }
-        continue;
+      }
-      break;
+    }
-    if (isGlob === true) {
-      finished = true;
-      if (scanToEnd === true) {
-        continue;
+      }
-      break;
+    }
+  }
-  if (opts.noext === true) {
-    isExtglob = false;
-    isGlob = false;
+  }
-  let base = str;
-  let prefix = '';
-  let glob = '';
-  if (start > 0) {
-    prefix = str.slice(0, start);
-    str = str.slice(start);
-    lastIndex -= start;
+  }
-  if (base && isGlob === true && lastIndex > 0) {
-    base = str.slice(0, lastIndex);
-    glob = str.slice(lastIndex);
-  } else if (isGlob === true) {
-    base = '';
-    glob = str;
-  } else {
-    base = str;
+  }
-  if (base && base !== '' && base !== '/' && base !== str) {
-    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-      base = base.slice(0, -1);
+    }
+  }
-  if (opts.unescape === true) {
-    if (glob) glob = utils$2.removeBackslashes(glob);
-    if (base && backslashes === true) {
-      base = utils$2.removeBackslashes(base);
+    }
+  }
-  const state = {
-    prefix,
-    input,
-    start,
-    base,
-    glob,
-    isBrace,
-    isBracket,
-    isGlob,
-    isExtglob,
-    isGlobstar,
-    negated,
-    negatedExtglob
-  };
-  if (opts.tokens === true) {
-    state.maxDepth = 0;
-    if (!isPathSeparator(code)) {
-      tokens.push(token);
+    }
-    state.tokens = tokens;
+  }
-  if (opts.parts === true || opts.tokens === true) {
-    let prevIndex;
-    for (let idx = 0; idx < slashes.length; idx++) {
-      const n = prevIndex ? prevIndex + 1 : start;
-      const i = slashes[idx];
-      const value = input.slice(n, i);
-      if (opts.tokens) {
-        if (idx === 0 && start !== 0) {
-          tokens[idx].isPrefix = true;
-          tokens[idx].value = prefix;
-        } else {
-          tokens[idx].value = value;
+        }
-        depth(tokens[idx]);
-        state.maxDepth += tokens[idx].depth;
+      }
-      if (idx !== 0 || value !== '') {
-        parts.push(value);
+      }
-      prevIndex = i;
+    }
-    if (prevIndex && prevIndex + 1 < input.length) {
-      const value = input.slice(prevIndex + 1);
-      parts.push(value);
-      if (opts.tokens) {
-        tokens[tokens.length - 1].value = value;
-        depth(tokens[tokens.length - 1]);
-        state.maxDepth += tokens[tokens.length - 1].depth;
+      }
+    }
-    state.slashes = slashes;
-    state.parts = parts;
+  }
-  return state;
-};
-var scan_1 = scan$1;
-const constants$1 = constants$2;
-const utils$1 = utils$3;
-/**
- * Constants
- */
-const {
-  MAX_LENGTH,
-  POSIX_REGEX_SOURCE,
-  REGEX_NON_SPECIAL_CHARS,
-  REGEX_SPECIAL_CHARS_BACKREF,
-  REPLACEMENTS
-} = constants$1;
-/**
- * Helpers
- */
-const expandRange = (args, options) => {
-  if (typeof options.expandRange === 'function') {
-    return options.expandRange(...args, options);
+  }
-  args.sort();
-  const value = `[${args.join('-')}]`;
-  return value;
-};
-/**
- * Create the message for a syntax error
- */
-const syntaxError = (type, char) => {
-  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-};
-/**
- * Parse the given input string.
- * @param {String} input
- * @param {Object} options
- * @return {Object}
- */
-const parse$1 = (input, options) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected a string');
+  }
-  input = REPLACEMENTS[input] || input;
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  let len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
-  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
-  const tokens = [bos];
-  const capture = opts.capture ? '' : '?:';
-  const win32 = utils$1.isWindows(options);
-  // create constants based on platform, for windows or posix
-  const PLATFORM_CHARS = constants$1.globChars(win32);
-  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
-  const {
-    DOT_LITERAL,
-    PLUS_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOT_SLASH,
-    NO_DOTS_SLASH,
-    QMARK,
-    QMARK_NO_DOT,
-    STAR,
-    START_ANCHOR
-  } = PLATFORM_CHARS;
-  const globstar = opts => {
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
-  const nodot = opts.dot ? '' : NO_DOT;
-  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
-  let star = opts.bash === true ? globstar(opts) : STAR;
-  if (opts.capture) {
-    star = `(${star})`;
+  }
-  // minimatch options support
-  if (typeof opts.noext === 'boolean') {
-    opts.noextglob = opts.noext;
+  }
-  const state = {
-    input,
-    index: -1,
-    start: 0,
-    dot: opts.dot === true,
-    consumed: '',
-    output: '',
-    prefix: '',
-    backtrack: false,
-    negated: false,
-    brackets: 0,
-    braces: 0,
-    parens: 0,
-    quotes: 0,
-    globstar: false,
-    tokens
-  };
-  input = utils$1.removePrefix(input, state);
-  len = input.length;
-  const extglobs = [];
-  const braces = [];
-  const stack = [];
-  let prev = bos;
-  let value;
-  /**
-   * Tokenizing helpers
-   */
-  const eos = () => state.index === len - 1;
-  const peek = state.peek = (n = 1) => input[state.index + n];
-  const advance = state.advance = () => input[++state.index] || '';
-  const remaining = () => input.slice(state.index + 1);
-  const consume = (value = '', num = 0) => {
-    state.consumed += value;
-    state.index += num;
-  };
-  const append = token => {
-    state.output += token.output != null ? token.output : token.value;
-    consume(token.value);
-  };
-  const negate = () => {
-    let count = 1;
-    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
-      advance();
-      state.start++;
-      count++;
+    }
-    if (count % 2 === 0) {
-      return false;
+    }
-    state.negated = true;
-    state.start++;
-    return true;
-  };
-  const increment = type => {
-    state[type]++;
-    stack.push(type);
-  };
-  const decrement = type => {
-    state[type]--;
-    stack.pop();
-  };
-  /**
-   * Push tokens onto the tokens array. This helper speeds up
-   * tokenizing by 1) helping us avoid backtracking as much as possible,
-   * and 2) helping us avoid creating extra tokens when consecutive
-   * characters are plain text. This improves performance and simplifies
-   * lookbehinds.
-   */
-  const push = tok => {
-    if (prev.type === 'globstar') {
-      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
-      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
-      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
-        state.output = state.output.slice(0, -prev.output.length);
-        prev.type = 'star';
-        prev.value = '*';
-        prev.output = star;
-        state.output += prev.output;
+      }
+    }
-    if (extglobs.length && tok.type !== 'paren') {
-      extglobs[extglobs.length - 1].inner += tok.value;
+    }
-    if (tok.value || tok.output) append(tok);
-    if (prev && prev.type === 'text' && tok.type === 'text') {
-      prev.value += tok.value;
-      prev.output = (prev.output || '') + tok.value;
-      return;
+    }
-    tok.prev = prev;
-    tokens.push(tok);
-    prev = tok;
-  };
-  const extglobOpen = (type, value) => {
-    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
-    token.prev = prev;
-    token.parens = state.parens;
-    token.output = state.output;
-    const output = (opts.capture ? '(' : '') + token.open;
-    increment('parens');
-    push({ type, value, output: state.output ? '' : ONE_CHAR });
-    push({ type: 'paren', extglob: true, value: advance(), output });
-    extglobs.push(token);
-  };
-  const extglobClose = token => {
-    let output = token.close + (opts.capture ? ')' : '');
-    let rest;
-    if (token.type === 'negate') {
-      let extglobStar = star;
-      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
-        extglobStar = globstar(opts);
+      }
-      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
-        output = token.close = `)$))${extglobStar}`;
+      }
-      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
-        // In this case, we need to parse the string and use it in the output of the original pattern.
-        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
-        //
-        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
-        const expression = parse$1(rest, { ...options, fastpaths: false }).output;
-        output = token.close = `)${expression})${extglobStar})`;
+      }
-      if (token.prev.type === 'bos') {
-        state.negatedExtglob = true;
+      }
+    }
-    push({ type: 'paren', extglob: true, value, output });
-    decrement('parens');
-  };
-  /**
-   * Fast paths
-   */
-  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-    let backslashes = false;
-    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
-      if (first === '\\') {
-        backslashes = true;
-        return m;
+      }
-      if (first === '?') {
-        if (esc) {
-          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+        }
-        if (index === 0) {
-          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+        }
-        return QMARK.repeat(chars.length);
+      }
-      if (first === '.') {
-        return DOT_LITERAL.repeat(chars.length);
+      }
-      if (first === '*') {
-        if (esc) {
-          return esc + first + (rest ? star : '');
+        }
-        return star;
+      }
-      return esc ? m : `\\${m}`;
-    });
-    if (backslashes === true) {
-      if (opts.unescape === true) {
-        output = output.replace(/\\/g, '');
-      } else {
-        output = output.replace(/\\+/g, m => {
-          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
-        });
+      }
+    }
-    if (output === input && opts.contains === true) {
-      state.output = input;
-      return state;
+    }
-    state.output = utils$1.wrapOutput(output, state, options);
-    return state;
+  }
-  /**
-   * Tokenize input until we reach end-of-string
-   */
-  while (!eos()) {
-    value = advance();
-    if (value === '\u0000') {
-      continue;
+    }
-    /**
-     * Escaped characters
-     */
-    if (value === '\\') {
-      const next = peek();
-      if (next === '/' && opts.bash !== true) {
-        continue;
+      }
-      if (next === '.' || next === ';') {
-        continue;
+      }
-      if (!next) {
-        value += '\\';
-        push({ type: 'text', value });
-        continue;
+      }
-      // collapse slashes to reduce potential for exploits
-      const match = /^\\+/.exec(remaining());
-      let slashes = 0;
-      if (match && match[0].length > 2) {
-        slashes = match[0].length;
-        state.index += slashes;
-        if (slashes % 2 !== 0) {
-          value += '\\';
+        }
+      }
-      if (opts.unescape === true) {
-        value = advance();
-      } else {
-        value += advance();
+      }
-      if (state.brackets === 0) {
-        push({ type: 'text', value });
-        continue;
+      }
+    }
-    /**
-     * If we're inside a regex character class, continue
-     * until we reach the closing bracket.
-     */
-    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
-      if (opts.posix !== false && value === ':') {
-        const inner = prev.value.slice(1);
-        if (inner.includes('[')) {
-          prev.posix = true;
-          if (inner.includes(':')) {
-            const idx = prev.value.lastIndexOf('[');
-            const pre = prev.value.slice(0, idx);
-            const rest = prev.value.slice(idx + 2);
-            const posix = POSIX_REGEX_SOURCE[rest];
-            if (posix) {
-              prev.value = pre + posix;
-              state.backtrack = true;
-              advance();
-              if (!bos.output && tokens.indexOf(prev) === 1) {
-                bos.output = ONE_CHAR;
+              }
-              continue;
+            }
+          }
+        }
+      }
-      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
-        value = `\\${value}`;
+      }
-      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
-        value = `\\${value}`;
+      }
-      if (opts.posix === true && value === '!' && prev.value === '[') {
-        value = '^';
+      }
-      prev.value += value;
-      append({ value });
-      continue;
+    }
-    /**
-     * If we're inside a quoted string, continue
-     * until we reach the closing double quote.
-     */
-    if (state.quotes === 1 && value !== '"') {
-      value = utils$1.escapeRegex(value);
-      prev.value += value;
-      append({ value });
-      continue;
+    }
-    /**
-     * Double quotes
-     */
-    if (value === '"') {
-      state.quotes = state.quotes === 1 ? 0 : 1;
-      if (opts.keepQuotes === true) {
-        push({ type: 'text', value });
+      }
-      continue;
+    }
-    /**
-     * Parentheses
-     */
-    if (value === '(') {
-      increment('parens');
-      push({ type: 'paren', value });
-      continue;
+    }
-    if (value === ')') {
-      if (state.parens === 0 && opts.strictBrackets === true) {
-        throw new SyntaxError(syntaxError('opening', '('));
+      }
-      const extglob = extglobs[extglobs.length - 1];
-      if (extglob && state.parens === extglob.parens + 1) {
-        extglobClose(extglobs.pop());
-        continue;
+      }
-      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
-      decrement('parens');
-      continue;
+    }
-    /**
-     * Square brackets
-     */
-    if (value === '[') {
-      if (opts.nobracket === true || !remaining().includes(']')) {
-        if (opts.nobracket !== true && opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('closing', ']'));
+        }
-        value = `\\${value}`;
-      } else {
-        increment('brackets');
+      }
-      push({ type: 'bracket', value });
-      continue;
+    }
-    if (value === ']') {
-      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
+      }
-      if (state.brackets === 0) {
-        if (opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('opening', '['));
+        }
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
+      }
-      decrement('brackets');
-      const prevValue = prev.value.slice(1);
-      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
-        value = `/${value}`;
+      }
-      prev.value += value;
-      append({ value });
-      // when literal brackets are explicitly disabled
-      // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {
-        continue;
+      }
-      const escaped = utils$1.escapeRegex(prev.value);
-      state.output = state.output.slice(0, -prev.value.length);
-      // when literal brackets are explicitly enabled
-      // assume we should escape the brackets to match literal characters
-      if (opts.literalBrackets === true) {
-        state.output += escaped;
-        prev.value = escaped;
-        continue;
+      }
-      // when the user specifies nothing, try to match both
-      prev.value = `(${capture}${escaped}|${prev.value})`;
-      state.output += prev.value;
-      continue;
+    }
-    /**
-     * Braces
-     */
-    if (value === '{' && opts.nobrace !== true) {
-      increment('braces');
-      const open = {
-        type: 'brace',
-        value,
-        output: '(',
-        outputIndex: state.output.length,
-        tokensIndex: state.tokens.length
-      };
-      braces.push(open);
-      push(open);
-      continue;
+    }
-    if (value === '}') {
-      const brace = braces[braces.length - 1];
-      if (opts.nobrace === true || !brace) {
-        push({ type: 'text', value, output: value });
-        continue;
+      }
-      let output = ')';
-      if (brace.dots === true) {
-        const arr = tokens.slice();
-        const range = [];
-        for (let i = arr.length - 1; i >= 0; i--) {
-          tokens.pop();
-          if (arr[i].type === 'brace') {
-            break;
+          }
-          if (arr[i].type !== 'dots') {
-            range.unshift(arr[i].value);
+          }
+        }
-        output = expandRange(range, opts);
-        state.backtrack = true;
+      }
-      if (brace.comma !== true && brace.dots !== true) {
-        const out = state.output.slice(0, brace.outputIndex);
-        const toks = state.tokens.slice(brace.tokensIndex);
-        brace.value = brace.output = '\\{';
-        value = output = '\\}';
-        state.output = out;
-        for (const t of toks) {
-          state.output += (t.output || t.value);
+        }
+      }
-      push({ type: 'brace', value, output });
-      decrement('braces');
-      braces.pop();
-      continue;
+    }
-    /**
-     * Pipes
-     */
-    if (value === '|') {
-      if (extglobs.length > 0) {
-        extglobs[extglobs.length - 1].conditions++;
+      }
-      push({ type: 'text', value });
-      continue;
+    }
-    /**
-     * Commas
-     */
-    if (value === ',') {
-      let output = value;
-      const brace = braces[braces.length - 1];
-      if (brace && stack[stack.length - 1] === 'braces') {
-        brace.comma = true;
-        output = '|';
+      }
-      push({ type: 'comma', value, output });
-      continue;
+    }
-    /**
-     * Slashes
-     */
-    if (value === '/') {
-      // if the beginning of the glob is "./", advance the start
-      // to the current index, and don't add the "./" characters
-      // to the state. This greatly simplifies lookbehinds when
-      // checking for BOS characters like "!" and "." (not "./")
-      if (prev.type === 'dot' && state.index === state.start + 1) {
-        state.start = state.index + 1;
-        state.consumed = '';
-        state.output = '';
-        tokens.pop();
-        prev = bos; // reset "prev" to the first token
-        continue;
+      }
-      push({ type: 'slash', value, output: SLASH_LITERAL });
-      continue;
+    }
-    /**
-     * Dots
-     */
-    if (value === '.') {
-      if (state.braces > 0 && prev.type === 'dot') {
-        if (prev.value === '.') prev.output = DOT_LITERAL;
-        const brace = braces[braces.length - 1];
-        prev.type = 'dots';
-        prev.output += value;
-        prev.value += value;
-        brace.dots = true;
-        continue;
+      }
-      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
-        push({ type: 'text', value, output: DOT_LITERAL });
-        continue;
+      }
-      push({ type: 'dot', value, output: DOT_LITERAL });
-      continue;
+    }
-    /**
-     * Question marks
-     */
-    if (value === '?') {
-      const isGroup = prev && prev.value === '(';
-      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('qmark', value);
-        continue;
+      }
-      if (prev && prev.type === 'paren') {
-        const next = peek();
-        let output = value;
-        if (next === '<' && !utils$1.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}`;
+        }
-        push({ type: 'text', value, output });
-        continue;
+      }
-      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
-        push({ type: 'qmark', value, output: QMARK_NO_DOT });
-        continue;
+      }
-      push({ type: 'qmark', value, output: QMARK });
-      continue;
+    }
-    /**
-     * Exclamation
-     */
-    if (value === '!') {
-      if (opts.noextglob !== true && peek() === '(') {
-        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
-          extglobOpen('negate', value);
-          continue;
+        }
+      }
-      if (opts.nonegate !== true && state.index === 0) {
-        negate();
-        continue;
+      }
+    }
-    /**
-     * Plus
-     */
-    if (value === '+') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('plus', value);
-        continue;
+      }
-      if ((prev && prev.value === '(') || opts.regex === false) {
-        push({ type: 'plus', value, output: PLUS_LITERAL });
-        continue;
+      }
-      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
-        push({ type: 'plus', value });
-        continue;
+      }
-      push({ type: 'plus', value: PLUS_LITERAL });
-      continue;
+    }
-    /**
-     * Plain text
-     */
-    if (value === '@') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        push({ type: 'at', extglob: true, value, output: '' });
-        continue;
+      }
-      push({ type: 'text', value });
-      continue;
+    }
-    /**
-     * Plain text
-     */
-    if (value !== '*') {
-      if (value === '$' || value === '^') {
-        value = `\\${value}`;
+      }
-      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-      if (match) {
-        value += match[0];
-        state.index += match[0].length;
+      }
-      push({ type: 'text', value });
-      continue;
+    }
-    /**
-     * Stars
-     */
-    if (prev && (prev.type === 'globstar' || prev.star === true)) {
-      prev.type = 'star';
-      prev.star = true;
-      prev.value += value;
-      prev.output = star;
-      state.backtrack = true;
-      state.globstar = true;
-      consume(value);
-      continue;
+    }
-    let rest = remaining();
-    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-      extglobOpen('star', value);
-      continue;
+    }
-    if (prev.type === 'star') {
-      if (opts.noglobstar === true) {
-        consume(value);
-        continue;
+      }
-      const prior = prev.prev;
-      const before = prior.prev;
-      const isStart = prior.type === 'slash' || prior.type === 'bos';
-      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
-      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
-        push({ type: 'star', value, output: '' });
-        continue;
+      }
-      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
-      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
-      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
-        push({ type: 'star', value, output: '' });
-        continue;
+      }
-      // strip consecutive `/**/`
-      while (rest.slice(0, 3) === '/**') {
-        const after = input[state.index + 4];
-        if (after && after !== '/') {
-          break;
+        }
-        rest = rest.slice(3);
-        consume('/**', 3);
+      }
-      if (prior.type === 'bos' && eos()) {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = globstar(opts);
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value);
-        continue;
+      }
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
-        prev.type = 'globstar';
-        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
-        prev.value += value;
-        state.globstar = true;
-        state.output += prior.output + prev.output;
-        consume(value);
-        continue;
+      }
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
-        const end = rest[1] !== void 0 ? '|$' : '';
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
-        prev.type = 'globstar';
-        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
-        prev.value += value;
-        state.output += prior.output + prev.output;
-        state.globstar = true;
-        consume(value + advance());
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
+      }
-      if (prior.type === 'bos' && rest[0] === '/') {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value + advance());
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
+      }
-      // remove single star from output
-      state.output = state.output.slice(0, -prev.output.length);
-      // reset previous token to globstar
-      prev.type = 'globstar';
-      prev.output = globstar(opts);
-      prev.value += value;
-      // reset output with globstar
-      state.output += prev.output;
-      state.globstar = true;
-      consume(value);
-      continue;
+    }
-    const token = { type: 'star', value, output: star };
-    if (opts.bash === true) {
-      token.output = '.*?';
-      if (prev.type === 'bos' || prev.type === 'slash') {
-        token.output = nodot + token.output;
+      }
-      push(token);
-      continue;
+    }
-    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
-      token.output = value;
-      push(token);
-      continue;
+    }
-    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
-      if (prev.type === 'dot') {
-        state.output += NO_DOT_SLASH;
-        prev.output += NO_DOT_SLASH;
-      } else if (opts.dot === true) {
-        state.output += NO_DOTS_SLASH;
-        prev.output += NO_DOTS_SLASH;
-      } else {
-        state.output += nodot;
-        prev.output += nodot;
+      }
-      if (peek() !== '*') {
-        state.output += ONE_CHAR;
-        prev.output += ONE_CHAR;
+      }
+    }
-    push(token);
+  }
-  while (state.brackets > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$1.escapeLast(state.output, '[');
-    decrement('brackets');
+  }
-  while (state.parens > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
-    state.output = utils$1.escapeLast(state.output, '(');
-    decrement('parens');
+  }
-  while (state.braces > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
-    state.output = utils$1.escapeLast(state.output, '{');
-    decrement('braces');
+  }
-  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
-    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+  }
-  // rebuild the output if we had to backtrack at any point
-  if (state.backtrack === true) {
-    state.output = '';
-    for (const token of state.tokens) {
-      state.output += token.output != null ? token.output : token.value;
-      if (token.suffix) {
-        state.output += token.suffix;
+      }
+    }
+  }
-  return state;
-};
-/**
- * Fast paths for creating regular expressions for common glob patterns.
- * This can significantly speed up processing and has very little downside
- * impact when none of the fast paths match.
- */
-parse$1.fastpaths = (input, options) => {
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  const len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
-  input = REPLACEMENTS[input] || input;
-  const win32 = utils$1.isWindows(options);
-  // create constants based on platform, for windows or posix
-  const {
-    DOT_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOTS,
-    NO_DOTS_SLASH,
-    STAR,
-    START_ANCHOR
-  } = constants$1.globChars(win32);
-  const nodot = opts.dot ? NO_DOTS : NO_DOT;
-  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
-  const capture = opts.capture ? '' : '?:';
-  const state = { negated: false, prefix: '' };
-  let star = opts.bash === true ? '.*?' : STAR;
-  if (opts.capture) {
-    star = `(${star})`;
+  }
-  const globstar = opts => {
-    if (opts.noglobstar === true) return star;
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
-  const create = str => {
-    switch (str) {
-      case '*':
-        return `${nodot}${ONE_CHAR}${star}`;
-      case '.*':
-        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
-      case '*.*':
-        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-      case '*/*':
-        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
-      case '**':
-        return nodot + globstar(opts);
-      case '**/*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
-      case '**/*.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-      case '**/.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
-      default: {
-        const match = /^(.*?)\.(\w+)$/.exec(str);
-        if (!match) return;
-        const source = create(match[1]);
-        if (!source) return;
-        return source + DOT_LITERAL + match[2];
+      }
+    }
-  };
-  const output = utils$1.removePrefix(input, state);
-  let source = create(output);
-  if (source && opts.strictSlashes !== true) {
-    source += `${SLASH_LITERAL}?`;
+  }
-  return source;
-};
-var parse_1 = parse$1;
-const path = require$$0;
-const scan = scan_1;
-const parse = parse_1;
-const utils = utils$3;
-const constants = constants$2;
-const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
-/**
- * Creates a matcher function from one or more glob patterns. The
- * returned function takes a string to match as its first argument,
- * and returns true if the string is a match. The returned matcher
- * function also takes a boolean as the second argument that, when true,
- * returns an object with additional information.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch(glob[, options]);
+ *
- * const isMatch = picomatch('*.!(*a)');
- * console.log(isMatch('a.a')); //=> false
- * console.log(isMatch('a.b')); //=> true
- * ```
- * @name picomatch
- * @param {String|Array} `globs` One or more glob patterns.
- * @param {Object=} `options`
- * @return {Function=} Returns a matcher function.
- * @api public
- */
-const picomatch$1 = (glob, options, returnState = false) => {
-  if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch$1(input, options, returnState));
-    const arrayMatcher = str => {
-      for (const isMatch of fns) {
-        const state = isMatch(str);
-        if (state) return state;
+      }
-      return false;
-    };
-    return arrayMatcher;
+  }
-  const isState = isObject(glob) && glob.tokens && glob.input;
-  if (glob === '' || (typeof glob !== 'string' && !isState)) {
-    throw new TypeError('Expected pattern to be a non-empty string');
+  }
-  const opts = options || {};
-  const posix = utils.isWindows(options);
-  const regex = isState
-    ? picomatch$1.compileRe(glob, options)
-    : picomatch$1.makeRe(glob, options, false, true);
-  const state = regex.state;
-  delete regex.state;
-  let isIgnored = () => false;
-  if (opts.ignore) {
-    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
+  }
-  const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch$1.test(input, regex, options, { glob, posix });
-    const result = { glob, state, regex, posix, input, output, match, isMatch };
-    if (typeof opts.onResult === 'function') {
-      opts.onResult(result);
+    }
-    if (isMatch === false) {
-      result.isMatch = false;
-      return returnObject ? result : false;
+    }
-    if (isIgnored(input)) {
-      if (typeof opts.onIgnore === 'function') {
-        opts.onIgnore(result);
+      }
-      result.isMatch = false;
-      return returnObject ? result : false;
+    }
-    if (typeof opts.onMatch === 'function') {
-      opts.onMatch(result);
+    }
-    return returnObject ? result : true;
-  };
-  if (returnState) {
-    matcher.state = state;
+  }
-  return matcher;
-};
-/**
- * Test `input` with the given `regex`. This is used by the main
- * `picomatch()` function to test the input string.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.test(input, regex[, options]);
+ *
- * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
- * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp} `regex`
- * @return {Object} Returns an object with matching info.
- * @api public
- */
-picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected input to be a string');
+  }
-  if (input === '') {
-    return { isMatch: false, output: '' };
+  }
-  const opts = options || {};
-  const format = opts.format || (posix ? utils.toPosixSlashes : null);
-  let match = input === glob;
-  let output = (match && format) ? format(input) : input;
-  if (match === false) {
-    output = format ? format(input) : input;
-    match = output === glob;
+  }
-  if (match === false || opts.capture === true) {
-    if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch$1.matchBase(input, regex, options, posix);
-    } else {
-      match = regex.exec(output);
+    }
+  }
-  return { isMatch: Boolean(match), match, output };
-};
-/**
- * Match the basename of a filepath.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.matchBase(input, glob[, options]);
- * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
- * @return {Boolean}
- * @api public
- */
-picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
-  return regex.test(path.basename(input));
-};
-/**
- * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.isMatch(string, patterns[, options]);
+ *
- * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
- * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
- * ```
- * @param {String|Array} str The string to test.
- * @param {String|Array} patterns One or more glob patterns to use for matching.
- * @param {Object} [options] See available [options](#options).
- * @return {Boolean} Returns true if any patterns match `str`
- * @api public
- */
-picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
-/**
- * Parse a glob pattern to create the source string for a regular
- * expression.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * const result = picomatch.parse(pattern[, options]);
- * ```
- * @param {String} `pattern`
- * @param {Object} `options`
- * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
- * @api public
- */
-picomatch$1.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch$1.parse(p, options));
-  return parse(pattern, { ...options, fastpaths: false });
-};
-/**
- * Scan a glob pattern to separate the pattern into segments.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.scan(input[, options]);
+ *
- * const result = picomatch.scan('!./foo/*.js');
- * console.log(result);
- * { prefix: '!./',
- *   input: '!./foo/*.js',
- *   start: 3,
- *   base: 'foo',
- *   glob: '*.js',
- *   isBrace: false,
- *   isBracket: false,
- *   isGlob: true,
- *   isExtglob: false,
- *   isGlobstar: false,
- *   negated: true }
- * ```
- * @param {String} `input` Glob pattern to scan.
- * @param {Object} `options`
- * @return {Object} Returns an object with
- * @api public
- */
-picomatch$1.scan = (input, options) => scan(input, options);
-/**
- * Compile a regular expression from the `state` object returned by the
- * [parse()](#parse) method.
+ *
- * @param {Object} `state`
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
- * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
- * @return {RegExp}
- * @api public
- */
-picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
-  if (returnOutput === true) {
-    return state.output;
+  }
-  const opts = options || {};
-  const prepend = opts.contains ? '' : '^';
-  const append = opts.contains ? '' : '$';
-  let source = `${prepend}(?:${state.output})${append}`;
-  if (state && state.negated === true) {
-    source = `^(?!${source}).*$`;
+  }
-  const regex = picomatch$1.toRegex(source, options);
-  if (returnState === true) {
-    regex.state = state;
+  }
-  return regex;
-};
-/**
- * Create a regular expression from a parsed glob pattern.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * const state = picomatch.parse('*.js');
- * // picomatch.compileRe(state[, options]);
+ *
- * console.log(picomatch.compileRe(state));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `state` The object returned from the `.parse` method.
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
- * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
- * @return {RegExp} Returns a regex created from the given pattern.
- * @api public
- */
-picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-  if (!input || typeof input !== 'string') {
-    throw new TypeError('Expected a non-empty string');
+  }
-  let parsed = { negated: false, fastpaths: true };
-  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    parsed.output = parse.fastpaths(input, options);
+  }
-  if (!parsed.output) {
-    parsed = parse(input, options);
+  }
-  return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
-};
-/**
- * Create a regular expression from the given regex source string.
+ *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.toRegex(source[, options]);
+ *
- * const { output } = picomatch.parse('*.js');
- * console.log(picomatch.toRegex(output));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `source` Regular expression source string.
- * @param {Object} `options`
- * @return {RegExp}
- * @api public
- */
-picomatch$1.toRegex = (source, options) => {
-  try {
-    const opts = options || {};
-    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
-  } catch (err) {
-    if (options && options.debug === true) throw err;
-    return /$^/;
+  }
-};
-/**
- * Picomatch constants.
- * @return {Object}
- */
-picomatch$1.constants = constants;
-/**
- * Expose "picomatch"
- */
-var picomatch_1 = picomatch$1;
-var picomatch = picomatch_1;
-const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
-const extractors = {
-    ArrayPattern(names, param) {
-        for (const element of param.elements) {
-            if (element)
-                extractors[element.type](names, element);
+        }
-    },
-    AssignmentPattern(names, param) {
-        extractors[param.left.type](names, param.left);
-    },
-    Identifier(names, param) {
-        names.push(param.name);
-    },
-    MemberExpression() { },
-    ObjectPattern(names, param) {
-        for (const prop of param.properties) {
-            // @ts-ignore Typescript reports that this is not a valid type
-            if (prop.type === 'RestElement') {
-                extractors.RestElement(names, prop);
+            }
-            else {
-                extractors[prop.value.type](names, prop.value);
+            }
+        }
-    },
-    RestElement(names, param) {
-        extractors[param.argument.type](names, param.argument);
+    }
-};
-const extractAssignedNames = function extractAssignedNames(param) {
-    const names = [];
-    extractors[param.type](names, param);
-    return names;
-};
-// Helper since Typescript can't detect readonly arrays with Array.isArray
-function isArray(arg) {
-    return Array.isArray(arg);
+}
-function ensureArray(thing) {
-    if (isArray(thing))
-        return thing;
-    if (thing == null)
-        return [];
-    return [thing];
+}
-const normalizePath = function normalizePath(filename) {
-    return filename.split(require$$0.win32.sep).join(require$$0.posix.sep);
-};
-function getMatcherString(id, resolutionBase) {
-    if (resolutionBase === false || require$$0.isAbsolute(id) || id.startsWith('**')) {
-        return normalizePath(id);
+    }
-    // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath(require$$0.resolve(resolutionBase || ''))
-        // escape all possible (posix + win) path characters that might interfere with regex
-        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
-    // Note that we use posix.join because:
-    // 1. the basePath has been normalized to use /
-    // 2. the incoming glob (id) matcher, also uses /
-    // otherwise Node will force backslash (\) on windows
-    return require$$0.posix.join(basePath, normalizePath(id));
+}
-const createFilter = function createFilter(include, exclude, options) {
-    const resolutionBase = options && options.resolve;
-    const getMatcher = (id) => id instanceof RegExp
-        ? id
-        : {
-            test: (what) => {
-                // this refactor is a tad overly verbose but makes for easy debugging
-                const pattern = getMatcherString(id, resolutionBase);
-                const fn = pm(pattern, { dot: true });
-                const result = fn(what);
-                return result;
+            }
-        };
-    const includeMatchers = ensureArray(include).map(getMatcher);
-    const excludeMatchers = ensureArray(exclude).map(getMatcher);
-    return function result(id) {
-        if (typeof id !== 'string')
-            return false;
-        if (/\0/.test(id))
-            return false;
-        const pathId = normalizePath(id);
-        for (let i = 0; i < excludeMatchers.length; ++i) {
-            const matcher = excludeMatchers[i];
-            if (matcher.test(pathId))
-                return false;
+        }
-        for (let i = 0; i < includeMatchers.length; ++i) {
-            const matcher = includeMatchers[i];
-            if (matcher.test(pathId))
-                return true;
+        }
-        return !includeMatchers.length;
-    };
-};
-const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
-const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
-const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
-forbiddenIdentifiers.add('');
 function createInclusionContext() {
 …
         replacedVariableInits: new Map()
     };
+}
+const INCLUDE_PARAMETERS = 'variables';
+const IS_SKIPPED_CHAIN = Symbol('IS_SKIPPED_CHAIN');
+class NodeBase extends ExpressionEntity {
+    /**
+     * Nodes can apply custom deoptimizations once they become part of the
+     * executed code. To do this, they must initialize this as false, implement
+     * applyDeoptimizations and call this from include and hasEffects if they have
+     * custom handlers
+     */
+    get deoptimized() {
+        return isFlagSet(this.flags, 2 /* Flag.deoptimized */);
+    }
+    set deoptimized(value) {
+        this.flags = setFlag(this.flags, 2 /* Flag.deoptimized */, value);
+    }
+    constructor(parent, parentScope) {
+        super();
+        this.parent = parent;
+        this.scope = parentScope;
+        this.createScope(parentScope);
+    }
+    addExportedVariables(_variables, _exportNamesByVariable) { }
+    /**
+     * Override this to bind assignments to variables and do any initialisations
+     * that require the scopes to be populated with variables.
+     */
+    bind() {
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.bind();
+                }
+            }
+            else if (value) {
+                value.bind();
+            }
+        }
+    }
+    /**
+     * Override if this node should receive a different scope than the parent
+     * scope.
+     */
+    createScope(parentScope) {
+        this.scope = parentScope;
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (child?.hasEffects(context))
+                        return true;
+                }
+            }
+            else if (value.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    hasEffectsAsAssignmentTarget(context, _checkAccess) {
+        return (this.hasEffects(context) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
+    include(context, includeChildrenRecursively, _options) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.include(context, includeChildrenRecursively);
+                }
+            }
+            else {
+                value.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, _deoptimizeAccess) {
+        this.include(context, includeChildrenRecursively);
+    }
+    /**
+     * Override to perform special initialisation steps after the scope is
+     * initialised
+     */
+    initialise() {
+        this.scope.context.magicString.addSourcemapLocation(this.start);
+        this.scope.context.magicString.addSourcemapLocation(this.end);
+    }
+    parseNode(esTreeNode) {
+        for (const [key, value] of Object.entries(esTreeNode)) {
+            // Skip properties defined on the class already.
+            // This way, we can override this function to add custom initialisation and then call super.parseNode
+            // Note: this doesn't skip properties with defined getters/setters which we use to pack wrap booleans
+            // in bitfields. Those are still assigned from the value in the esTreeNode.
+            if (this.hasOwnProperty(key))
+                continue;
+            if (key.charCodeAt(0) === 95 /* _ */) {
+                if (key === parseAst_js.ANNOTATION_KEY) {
+                    this.annotations = value;
+                }
+                else if (key === parseAst_js.INVALID_ANNOTATION_KEY) {
+                    this.invalidAnnotations = value;
+                }
+            }
+            else if (typeof value !== 'object' || value === null) {
+                this[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                this[key] = new Array(value.length);
+                let index = 0;
+                for (const child of value) {
+                    this[key][index++] =
+                        child === null
+                            ? null
+                            : new (this.scope.context.getNodeConstructor(child.type))(this, this.scope).parseNode(child);
+                }
+            }
+            else {
+                this[key] = new (this.scope.context.getNodeConstructor(value.type))(this, this.scope).parseNode(value);
+            }
+        }
+        // extend child keys for unknown node types
+        childNodeKeys[esTreeNode.type] ||= createChildNodeKeysForNode(esTreeNode);
+        this.initialise();
+        return this;
+    }
+    removeAnnotations(code) {
+        if (this.annotations) {
+            for (const annotation of this.annotations) {
+                code.remove(annotation.start, annotation.end);
+            }
+        }
+    }
+    render(code, options) {
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.render(code, options);
+                }
+            }
+            else {
+                value.render(code, options);
+            }
+        }
+    }
+    setAssignedValue(value) {
+        this.assignmentInteraction = { args: [null, value], type: INTERACTION_ASSIGNED };
+    }
+    shouldBeIncluded(context) {
+        return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
+    }
+    /**
+     * Just deoptimize everything by default so that when e.g. we do not track
+     * something properly, it is deoptimized.
+     * @protected
+     */
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+            else {
+                value.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+function createChildNodeKeysForNode(esTreeNode) {
+    return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
+}
+function isObjectExpressionNode(node) {
+    return node instanceof NodeBase && node.type === parseAst_js.ObjectExpression;
+}
+function isPropertyNode(node) {
+    return node.type === parseAst_js.Property;
+}
 …
+}
-// This file is generated by scripts/generate-child-node-keys.js.
-// Do not edit this file directly.
-const childNodeKeys = {
-    ArrayExpression: ['elements'],
-    ArrayPattern: ['elements'],
-    ArrowFunctionExpression: ['params', 'body'],
-    AssignmentExpression: ['left', 'right'],
-    AssignmentPattern: ['left', 'right'],
-    AwaitExpression: ['argument'],
-    BinaryExpression: ['left', 'right'],
-    BlockStatement: ['body'],
-    BreakStatement: ['label'],
-    CallExpression: ['callee', 'arguments'],
-    CatchClause: ['param', 'body'],
-    ChainExpression: ['expression'],
-    ClassBody: ['body'],
-    ClassDeclaration: ['decorators', 'id', 'superClass', 'body'],
-    ClassExpression: ['decorators', 'id', 'superClass', 'body'],
-    ConditionalExpression: ['test', 'consequent', 'alternate'],
-    ContinueStatement: ['label'],
-    DebuggerStatement: [],
-    Decorator: ['expression'],
-    DoWhileStatement: ['body', 'test'],
-    EmptyStatement: [],
-    ExportAllDeclaration: ['exported', 'source', 'attributes'],
-    ExportDefaultDeclaration: ['declaration'],
-    ExportNamedDeclaration: ['specifiers', 'source', 'attributes', 'declaration'],
-    ExportSpecifier: ['local', 'exported'],
-    ExpressionStatement: ['expression'],
-    ForInStatement: ['left', 'right', 'body'],
-    ForOfStatement: ['left', 'right', 'body'],
-    ForStatement: ['init', 'test', 'update', 'body'],
-    FunctionDeclaration: ['id', 'params', 'body'],
-    FunctionExpression: ['id', 'params', 'body'],
-    Identifier: [],
-    IfStatement: ['test', 'consequent', 'alternate'],
-    ImportAttribute: ['key', 'value'],
-    ImportDeclaration: ['specifiers', 'source', 'attributes'],
-    ImportDefaultSpecifier: ['local'],
-    ImportExpression: ['source', 'options'],
-    ImportNamespaceSpecifier: ['local'],
-    ImportSpecifier: ['imported', 'local'],
-    LabeledStatement: ['label', 'body'],
-    Literal: [],
-    LogicalExpression: ['left', 'right'],
-    MemberExpression: ['object', 'property'],
-    MetaProperty: ['meta', 'property'],
-    MethodDefinition: ['decorators', 'key', 'value'],
-    NewExpression: ['callee', 'arguments'],
-    ObjectExpression: ['properties'],
-    ObjectPattern: ['properties'],
-    PanicError: [],
-    ParseError: [],
-    PrivateIdentifier: [],
-    Program: ['body'],
-    Property: ['key', 'value'],
-    PropertyDefinition: ['decorators', 'key', 'value'],
-    RestElement: ['argument'],
-    ReturnStatement: ['argument'],
-    SequenceExpression: ['expressions'],
-    SpreadElement: ['argument'],
-    StaticBlock: ['body'],
-    Super: [],
-    SwitchCase: ['test', 'consequent'],
-    SwitchStatement: ['discriminant', 'cases'],
-    TaggedTemplateExpression: ['tag', 'quasi'],
-    TemplateElement: [],
-    TemplateLiteral: ['quasis', 'expressions'],
-    ThisExpression: [],
-    ThrowStatement: ['argument'],
-    TryStatement: ['block', 'handler', 'finalizer'],
-    UnaryExpression: ['argument'],
-    UpdateExpression: ['argument'],
-    VariableDeclaration: ['declarations'],
-    VariableDeclarator: ['id', 'init'],
-    WhileStatement: ['test', 'body'],
-    YieldExpression: ['argument']
-};
-const INCLUDE_PARAMETERS = 'variables';
-const IS_SKIPPED_CHAIN = Symbol('IS_SKIPPED_CHAIN');
-class NodeBase extends ExpressionEntity {
-    /**
-     * Nodes can apply custom deoptimizations once they become part of the
-     * executed code. To do this, they must initialize this as false, implement
-     * applyDeoptimizations and call this from include and hasEffects if they have
-     * custom handlers
-     */
-    get deoptimized() {
-        return isFlagSet(this.flags, 2 /* Flag.deoptimized */);
+    }
-    set deoptimized(value) {
-        this.flags = setFlag(this.flags, 2 /* Flag.deoptimized */, value);
+    }
-    constructor(parent, parentScope) {
-        super();
-        this.parent = parent;
-        this.scope = parentScope;
-        this.createScope(parentScope);
+    }
-    addExportedVariables(_variables, _exportNamesByVariable) { }
-    /**
-     * Override this to bind assignments to variables and do any initialisations
-     * that require the scopes to be populated with variables.
-     */
-    bind() {
-        for (const key of childNodeKeys[this.type]) {
-            const value = this[key];
-            if (Array.isArray(value)) {
-                for (const child of value) {
-                    child?.bind();
+                }
+            }
-            else if (value) {
-                value.bind();
+            }
+        }
+    }
-    /**
-     * Override if this node should receive a different scope than the parent
-     * scope.
-     */
-    createScope(parentScope) {
-        this.scope = parentScope;
+    }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        for (const key of childNodeKeys[this.type]) {
-            const value = this[key];
-            if (value === null)
-                continue;
-            if (Array.isArray(value)) {
-                for (const child of value) {
-                    if (child?.hasEffects(context))
-                        return true;
+                }
+            }
-            else if (value.hasEffects(context))
-                return true;
+        }
-        return false;
+    }
-    hasEffectsAsAssignmentTarget(context, _checkAccess) {
-        return (this.hasEffects(context) ||
-            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
-    include(context, includeChildrenRecursively, _options) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.included = true;
-        for (const key of childNodeKeys[this.type]) {
-            const value = this[key];
-            if (value === null)
-                continue;
-            if (Array.isArray(value)) {
-                for (const child of value) {
-                    child?.include(context, includeChildrenRecursively);
+                }
+            }
-            else {
-                value.include(context, includeChildrenRecursively);
+            }
+        }
+    }
-    includeAsAssignmentTarget(context, includeChildrenRecursively, _deoptimizeAccess) {
-        this.include(context, includeChildrenRecursively);
+    }
-    /**
-     * Override to perform special initialisation steps after the scope is
-     * initialised
-     */
-    initialise() {
-        this.scope.context.magicString.addSourcemapLocation(this.start);
-        this.scope.context.magicString.addSourcemapLocation(this.end);
+    }
-    parseNode(esTreeNode) {
-        for (const [key, value] of Object.entries(esTreeNode)) {
-            // Skip properties defined on the class already.
-            // This way, we can override this function to add custom initialisation and then call super.parseNode
-            // Note: this doesn't skip properties with defined getters/setters which we use to pack wrap booleans
-            // in bitfields. Those are still assigned from the value in the esTreeNode.
-            if (this.hasOwnProperty(key))
-                continue;
-            if (key.charCodeAt(0) === 95 /* _ */) {
-                if (key === parseAst_js.ANNOTATION_KEY) {
-                    this.annotations = value;
+                }
-                else if (key === parseAst_js.INVALID_ANNOTATION_KEY) {
-                    this.invalidAnnotations = value;
+                }
+            }
-            else if (typeof value !== 'object' || value === null) {
-                this[key] = value;
+            }
-            else if (Array.isArray(value)) {
-                this[key] = [];
-                for (const child of value) {
-                    this[key].push(child === null
-                        ? null
-                        : new (this.scope.context.getNodeConstructor(child.type))(this, this.scope).parseNode(child));
+                }
+            }
-            else {
-                this[key] = new (this.scope.context.getNodeConstructor(value.type))(this, this.scope).parseNode(value);
+            }
+        }
-        // extend child keys for unknown node types
-        childNodeKeys[esTreeNode.type] ||= createChildNodeKeysForNode(esTreeNode);
-        this.initialise();
-        return this;
+    }
-    removeAnnotations(code) {
-        if (this.annotations) {
-            for (const annotation of this.annotations) {
-                code.remove(annotation.start, annotation.end);
+            }
+        }
+    }
-    render(code, options) {
-        for (const key of childNodeKeys[this.type]) {
-            const value = this[key];
-            if (value === null)
-                continue;
-            if (Array.isArray(value)) {
-                for (const child of value) {
-                    child?.render(code, options);
+                }
+            }
-            else {
-                value.render(code, options);
+            }
+        }
+    }
-    setAssignedValue(value) {
-        this.assignmentInteraction = { args: [null, value], type: INTERACTION_ASSIGNED };
+    }
-    shouldBeIncluded(context) {
-        return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
+    }
-    /**
-     * Just deoptimize everything by default so that when e.g. we do not track
-     * something properly, it is deoptimized.
-     * @protected
-     */
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        for (const key of childNodeKeys[this.type]) {
-            const value = this[key];
-            if (value === null)
-                continue;
-            if (Array.isArray(value)) {
-                for (const child of value) {
-                    child?.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
-            else {
-                value.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
-        this.scope.context.requestTreeshakingPass();
+    }
+}
-function createChildNodeKeysForNode(esTreeNode) {
-    return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
+}
 class SpreadElement extends NodeBase {
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         if (path.length > 0) {
             this.argument.deoptimizeArgumentsOnInteractionAtPath(interaction, [UnknownKey, ...path], recursionTracker);
+            this.argument.deoptimizeArgumentsOnInteractionAtPath(interaction, UNKNOWN_PATH, recursionTracker);
+        }
+    }
 …
             property.deoptimizePath(subPath);
+        }
         this.prototypeExpression?.deoptimizePath(path.length === 1 ? [...path, UnknownKey] : path);
+        this.prototypeExpression?.deoptimizePath(path.length === 1 ? [path[0], UnknownKey] : path);
+    }
     getLiteralValueAtPath(path, recursionTracker, origin) {
 …
+}
-class ArrayPattern extends NodeBase {
-    addExportedVariables(variables, exportNamesByVariable) {
-        for (const element of this.elements) {
-            element?.addExportedVariables(variables, exportNamesByVariable);
+        }
+    }
-    declare(kind) {
-        const variables = [];
-        for (const element of this.elements) {
-            if (element !== null) {
-                variables.push(...element.declare(kind, UNKNOWN_EXPRESSION));
+            }
+        }
-        return variables;
+    }
-    // Patterns can only be deoptimized at the empty path at the moment
-    deoptimizePath() {
-        for (const element of this.elements) {
-            element?.deoptimizePath(EMPTY_PATH);
+        }
+    }
-    // Patterns are only checked at the empty path at the moment
-    hasEffectsOnInteractionAtPath(_path, interaction, context) {
-        for (const element of this.elements) {
-            if (element?.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
-                return true;
+        }
-        return false;
+    }
-    markDeclarationReached() {
-        for (const element of this.elements) {
-            element?.markDeclarationReached();
+        }
+    }
+}
-/** @typedef { import('estree').Node} Node */
-/** @typedef {Node | {
- *   type: 'PropertyDefinition';
- *   computed: boolean;
- *   value: Node
- * }} NodeWithPropertyDefinition */
-/**
+ *
- * @param {NodeWithPropertyDefinition} node
- * @param {NodeWithPropertyDefinition} parent
- * @returns {boolean}
- */
-function is_reference (node, parent) {
-        if (node.type === 'MemberExpression') {
-                return !node.computed && is_reference(node.object, node);
+        }
-        if (node.type === 'Identifier') {
-                if (!parent) return true;
-                switch (parent.type) {
-                        // disregard `bar` in `foo.bar`
-                        case 'MemberExpression': return parent.computed || node === parent.object;
-                        // disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
-                        case 'MethodDefinition': return parent.computed;
-                        // disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
-                        case 'PropertyDefinition': return parent.computed || node === parent.value;
-                        // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
-                        case 'Property': return parent.computed || node === parent.value;
-                        // disregard the `bar` in `export { foo as bar }` or
-                        // the foo in `import { foo as bar }`
-                        case 'ExportSpecifier':
-                        case 'ImportSpecifier': return node === parent.local;
-                        // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
-                        case 'LabeledStatement':
-                        case 'BreakStatement':
-                        case 'ContinueStatement': return false;
-                        default: return true;
+                }
+        }
-        return false;
+}
-const PureFunctionKey = Symbol('PureFunction');
-const getPureFunctions = ({ treeshake }) => {
-    const pureFunctions = Object.create(null);
-    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
-        let currentFunctions = pureFunctions;
-        for (const pathSegment of functionName.split('.')) {
-            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
+        }
-        currentFunctions[PureFunctionKey] = true;
+    }
-    return pureFunctions;
-};
 /* eslint sort-keys: "off" */
 const ValueProperties = Symbol('Value Properties');
 …
         prototype: O
     },
+    AggregateError: PC_WITH_ARRAY,
     Atomics: O,
     BigInt: C,
 …
     eval: O,
     EvalError: PC,
+    FinalizationRegistry: C,
     Float32Array: ARRAY_TYPE,
     Float64Array: ARRAY_TYPE,
 …
     },
     propertyIsEnumerable: O,
+    Proxy: O,
+    Proxy: {
+        __proto__: null,
+        [ValueProperties]: {
+            deoptimizeArgumentsOnCall: ({ args: [, target, parameter] }) => {
+                if (isObjectExpressionNode(parameter)) {
+                    const hasSpreadElement = parameter.properties.some(property => !isPropertyNode(property));
+                    if (!hasSpreadElement) {
+                        for (const property of parameter.properties) {
+                            property.deoptimizeArgumentsOnInteractionAtPath({
+                                args: [null, target],
+                                type: INTERACTION_CALLED,
+                                withNew: false
+                            }, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+                        }
+                        return;
+                    }
+                }
+                target.deoptimizePath(UNKNOWN_PATH);
+            },
+            getLiteralValue: getTruthyLiteralValue,
+            hasEffectsWhenCalled: returnTrue
+        }
+    },
     RangeError: PC,
     ReferenceError: PC,
 …
     valueOf: O,
     WeakMap: PC_WITH_ARRAY,
+    WeakRef: C,
     WeakSet: PC_WITH_ARRAY,
     // Additional globals shared by Node and Browser that are not strictly part of the language
 …
 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() {
 …
         this.flags = setFlag(this.flags, 4 /* Flag.tdzAccessDefined */, true);
         this.flags = setFlag(this.flags, 8 /* Flag.tdzAccess */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 && !this.scope.contains(this.name)) {
+            this.disallowImportReassignment();
+        }
+        // We keep conditional chaining because an unknown Node could have an
+        // Identifier as property that might be deoptimized by default
+        this.variable?.deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const [expression, isPure] = this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        return [expression, isPure || this.isPureFunction(path)];
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
+            return true;
+        }
+        return (this.scope.context.options.treeshake
+            .unknownGlobalSideEffects &&
+            this.variable instanceof GlobalVariable &&
+            !this.isPureFunction(EMPTY_PATH) &&
+            this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                return (this.variable !== null &&
+                    !this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_ASSIGNED: {
+                return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
+            case INTERACTION_CALLED: {
+                return (!this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
+    include() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            if (this.variable !== null) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+    }
+    includeCallArguments(context, parameters) {
+        this.variable.includeCallArguments(context, parameters);
+    }
+    isPossibleTDZ() {
+        // return cached value to avoid issues with the next tree-shaking pass
+        const cachedTdzAccess = this.isTDZAccess;
+        if (cachedTdzAccess !== null)
+            return cachedTdzAccess;
+        if (!(this.variable instanceof LocalVariable &&
+            this.variable.kind &&
+            tdzVariableKinds.has(this.variable.kind) &&
+            // We ignore modules that did not receive a treeshaking pass yet as that
+            // causes many false positives due to circular dependencies or disabled
+            // moduleSideEffects.
+            this.variable.module.hasTreeShakingPassStarted)) {
+            return (this.isTDZAccess = false);
+        }
+        let decl_id;
+        if (this.variable.declarations &&
+            this.variable.declarations.length === 1 &&
+            (decl_id = this.variable.declarations[0]) &&
+            this.start < decl_id.start &&
+            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
+            // a variable accessed before its declaration
+            // in the same function or at top level of module
+            return (this.isTDZAccess = true);
+        }
+        if (!this.variable.initReached) {
+            // Either a const/let TDZ violation or
+            // var use before declaration was encountered.
+            return (this.isTDZAccess = true);
+        }
+        return (this.isTDZAccess = false);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.variable instanceof LocalVariable) {
+            // When accessing a variable from a module without side effects, this
+            // means we use an export of that module and therefore need to potentially
+            // include it in the bundle.
+            if (!this.variable.module.isExecuted) {
+                markModuleAndImpureDependenciesAsExecuted(this.variable.module);
+            }
+            this.variable.consolidateInitializers();
+            this.scope.context.requestTreeshakingPass();
+        }
+        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;
+        }
+        return this.variable;
+    }
+    isPureFunction(path) {
+        let currentPureFunction = this.scope.context.manualPureFunctions[this.name];
+        for (const segment of path) {
+            if (currentPureFunction) {
+                if (currentPureFunction[PureFunctionKey]) {
+                    return true;
+                }
+                currentPureFunction = currentPureFunction[segment];
+            }
+            else {
+                return false;
+            }
+        }
+        return currentPureFunction?.[PureFunctionKey];
+    }
+}
+function closestParentFunctionOrProgram(node) {
+    while (node && !/^Program|Function/.test(node.type)) {
+        node = node.parent;
+    }
+    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
+    return node;
+}
+class Identifier extends IdentifierBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+    }
     addExportedVariables(variables, exportNamesByVariable) {
 …
             this.variable = this.scope.findVariable(this.name);
             this.variable.addReference(this);
             this.isReferenceVariable = true;
+            this.isVariableReference = true;
+        }
+    }
 …
         return [(this.variable = variable)];
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
-    deoptimizePath(path) {
-        if (path.length === 0 && !this.scope.contains(this.name)) {
-            this.disallowImportReassignment();
+        }
-        // We keep conditional chaining because an unknown Node could have an
-        // Identifier as property that might be deoptimized by default
-        this.variable?.deoptimizePath(path);
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        const [expression, isPure] = this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
-        return [expression, isPure || this.isPureFunction(path)];
+    }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
-            return true;
+        }
-        return (this.scope.context.options.treeshake
-            .unknownGlobalSideEffects &&
-            this.variable instanceof GlobalVariable &&
-            !this.isPureFunction(EMPTY_PATH) &&
-            this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        switch (interaction.type) {
-            case INTERACTION_ACCESSED: {
-                return (this.variable !== null &&
-                    !this.isPureFunction(path) &&
-                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
-            case INTERACTION_ASSIGNED: {
-                return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
-            case INTERACTION_CALLED: {
-                return (!this.isPureFunction(path) &&
-                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
-    include() {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+    }
-    includeCallArguments(context, parameters) {
-        this.variable.includeCallArguments(context, parameters);
+    }
-    isPossibleTDZ() {
-        // return cached value to avoid issues with the next tree-shaking pass
-        const cachedTdzAccess = this.isTDZAccess;
-        if (cachedTdzAccess !== null)
-            return cachedTdzAccess;
-        if (!(this.variable instanceof LocalVariable &&
-            this.variable.kind &&
-            tdzVariableKinds.has(this.variable.kind) &&
-            // we ignore possible TDZs due to circular module dependencies as
-            // otherwise we get many false positives
-            this.variable.module === this.scope.context.module)) {
-            return (this.isTDZAccess = false);
+        }
-        let decl_id;
-        if (this.variable.declarations &&
-            this.variable.declarations.length === 1 &&
-            (decl_id = this.variable.declarations[0]) &&
-            this.start < decl_id.start &&
-            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
-            // a variable accessed before its declaration
-            // in the same function or at top level of module
-            return (this.isTDZAccess = true);
+        }
-        // We ignore the case where the module is not yet executed because
-        // moduleSideEffects are false.
-        if (!this.variable.initReached && this.scope.context.module.isExecuted) {
-            // Either a const/let TDZ violation or
-            // var use before declaration was encountered.
-            return (this.isTDZAccess = true);
+        }
-        return (this.isTDZAccess = false);
+    }
     markDeclarationReached() {
         this.variable.initReached = true;
 …
+            }
+        }
+    }
-    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) {
-            this.variable.consolidateInitializers();
-            this.scope.context.requestTreeshakingPass();
+        }
-        if (this.isReferenceVariable) {
-            this.variable.addUsedPlace(this);
-            this.scope.context.requestTreeshakingPass();
+        }
+    }
-    getVariableRespectingTDZ() {
-        if (this.isPossibleTDZ()) {
-            return UNKNOWN_EXPRESSION;
+        }
-        return this.variable;
+    }
-    isPureFunction(path) {
-        let currentPureFunction = this.scope.context.manualPureFunctions[this.name];
-        for (const segment of path) {
-            if (currentPureFunction) {
-                if (currentPureFunction[PureFunctionKey]) {
-                    return true;
+                }
-                currentPureFunction = currentPureFunction[segment];
+            }
-            else {
-                return false;
+            }
+        }
-        return currentPureFunction?.[PureFunctionKey];
+    }
+}
-function closestParentFunctionOrProgram(node) {
-    while (node && !/^Program|Function/.test(node.type)) {
-        node = node.parent;
+    }
-    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
-    return node;
+}
-const MAX_TRACKED_INTERACTIONS = 20;
-const NO_INTERACTIONS = parseAst_js.EMPTY_ARRAY;
-const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
-const EMPTY_PATH_TRACKER = new PathTracker();
-const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
-class ParameterVariable extends LocalVariable {
-    constructor(name, declarator, context) {
-        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
-        this.deoptimizationInteractions = [];
-        this.deoptimizations = new PathTracker();
-        this.deoptimizedFields = new Set();
-        this.entitiesToBeDeoptimized = new Set();
-        this.expressionsUseTheKnownValue = [];
-        this.knownValue = null;
-        this.knownValueLiteral = UnknownValue;
-        this.frozenValue = null;
+    }
-    addEntityToBeDeoptimized(entity) {
-        if (entity === UNKNOWN_EXPRESSION) {
-            // As unknown expressions fully deoptimize all interactions, we can clear
-            // the interaction cache at this point provided we keep this optimization
-            // in mind when adding new interactions
-            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
-                this.entitiesToBeDeoptimized.add(UNKNOWN_EXPRESSION);
-                for (const { interaction } of this.deoptimizationInteractions) {
-                    deoptimizeInteraction(interaction);
+                }
-                this.deoptimizationInteractions = NO_INTERACTIONS;
+            }
+        }
-        else if (this.deoptimizedFields.has(UnknownKey)) {
-            // This means that we already deoptimized all interactions and no longer
-            // track them
-            entity.deoptimizePath(UNKNOWN_PATH);
+        }
-        else if (!this.entitiesToBeDeoptimized.has(entity)) {
-            this.entitiesToBeDeoptimized.add(entity);
-            for (const field of this.deoptimizedFields) {
-                entity.deoptimizePath([field]);
+            }
-            for (const { interaction, path } of this.deoptimizationInteractions) {
-                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+        }
+    }
-    markReassigned() {
-        if (this.isReassigned) {
-            return;
+        }
-        super.markReassigned();
-        for (const expression of this.expressionsUseTheKnownValue) {
-            expression.deoptimizeCache();
+        }
-        this.expressionsUseTheKnownValue = parseAst_js.EMPTY_ARRAY;
+    }
-    deoptimizeCache() {
-        this.markReassigned();
+    }
-    /**
-     * Update the known value of the parameter variable.
-     * Must be called for every function call, so it can track all the arguments,
-     * and deoptimizeCache itself to mark reassigned if the argument is changed.
-     * @param argument The argument of the function call
-     */
-    updateKnownValue(argument) {
-        if (this.isReassigned) {
-            return;
+        }
-        if (this.knownValue === null) {
-            this.knownValue = argument;
-            this.knownValueLiteral = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            return;
+        }
-        // the same literal or identifier, do nothing
-        if (this.knownValue === argument ||
-            (this.knownValue instanceof Identifier &&
-                argument instanceof Identifier &&
-                this.knownValue.variable === argument.variable)) {
-            return;
+        }
-        const oldValue = this.knownValueLiteral;
-        if (typeof oldValue === 'symbol') {
-            this.markReassigned();
-            return;
+        }
-        // add tracking for the new argument
-        const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-        if (newValue !== oldValue) {
-            this.markReassigned();
+        }
+    }
-    /**
-     * This function freezes the known value of the parameter variable,
-     * so the optimization starts with a certain ExpressionEntity.
-     * The optimization can be undone by calling `markReassigned`.
-     * @returns the frozen value
-     */
-    getKnownValue() {
-        if (this.frozenValue === null) {
-            this.frozenValue = this.knownValue || UNKNOWN_EXPRESSION;
+        }
-        return this.frozenValue;
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.isReassigned) {
-            return UnknownValue;
+        }
-        const knownValue = this.getKnownValue();
-        this.expressionsUseTheKnownValue.push(origin);
-        return recursionTracker.withTrackedEntityAtPath(path, knownValue, () => knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (this.isReassigned || interaction.type === INTERACTION_ASSIGNED) {
-            return super.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
-        const knownValue = this.getKnownValue();
-        return knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
-        // For performance reasons, we fully deoptimize all deeper interactions
-        if (path.length >= 2 ||
-            this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
-            this.deoptimizationInteractions.length >= MAX_TRACKED_INTERACTIONS ||
-            (path.length === 1 &&
-                (this.deoptimizedFields.has(UnknownKey) ||
-                    (interaction.type === INTERACTION_CALLED && this.deoptimizedFields.has(path[0]))))) {
-            deoptimizeInteraction(interaction);
-            return;
+        }
-        if (!this.deoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.args)) {
-            for (const entity of this.entitiesToBeDeoptimized) {
-                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
-            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
-                this.deoptimizationInteractions.push({
-                    interaction,
-                    path
-                });
+            }
+        }
+    }
-    deoptimizePath(path) {
-        if (path.length === 0) {
-            this.markReassigned();
-            return;
+        }
-        if (this.deoptimizedFields.has(UnknownKey)) {
-            return;
+        }
-        const key = path[0];
-        if (this.deoptimizedFields.has(key)) {
-            return;
+        }
-        this.deoptimizedFields.add(key);
-        for (const entity of this.entitiesToBeDeoptimized) {
-            // We do not need a recursion tracker here as we already track whether
-            // this field is deoptimized
-            entity.deoptimizePath([key]);
+        }
-        if (key === UnknownKey) {
-            // save some memory
-            this.deoptimizationInteractions = NO_INTERACTIONS;
-            this.deoptimizations = EMPTY_PATH_TRACKER;
-            this.deoptimizedFields = UNKNOWN_DEOPTIMIZED_FIELD;
-            this.entitiesToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
+        }
+    }
-    getReturnExpressionWhenCalledAtPath(path) {
-        // We deoptimize everything that is called as that will trivially deoptimize
-        // the corresponding return expressions as well and avoid badly performing
-        // and complicated alternatives
-        if (path.length === 0) {
-            this.deoptimizePath(UNKNOWN_PATH);
+        }
-        else if (!this.deoptimizedFields.has(path[0])) {
-            this.deoptimizePath([path[0]]);
+        }
-        return UNKNOWN_RETURN_EXPRESSION;
+    }
+}
 …
+    }
     addReturnExpression(expression) {
+        this.parent instanceof ChildScope && this.parent.addReturnExpression(expression);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addReturnExpression(expression);
+        }
+    }
     addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope) {
 …
         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);
 …
         this.accessedOutsideVariables.set(name, variable);
         return variable;
+    }
+}
+function checkEffectForNodes(nodes, context) {
+    for (const node of nodes) {
+        if (node.hasEffects(context)) {
+            return true;
+        }
+    }
+    return false;
+}
+class MethodBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.accessedValue = null;
+    }
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (interaction.type === INTERACTION_ACCESSED && this.kind === 'get' && path.length === 0) {
+            return this.value.deoptimizeArgumentsOnInteractionAtPath({
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
+        }
+        if (interaction.type === INTERACTION_ASSIGNED && this.kind === 'set' && path.length === 0) {
+            return this.value.deoptimizeArgumentsOnInteractionAtPath({
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
+        }
+        this.getAccessedValue()[0].deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    // As getter properties directly receive their values from fixed function
+    // expressions, there is no known situation where a getter is deoptimized.
+    deoptimizeCache() { }
+    deoptimizePath(path) {
+        this.getAccessedValue()[0].deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getAccessedValue()[0].getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getAccessedValue()[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        return this.key.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.kind === 'get' && interaction.type === INTERACTION_ACCESSED && path.length === 0) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
+        }
+        // setters are only called for empty paths
+        if (this.kind === 'set' && interaction.type === INTERACTION_ASSIGNED) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
+        }
+        return this.getAccessedValue()[0].hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    applyDeoptimizations() { }
+    getAccessedValue() {
+        if (this.accessedValue === null) {
+            if (this.kind === 'get') {
+                this.accessedValue = UNKNOWN_RETURN_EXPRESSION;
+                return (this.accessedValue = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, SHARED_RECURSION_TRACKER, this));
+            }
+            else {
+                return (this.accessedValue = [this.value, false]);
+            }
+        }
+        return this.accessedValue;
+    }
+}
+class MethodDefinition extends MethodBase {
+    hasEffects(context) {
+        return super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
+    applyDeoptimizations() { }
+}
+class BlockScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === 'var') {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                if (existingVariable.kind === 'var' ||
+                    (kind === 'var' && existingVariable.kind === 'parameter')) {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+                }
+                return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+            }
+            const declaredVariable = this.parent.addDeclaration(identifier, context, init, kind);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            declaredVariable.markInitializersForDeoptimization();
+            // We add the variable to this and all parent scopes to reliably detect conflicts
+            this.addHoistedVariable(name, declaredVariable);
+            return declaredVariable;
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+class StaticBlock extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        for (const node of this.body) {
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        for (const node of this.body) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                node.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options) {
+        if (this.body.length > 0) {
+            const bodyStartPos = findFirstOccurrenceOutsideComment(code.original.slice(this.start, this.end), '{') + 1;
+            renderStatementList(this.body, code, this.start + bodyStartPos, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+function isStaticBlock(statement) {
+    return statement.type === parseAst_js.StaticBlock;
+}
+class ObjectMember extends ExpressionEntity {
+    constructor(object, key) {
+        super();
+        this.object = object;
+        this.key = key;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.key, ...path], recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.object.deoptimizePath([this.key, ...path]);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.object.getLiteralValueAtPath([this.key, ...path], recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.object.hasEffectsOnInteractionAtPath([this.key, ...path], interaction, context);
+    }
+}
+class ClassNode extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    createScope(parentScope) {
+        this.scope = new ChildScope(parentScope, parentScope.context);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        this.getObjectEntity().deoptimizeAllProperties();
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const initEffect = this.superClass?.hasEffects(context) || this.body.hasEffects(context);
+        this.id?.markDeclarationReached();
+        return initEffect || super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return interaction.type === INTERACTION_CALLED && path.length === 0
+            ? !interaction.withNew ||
+                (this.classConstructor === null
+                    ? this.superClass?.hasEffectsOnInteractionAtPath(path, interaction, context)
+                    : this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
+                false
+            : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.superClass?.include(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively);
+        for (const decorator of this.decorators)
+            decorator.include(context, includeChildrenRecursively);
+        if (this.id) {
+            this.id.markDeclarationReached();
+            this.id.include();
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.id?.declare('class', this);
+        for (const method of this.body.body) {
+            if (method instanceof MethodDefinition && method.kind === 'constructor') {
+                this.classConstructor = method;
+                return;
+            }
+        }
+        this.classConstructor = null;
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const definition of this.body.body) {
+            if (!isStaticBlock(definition) &&
+                !(definition.static ||
+                    (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
+                // Calls to methods are not tracked, ensure that the return value is deoptimized
+                definition.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        const staticProperties = [];
+        const dynamicMethods = [];
+        for (const definition of this.body.body) {
+            if (isStaticBlock(definition))
+                continue;
+            const properties = definition.static ? staticProperties : dynamicMethods;
+            const definitionKind = definition.kind;
+            // Note that class fields do not end up on the prototype
+            if (properties === dynamicMethods && !definitionKind)
+                continue;
+            const kind = definitionKind === 'set' || definitionKind === 'get' ? definitionKind : 'init';
+            let key;
+            if (definition.computed) {
+                const keyValue = definition.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+                if (typeof keyValue === 'symbol') {
+                    properties.push({ key: UnknownKey, kind, property: definition });
+                    continue;
+                }
+                else {
+                    key = String(keyValue);
+                }
+            }
+            else {
+                key =
+                    definition.key instanceof Identifier
+                        ? definition.key.name
+                        : String(definition.key.value);
+            }
+            properties.push({ key, kind, property: definition });
+        }
+        staticProperties.unshift({
+            key: 'prototype',
+            kind: 'init',
+            property: new ObjectEntity(dynamicMethods, this.superClass ? new ObjectMember(this.superClass, 'prototype') : OBJECT_PROTOTYPE)
+        });
+        return (this.objectEntity = new ObjectEntity(staticProperties, this.superClass || OBJECT_PROTOTYPE));
+    }
+}
+class ClassDeclaration extends ClassNode {
+    initialise() {
+        super.initialise();
+        if (this.id !== null) {
+            this.id.variable.isId = true;
+        }
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, format, snippets: { _, getPropertyAccess } } = options;
+        if (this.id) {
+            const { variable, name } = this.id;
+            if (format === 'system' && exportNamesByVariable.has(variable)) {
+                code.appendLeft(this.end, `${_}${getSystemExportStatement([variable], options)};`);
+            }
+            const renderedVariable = variable.getName(getPropertyAccess);
+            if (renderedVariable !== name) {
+                this.decorators.map(decorator => decorator.render(code, options));
+                this.superClass?.render(code, options);
+                this.body.render(code, {
+                    ...options,
+                    useOriginalName: (_variable) => _variable === variable
+                });
+                code.prependRight(this.start, `let ${renderedVariable}${_}=${_}`);
+                code.prependLeft(this.end, ';');
+                return;
+            }
+        }
+        super.render(code, options);
+    }
+    applyDeoptimizations() {
+        super.applyDeoptimizations();
+        const { id, scope } = this;
+        if (id) {
+            const { name, variable } = id;
+            for (const accessedVariable of scope.accessedOutsideVariables.values()) {
+                if (accessedVariable !== variable) {
+                    accessedVariable.forbidName(name);
+                }
+            }
+        }
+    }
+}
+class ArgumentsVariable extends LocalVariable {
+    constructor(context) {
+        super('arguments', null, UNKNOWN_EXPRESSION, context, 'other');
+        this.deoptimizedArguments = [];
+    }
+    addArgumentToBeDeoptimized(argument) {
+        if (this.included) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        else {
+            this.deoptimizedArguments.push(argument);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
+    include() {
+        super.include();
+        for (const argument of this.deoptimizedArguments) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        this.deoptimizedArguments.length = 0;
+    }
+}
+const MAX_TRACKED_INTERACTIONS = 20;
+const NO_INTERACTIONS = parseAst_js.EMPTY_ARRAY;
+const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
+const EMPTY_PATH_TRACKER = new PathTracker();
+const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
+class ParameterVariable extends LocalVariable {
+    constructor(name, declarator, context) {
+        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
+        this.deoptimizationInteractions = [];
+        this.deoptimizations = new PathTracker();
+        this.deoptimizedFields = new Set();
+        this.entitiesToBeDeoptimized = new Set();
+        this.expressionsUseTheKnownValue = [];
+        this.knownValue = null;
+        this.knownValueLiteral = UnknownValue;
+        this.frozenValue = null;
+    }
+    addEntityToBeDeoptimized(entity) {
+        if (entity === UNKNOWN_EXPRESSION) {
+            // As unknown expressions fully deoptimize all interactions, we can clear
+            // the interaction cache at this point provided we keep this optimization
+            // in mind when adding new interactions
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.entitiesToBeDeoptimized.add(UNKNOWN_EXPRESSION);
+                for (const { interaction } of this.deoptimizationInteractions) {
+                    deoptimizeInteraction(interaction);
+                }
+                this.deoptimizationInteractions = NO_INTERACTIONS;
+            }
+        }
+        else if (this.deoptimizedFields.has(UnknownKey)) {
+            // This means that we already deoptimized all interactions and no longer
+            // track them
+            entity.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.entitiesToBeDeoptimized.has(entity)) {
+            this.entitiesToBeDeoptimized.add(entity);
+            for (const field of this.deoptimizedFields) {
+                entity.deoptimizePath([field]);
+            }
+            for (const { interaction, path } of this.deoptimizationInteractions) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+        }
+    }
+    markReassigned() {
+        if (this.isReassigned) {
+            return;
+        }
+        super.markReassigned();
+        for (const expression of this.expressionsUseTheKnownValue) {
+            expression.deoptimizeCache();
+        }
+        this.expressionsUseTheKnownValue = parseAst_js.EMPTY_ARRAY;
+    }
+    deoptimizeCache() {
+        this.markReassigned();
+    }
+    /**
+     * Update the known value of the parameter variable.
+     * Must be called for every function call, so it can track all the arguments,
+     * and deoptimizeCache itself to mark reassigned if the argument is changed.
+     * @param argument The argument of the function call
+     */
+    updateKnownValue(argument) {
+        if (this.isReassigned) {
+            return;
+        }
+        if (this.knownValue === null) {
+            this.knownValue = argument;
+            this.knownValueLiteral = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return;
+        }
+        // the same literal or identifier, do nothing
+        if (this.knownValue === argument ||
+            (this.knownValue instanceof Identifier &&
+                argument instanceof Identifier &&
+                this.knownValue.variable === argument.variable)) {
+            return;
+        }
+        const oldValue = this.knownValueLiteral;
+        if (typeof oldValue === 'symbol') {
+            this.markReassigned();
+            return;
+        }
+        // add tracking for the new argument
+        const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        if (newValue !== oldValue) {
+            this.markReassigned();
+        }
+    }
+    /**
+     * This function freezes the known value of the parameter variable,
+     * so the optimization starts with a certain ExpressionEntity.
+     * The optimization can be undone by calling `markReassigned`.
+     * @returns the frozen value
+     */
+    getKnownValue() {
+        if (this.frozenValue === null) {
+            this.frozenValue = this.knownValue || UNKNOWN_EXPRESSION;
+        }
+        return this.frozenValue;
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        const knownValue = this.getKnownValue();
+        this.expressionsUseTheKnownValue.push(origin);
+        return recursionTracker.withTrackedEntityAtPath(path, knownValue, () => knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.isReassigned || interaction.type === INTERACTION_ASSIGNED) {
+            return super.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        const knownValue = this.getKnownValue();
+        return knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
+        // For performance reasons, we fully deoptimize all deeper interactions
+        if (path.length >= 2 ||
+            this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
+            this.deoptimizationInteractions.length >= MAX_TRACKED_INTERACTIONS ||
+            (path.length === 1 &&
+                (this.deoptimizedFields.has(UnknownKey) ||
+                    (interaction.type === INTERACTION_CALLED && this.deoptimizedFields.has(path[0]))))) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        if (!this.deoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.args)) {
+            for (const entity of this.entitiesToBeDeoptimized) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.deoptimizationInteractions.push({
+                    interaction,
+                    path
+                });
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.markReassigned();
+            return;
+        }
+        if (this.deoptimizedFields.has(UnknownKey)) {
+            return;
+        }
+        const key = path[0];
+        if (this.deoptimizedFields.has(key)) {
+            return;
+        }
+        this.deoptimizedFields.add(key);
+        for (const entity of this.entitiesToBeDeoptimized) {
+            // We do not need a recursion tracker here as we already track whether
+            // this field is deoptimized
+            entity.deoptimizePath([key]);
+        }
+        if (key === UnknownKey) {
+            // save some memory
+            this.deoptimizationInteractions = NO_INTERACTIONS;
+            this.deoptimizations = EMPTY_PATH_TRACKER;
+            this.deoptimizedFields = UNKNOWN_DEOPTIMIZED_FIELD;
+            this.entitiesToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        // We deoptimize everything that is called as that will trivially deoptimize
+        // the corresponding return expressions as well and avoid badly performing
+        // and complicated alternatives
+        if (path.length === 0) {
+            this.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.deoptimizedFields.has(path[0])) {
+            this.deoptimizePath([path[0]]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+}
+class ThisVariable extends ParameterVariable {
+    constructor(context) {
+        super('this', null, context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (context.replacedVariableInits.get(this) || UNKNOWN_EXPRESSION).hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+}
 …
+}
+function treeshakeNode(node, code, start, end) {
+    code.remove(start, end);
+    node.removeAnnotations(code);
+}
+const NO_SEMICOLON = { isNoStatement: true };
+// This assumes there are only white-space and comments between start and the string we are looking for
+function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
+    let searchPos, charCodeAfterSlash;
+    searchPos = code.indexOf(searchString, start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start >= searchPos)
+            return searchPos;
+        charCodeAfterSlash = code.charCodeAt(++start);
+        ++start;
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        start =
+            charCodeAfterSlash === 47 /*"/"*/
+                ? code.indexOf('\n', start) + 1
+                : code.indexOf('*/', start) + 2;
+        if (start > searchPos) {
+            searchPos = code.indexOf(searchString, start);
+        }
+    }
+}
+const NON_WHITESPACE = /\S/g;
+function findNonWhiteSpace(code, index) {
+    NON_WHITESPACE.lastIndex = index;
+    const result = NON_WHITESPACE.exec(code);
+    return result.index;
+}
+const WHITESPACE = /\s/;
+function findLastWhiteSpaceReverse(code, start, end) {
+    while (true) {
+        if (start >= end) {
+            return end;
+        }
+        if (WHITESPACE.test(code[end - 1])) {
+            end--;
+        }
+        else {
+            return end;
+        }
+    }
+}
+// This assumes "code" only contains white-space and comments
+// Returns position of line-comment if applicable
+function findFirstLineBreakOutsideComment(code) {
+    let lineBreakPos, charCodeAfterSlash, start = 0;
+    lineBreakPos = code.indexOf('\n', start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start > lineBreakPos)
+            return [lineBreakPos, lineBreakPos + 1];
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        charCodeAfterSlash = code.charCodeAt(start + 1);
+        if (charCodeAfterSlash === 47 /*"/"*/)
+            return [start, lineBreakPos + 1];
+        start = code.indexOf('*/', start + 2) + 2;
+        if (start > lineBreakPos) {
+            lineBreakPos = code.indexOf('\n', start);
+        }
+    }
+}
+function renderStatementList(statements, code, start, end, options) {
+    let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
+    let nextNode = statements[0];
+    let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
+    if (nextNodeNeedsBoundaries) {
+        nextNodeStart =
+            start + findFirstLineBreakOutsideComment(code.original.slice(start, nextNode.start))[1];
+    }
+    for (let nextIndex = 1; nextIndex <= statements.length; nextIndex++) {
+        currentNode = nextNode;
+        currentNodeStart = nextNodeStart;
+        currentNodeNeedsBoundaries = nextNodeNeedsBoundaries;
+        nextNode = statements[nextIndex];
+        nextNodeNeedsBoundaries =
+            nextNode === undefined ? false : !nextNode.included || nextNode.needsBoundaries;
+        if (currentNodeNeedsBoundaries || nextNodeNeedsBoundaries) {
+            nextNodeStart =
+                currentNode.end +
+                    findFirstLineBreakOutsideComment(code.original.slice(currentNode.end, nextNode === undefined ? end : nextNode.start))[1];
+            if (currentNode.included) {
+                currentNodeNeedsBoundaries
+                    ? currentNode.render(code, options, {
+                        end: nextNodeStart,
+                        start: currentNodeStart
+                    })
+                    : currentNode.render(code, options);
+            }
+            else {
+                treeshakeNode(currentNode, code, currentNodeStart, nextNodeStart);
+            }
+        }
+        else {
+            currentNode.render(code, options);
+        }
+    }
+}
+// This assumes that the first character is not part of the first node
+function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
+    const splitUpNodes = [];
+    let node, nextNodeStart, contentEnd, char;
+    let separator = start - 1;
+    for (const nextNode of nodes) {
+        if (node !== undefined) {
+            separator =
+                node.end +
+                    findFirstOccurrenceOutsideComment(code.original.slice(node.end, nextNode.start), ',');
+        }
+        nextNodeStart = contentEnd =
+            separator +
++
+                findFirstLineBreakOutsideComment(code.original.slice(separator + 1, nextNode.start))[1];
+        while (((char = code.original.charCodeAt(nextNodeStart)),
+            char === 32 /*" "*/ || char === 9 /*"\t"*/ || char === 10 /*"\n"*/ || char === 13) /*"\r"*/)
+            nextNodeStart++;
+        if (node !== undefined) {
+            splitUpNodes.push({
+                contentEnd,
+                end: nextNodeStart,
+                node,
+                separator,
+                start
+            });
+        }
+        node = nextNode;
+        start = nextNodeStart;
+    }
+    splitUpNodes.push({
+        contentEnd: end,
+        end,
+        node: node,
+        separator: null,
+        start
+    });
+    return splitUpNodes;
+}
+// This assumes there are only white-space and comments between start and end
+function removeLineBreaks(code, start, end) {
+    while (true) {
+        const [removeStart, removeEnd] = findFirstLineBreakOutsideComment(code.original.slice(start, end));
+        if (removeStart === -1) {
+            break;
+        }
+        code.remove(start + removeStart, (start += removeEnd));
+    }
+}
+class BlockScope extends ChildScope {
+class FunctionScope extends ReturnValueScope {
     constructor(parent) {
+        super(parent, parent.context);
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === 'var') {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                if (existingVariable.kind === 'var' ||
+                    (kind === 'var' && existingVariable.kind === 'parameter')) {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+        const { context } = parent;
+        super(parent, false);
+        this.variables.set('arguments', (this.argumentsVariable = new ArgumentsVariable(context)));
+        this.variables.set('this', (this.thisVariable = new ThisVariable(context)));
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+    includeCallArguments(context, parameters) {
+        super.includeCallArguments(context, parameters);
+        if (this.argumentsVariable.included) {
+            for (const argument of parameters) {
+                if (!argument.included) {
+                    argument.include(context, false);
+                }
+                return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+            }
+            const declaredVariable = this.parent.addDeclaration(identifier, context, init, kind);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            declaredVariable.markInitializersForDeoptimization();
+            // We add the variable to this and all parent scopes to reliably detect conflicts
+            this.addHoistedVariable(name, declaredVariable);
+            return declaredVariable;
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+            }
+        }
+    }
+}
 …
+    }
     deoptimizePath(path) {
+        path.length === 0 && this.argument.deoptimizePath(EMPTY_PATH);
+        if (path.length === 0) {
+            this.argument.deoptimizePath(EMPTY_PATH);
+        }
+    }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
 …
 FunctionBase.prototype.preventChildBlockScope = true;
-class ArrowFunctionExpression extends FunctionBase {
-    constructor() {
-        super(...arguments);
-        this.objectEntity = null;
+    }
-    get expression() {
-        return isFlagSet(this.flags, 8388608 /* Flag.expression */);
+    }
-    set expression(value) {
-        this.flags = setFlag(this.flags, 8388608 /* Flag.expression */, value);
+    }
-    createScope(parentScope) {
-        this.scope = new ReturnValueScope(parentScope, false);
+    }
-    hasEffects() {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        return false;
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (super.hasEffectsOnInteractionAtPath(path, interaction, context)) {
-            return true;
+        }
-        if (this.annotationNoSideEffects) {
-            return false;
+        }
-        if (interaction.type === INTERACTION_CALLED) {
-            const { ignore, brokenFlow } = context;
-            context.ignore = {
-                breaks: false,
-                continues: false,
-                labels: new Set(),
-                returnYield: true,
-                this: false
-            };
-            if (this.body.hasEffects(context))
-                return true;
-            context.ignore = ignore;
-            context.brokenFlow = brokenFlow;
+        }
-        return false;
+    }
-    onlyFunctionCallUsed() {
-        const isIIFE = this.parent.type === parseAst_js.CallExpression &&
-            this.parent.callee === this;
-        return isIIFE || super.onlyFunctionCallUsed();
+    }
-    include(context, includeChildrenRecursively) {
-        super.include(context, includeChildrenRecursively);
-        for (const parameter of this.params) {
-            if (!(parameter instanceof Identifier)) {
-                parameter.include(context, includeChildrenRecursively);
+            }
+        }
+    }
-    getObjectEntity() {
-        if (this.objectEntity !== null) {
-            return this.objectEntity;
+        }
-        return (this.objectEntity = new ObjectEntity([], OBJECT_PROTOTYPE));
+    }
+}
-function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
-    if (exportedVariables.length === 1 &&
-        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
-        const variable = exportedVariables[0];
-        return `exports(${JSON.stringify(exportNamesByVariable.get(variable)[0])},${_}${variable.getName(getPropertyAccess)}${modifier})`;
+    }
-    else {
-        const fields = [];
-        for (const variable of exportedVariables) {
-            for (const exportName of exportNamesByVariable.get(variable)) {
-                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
+            }
+        }
-        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
+    }
+}
-// This is only invoked if there is exactly one export name
-function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
-    code.prependRight(expressionStart, `exports(${JSON.stringify(exportNamesByVariable.get(exportedVariable)[0])},${_}`);
-    code.appendLeft(expressionEnd, ')');
+}
-function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
-    const { _, getDirectReturnIifeLeft } = options.snippets;
-    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
-    code.appendLeft(expressionEnd, ')');
+}
-function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
-    const { _, getPropertyAccess } = options.snippets;
-    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
-    if (needsParens) {
-        code.prependRight(expressionStart, '(');
-        code.appendLeft(expressionEnd, ')');
+    }
+}
-function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
-    const { _ } = options.snippets;
-    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
-    if (needsParens) {
-        code.prependRight(expressionStart, '(');
-        code.appendLeft(expressionEnd, ')');
+    }
+}
-class ObjectPattern extends NodeBase {
-    addExportedVariables(variables, exportNamesByVariable) {
-        for (const property of this.properties) {
-            if (property.type === parseAst_js.Property) {
-                property.value.addExportedVariables(variables, exportNamesByVariable);
+            }
-            else {
-                property.argument.addExportedVariables(variables, exportNamesByVariable);
+            }
+        }
+    }
-    declare(kind, init) {
-        const variables = [];
-        for (const property of this.properties) {
-            variables.push(...property.declare(kind, init));
+        }
-        return variables;
+    }
-    deoptimizePath(path) {
-        if (path.length === 0) {
-            for (const property of this.properties) {
-                property.deoptimizePath(path);
+            }
+        }
+    }
-    hasEffectsOnInteractionAtPath(
-    // At the moment, this is only triggered for assignment left-hand sides,
-    // where the path is empty
-    _path, interaction, context) {
-        for (const property of this.properties) {
-            if (property.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
-                return true;
+        }
-        return false;
+    }
-    markDeclarationReached() {
-        for (const property of this.properties) {
-            property.markDeclarationReached();
+        }
+    }
+}
-class AssignmentExpression extends NodeBase {
-    hasEffects(context) {
-        const { deoptimized, left, operator, right } = this;
-        if (!deoptimized)
-            this.applyDeoptimizations();
-        // MemberExpressions do not access the property before assignments if the
-        // operator is '='.
-        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, operator !== '='));
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
-    include(context, includeChildrenRecursively) {
-        const { deoptimized, left, right, operator } = this;
-        if (!deoptimized)
-            this.applyDeoptimizations();
-        this.included = true;
-        if (includeChildrenRecursively ||
-            operator !== '=' ||
-            left.included ||
-            left.hasEffectsAsAssignmentTarget(createHasEffectsContext(), false)) {
-            left.includeAsAssignmentTarget(context, includeChildrenRecursively, operator !== '=');
+        }
-        right.include(context, includeChildrenRecursively);
+    }
-    initialise() {
-        super.initialise();
-        if (this.left instanceof Identifier) {
-            const variable = this.scope.variables.get(this.left.name);
-            if (variable?.kind === 'const') {
-                this.scope.context.error(parseAst_js.logConstVariableReassignError(), this.left.start);
+            }
+        }
-        this.left.setAssignedValue(this.right);
+    }
-    render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
-        const { left, right, start, end, parent } = this;
-        if (left.included) {
-            left.render(code, options);
-            right.render(code, options);
+        }
-        else {
-            const inclusionStart = findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, '=', left.end) + 1);
-            code.remove(start, inclusionStart);
-            if (preventASI) {
-                removeLineBreaks(code, inclusionStart, right.start);
+            }
-            right.render(code, options, {
-                renderedParentType: renderedParentType || parent.type,
-                renderedSurroundingElement: renderedSurroundingElement || parent.type
-            });
+        }
-        if (options.format === 'system') {
-            if (left instanceof Identifier) {
-                const variable = left.variable;
-                const exportNames = options.exportNamesByVariable.get(variable);
-                if (exportNames) {
-                    if (exportNames.length === 1) {
-                        renderSystemExportExpression(variable, start, end, code, options);
+                    }
-                    else {
-                        renderSystemExportSequenceAfterExpression(variable, start, end, parent.type !== parseAst_js.ExpressionStatement, code, options);
+                    }
-                    return;
+                }
+            }
-            else {
-                const systemPatternExports = [];
-                left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
-                if (systemPatternExports.length > 0) {
-                    renderSystemExportFunction(systemPatternExports, start, end, renderedSurroundingElement === parseAst_js.ExpressionStatement, code, options);
-                    return;
+                }
+            }
+        }
-        if (left.included &&
-            left instanceof ObjectPattern &&
-            (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
-                renderedSurroundingElement === parseAst_js.ArrowFunctionExpression)) {
-            code.appendRight(start, '(');
-            code.prependLeft(end, ')');
+        }
+    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.left.deoptimizePath(EMPTY_PATH);
-        this.right.deoptimizePath(UNKNOWN_PATH);
-        this.scope.context.requestTreeshakingPass();
+    }
+}
-class AssignmentPattern extends NodeBase {
-    addExportedVariables(variables, exportNamesByVariable) {
-        this.left.addExportedVariables(variables, exportNamesByVariable);
+    }
-    declare(kind, init) {
-        return this.left.declare(kind, init);
+    }
-    deoptimizePath(path) {
-        path.length === 0 && this.left.deoptimizePath(path);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        return (path.length > 0 || this.left.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
+    }
-    markDeclarationReached() {
-        this.left.markDeclarationReached();
+    }
-    render(code, options, { isShorthandProperty } = parseAst_js.BLANK) {
-        this.left.render(code, options, { isShorthandProperty });
-        this.right.render(code, options);
+    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.left.deoptimizePath(EMPTY_PATH);
-        this.right.deoptimizePath(UNKNOWN_PATH);
-        this.scope.context.requestTreeshakingPass();
+    }
+}
-class ArgumentsVariable extends LocalVariable {
-    constructor(context) {
-        super('arguments', null, UNKNOWN_EXPRESSION, context, 'other');
-        this.deoptimizedArguments = [];
+    }
-    addArgumentToBeDeoptimized(argument) {
-        if (this.included) {
-            argument.deoptimizePath(UNKNOWN_PATH);
+        }
-        else {
-            this.deoptimizedArguments.push(argument);
+        }
+    }
-    hasEffectsOnInteractionAtPath(path, { type }) {
-        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
-    include() {
-        super.include();
-        for (const argument of this.deoptimizedArguments) {
-            argument.deoptimizePath(UNKNOWN_PATH);
+        }
-        this.deoptimizedArguments.length = 0;
+    }
+}
-class ThisVariable extends ParameterVariable {
-    constructor(context) {
-        super('this', null, context);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        return (context.replacedVariableInits.get(this) || UNKNOWN_EXPRESSION).hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+}
-class FunctionScope extends ReturnValueScope {
-    constructor(parent) {
-        const { context } = parent;
-        super(parent, false);
-        this.variables.set('arguments', (this.argumentsVariable = new ArgumentsVariable(context)));
-        this.variables.set('this', (this.thisVariable = new ThisVariable(context)));
+    }
-    findLexicalBoundary() {
-        return this;
+    }
-    includeCallArguments(context, parameters) {
-        super.includeCallArguments(context, parameters);
-        if (this.argumentsVariable.included) {
-            for (const argument of parameters) {
-                if (!argument.included) {
-                    argument.include(context, false);
+                }
+            }
+        }
+    }
+}
 class FunctionNode extends FunctionBase {
     constructor() {
 …
+}
-class AwaitExpression extends NodeBase {
-    hasEffects() {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        return true;
+    }
-    include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (!this.included) {
-            this.included = true;
-            checkTopLevelAwait: if (!this.scope.context.usesTopLevelAwait) {
-                let parent = this.parent;
-                do {
-                    if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression)
-                        break checkTopLevelAwait;
-                } while ((parent = parent.parent));
-                this.scope.context.usesTopLevelAwait = true;
+            }
+        }
-        this.argument.include(context, includeChildrenRecursively);
+    }
+}
-const binaryOperators = {
-    '!=': (left, right) => left != right,
-    '!==': (left, right) => left !== right,
-    '%': (left, right) => left % right,
-    '&': (left, right) => left & right,
-    '*': (left, right) => left * right,
-    // At the moment, "**" will be transpiled to Math.pow
-    '**': (left, right) => left ** right,
-    '+': (left, right) => left + right,
-    '-': (left, right) => left - right,
-    '/': (left, right) => left / right,
-    '<': (left, right) => left < right,
-    '<<': (left, right) => left << right,
-    '<=': (left, right) => left <= right,
-    '==': (left, right) => left == right,
-    '===': (left, right) => left === right,
-    '>': (left, right) => left > right,
-    '>=': (left, right) => left >= right,
-    '>>': (left, right) => left >> right,
-    '>>>': (left, right) => left >>> right,
-    '^': (left, right) => left ^ right,
-    '|': (left, right) => left | right
-    // We use the fallback for cases where we return something unknown
-    // in: () => UnknownValue,
-    // instanceof: () => UnknownValue,
-};
-class BinaryExpression extends NodeBase {
-    deoptimizeCache() { }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (path.length > 0)
-            return UnknownValue;
-        const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (typeof leftValue === 'symbol')
-            return UnknownValue;
-        const rightValue = this.right.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (typeof rightValue === 'symbol')
-            return UnknownValue;
-        const operatorFunction = binaryOperators[this.operator];
-        if (!operatorFunction)
-            return UnknownValue;
-        return operatorFunction(leftValue, rightValue);
+    }
-    hasEffects(context) {
-        // support some implicit type coercion runtime errors
-        if (this.operator === '+' &&
-            this.parent instanceof ExpressionStatement &&
-            this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '') {
-            return true;
+        }
-        return super.hasEffects(context);
+    }
-    hasEffectsOnInteractionAtPath(path, { type }) {
-        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
-    removeAnnotations(code) {
-        this.left.removeAnnotations(code);
+    }
-    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
-        this.left.render(code, options, { renderedSurroundingElement });
-        this.right.render(code, options);
+    }
+}
-class BreakStatement extends NodeBase {
-    hasEffects(context) {
-        if (this.label) {
-            if (!context.ignore.labels.has(this.label.name))
-                return true;
-            context.includedLabels.add(this.label.name);
+        }
-        else {
-            if (!context.ignore.breaks)
-                return true;
-            context.hasBreak = true;
+        }
-        context.brokenFlow = true;
-        return false;
+    }
-    include(context) {
-        this.included = true;
-        if (this.label) {
-            this.label.include();
-            context.includedLabels.add(this.label.name);
+        }
-        else {
-            context.hasBreak = true;
+        }
-        context.brokenFlow = true;
+    }
+}
-function renderCallArguments(code, options, node) {
-    if (node.arguments.length > 0) {
-        if (node.arguments[node.arguments.length - 1].included) {
-            for (const argument of node.arguments) {
-                argument.render(code, options);
+            }
+        }
-        else {
-            let lastIncludedIndex = node.arguments.length - 2;
-            while (lastIncludedIndex >= 0 && !node.arguments[lastIncludedIndex].included) {
-                lastIncludedIndex--;
+            }
-            if (lastIncludedIndex >= 0) {
-                for (let index = 0; index <= lastIncludedIndex; index++) {
-                    node.arguments[index].render(code, options);
+                }
-                code.remove(findFirstOccurrenceOutsideComment(code.original, ',', node.arguments[lastIncludedIndex].end), node.end - 1);
+            }
-            else {
-                code.remove(findFirstOccurrenceOutsideComment(code.original, '(', node.callee.end) + 1, node.end - 1);
+            }
+        }
+    }
+}
-class Literal extends NodeBase {
-    deoptimizeArgumentsOnInteractionAtPath() { }
-    getLiteralValueAtPath(path) {
-        if (path.length > 0 ||
-            // unknown literals can also be null but do not start with an "n"
-            (this.value === null && this.scope.context.code.charCodeAt(this.start) !== 110) ||
-            typeof this.value === 'bigint' ||
-            // to support shims for regular expressions
-            this.scope.context.code.charCodeAt(this.start) === 47) {
-            return UnknownValue;
+        }
-        return this.value;
+    }
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length !== 1)
-            return UNKNOWN_RETURN_EXPRESSION;
-        return getMemberReturnExpressionWhenCalled(this.members, path[0]);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        switch (interaction.type) {
-            case INTERACTION_ACCESSED: {
-                return path.length > (this.value === null ? 0 : 1);
+            }
-            case INTERACTION_ASSIGNED: {
-                return true;
+            }
-            case INTERACTION_CALLED: {
-                if (this.included &&
-                    this.value instanceof RegExp &&
-                    (this.value.global || this.value.sticky)) {
-                    return true;
+                }
-                return (path.length !== 1 ||
-                    hasMemberEffectWhenCalled(this.members, path[0], interaction, context));
+            }
+        }
+    }
-    initialise() {
-        super.initialise();
-        this.members = getLiteralMembersForValue(this.value);
+    }
-    parseNode(esTreeNode) {
-        this.value = esTreeNode.value;
-        this.regex = esTreeNode.regex;
-        return super.parseNode(esTreeNode);
+    }
-    render(code) {
-        if (typeof this.value === 'string') {
-            code.indentExclusionRanges.push([this.start + 1, this.end - 1]);
+        }
+    }
+}
-function getChainElementLiteralValueAtPath(element, object, path, recursionTracker, origin) {
-    if ('getLiteralValueAtPathAsChainElement' in object) {
-        const calleeValue = object.getLiteralValueAtPathAsChainElement(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin);
-        if (calleeValue === IS_SKIPPED_CHAIN || (element.optional && calleeValue == null)) {
-            return IS_SKIPPED_CHAIN;
+        }
+    }
-    else if (element.optional &&
-        object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null) {
-        return IS_SKIPPED_CHAIN;
+    }
-    return element.getLiteralValueAtPath(path, recursionTracker, origin);
+}
-// To avoid infinite recursions
-const MAX_PATH_DEPTH = 7;
-function getResolvablePropertyKey(memberExpression) {
-    return memberExpression.computed
-        ? getResolvableComputedPropertyKey(memberExpression.property)
-        : memberExpression.property.name;
+}
-function getResolvableComputedPropertyKey(propertyKey) {
-    if (propertyKey instanceof Literal) {
-        return String(propertyKey.value);
+    }
-    return null;
+}
-function getPathIfNotComputed(memberExpression) {
-    const nextPathKey = memberExpression.propertyKey;
-    const object = memberExpression.object;
-    if (typeof nextPathKey === 'string') {
-        if (object instanceof Identifier) {
-            return [
-                { key: object.name, pos: object.start },
-                { key: nextPathKey, pos: memberExpression.property.start }
-            ];
+        }
-        if (object instanceof MemberExpression) {
-            const parentPath = getPathIfNotComputed(object);
-            return (parentPath && [...parentPath, { key: nextPathKey, pos: memberExpression.property.start }]);
+        }
+    }
-    return null;
+}
-function getStringFromPath(path) {
-    let pathString = path[0].key;
-    for (let index = 1; index < path.length; index++) {
-        pathString += '.' + path[index].key;
+    }
-    return pathString;
+}
-class MemberExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.variable = null;
-        this.expressionsToBeDeoptimized = [];
+    }
-    get computed() {
-        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
-    set computed(value) {
-        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
-    get optional() {
-        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
-    set optional(value) {
-        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
-    get assignmentDeoptimized() {
-        return isFlagSet(this.flags, 16 /* Flag.assignmentDeoptimized */);
+    }
-    set assignmentDeoptimized(value) {
-        this.flags = setFlag(this.flags, 16 /* Flag.assignmentDeoptimized */, value);
+    }
-    get bound() {
-        return isFlagSet(this.flags, 32 /* Flag.bound */);
+    }
-    set bound(value) {
-        this.flags = setFlag(this.flags, 32 /* Flag.bound */, value);
+    }
-    get isUndefined() {
-        return isFlagSet(this.flags, 64 /* Flag.isUndefined */);
+    }
-    set isUndefined(value) {
-        this.flags = setFlag(this.flags, 64 /* Flag.isUndefined */, value);
+    }
-    bind() {
-        this.bound = true;
-        const path = getPathIfNotComputed(this);
-        const baseVariable = path && this.scope.findVariable(path[0].key);
-        if (baseVariable?.isNamespace) {
-            const resolvedVariable = resolveNamespaceVariables(baseVariable, path.slice(1), this.scope.context);
-            if (!resolvedVariable) {
-                super.bind();
+            }
-            else if (resolvedVariable === 'undefined') {
-                this.isUndefined = true;
+            }
-            else {
-                this.variable = resolvedVariable;
-                this.scope.addNamespaceMemberAccess(getStringFromPath(path), resolvedVariable);
+            }
+        }
-        else {
-            super.bind();
+        }
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (this.variable) {
-            this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        }
-        else if (!this.isUndefined) {
-            if (path.length < MAX_PATH_DEPTH) {
-                this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.getPropertyKey(), ...path], recursionTracker);
+            }
-            else {
-                deoptimizeInteraction(interaction);
+            }
+        }
+    }
-    deoptimizeCache() {
-        const { expressionsToBeDeoptimized, object } = this;
-        this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
-        this.propertyKey = UnknownKey;
-        object.deoptimizePath(UNKNOWN_PATH);
-        for (const expression of expressionsToBeDeoptimized) {
-            expression.deoptimizeCache();
+        }
+    }
-    deoptimizePath(path) {
-        if (path.length === 0)
-            this.disallowNamespaceReassignment();
-        if (this.variable) {
-            this.variable.deoptimizePath(path);
+        }
-        else if (!this.isUndefined && path.length < MAX_PATH_DEPTH) {
-            const propertyKey = this.getPropertyKey();
-            this.object.deoptimizePath([
-                propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
-                ...path
-            ]);
+        }
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.variable) {
-            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
-        if (this.isUndefined) {
-            return undefined;
+        }
-        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
-            this.expressionsToBeDeoptimized.push(origin);
-            return this.object.getLiteralValueAtPath([this.getPropertyKey(), ...path], recursionTracker, origin);
+        }
-        return UnknownValue;
+    }
-    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
-        if (this.variable) {
-            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
-        if (this.isUndefined) {
-            return undefined;
+        }
-        return getChainElementLiteralValueAtPath(this, this.object, path, recursionTracker, origin);
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        if (this.variable) {
-            return this.variable.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
-        if (this.isUndefined) {
-            return [UNDEFINED_EXPRESSION, false];
+        }
-        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
-            this.expressionsToBeDeoptimized.push(origin);
-            return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], interaction, recursionTracker, origin);
+        }
-        return UNKNOWN_RETURN_EXPRESSION;
+    }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        return (this.property.hasEffects(context) ||
-            this.object.hasEffects(context) ||
-            this.hasAccessEffect(context));
+    }
-    hasEffectsAsChainElement(context) {
-        if (this.variable || this.isUndefined)
-            return this.hasEffects(context);
-        const objectHasEffects = 'hasEffectsAsChainElement' in this.object
-            ? this.object.hasEffectsAsChainElement(context)
-            : this.object.hasEffects(context);
-        if (objectHasEffects === IS_SKIPPED_CHAIN)
-            return IS_SKIPPED_CHAIN;
-        if (this.optional &&
-            this.object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
-            return objectHasEffects || IS_SKIPPED_CHAIN;
+        }
-        // We only apply deoptimizations lazily once we know we are not skipping
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        return this.property.hasEffects(context) || this.hasAccessEffect(context);
+    }
-    hasEffectsAsAssignmentTarget(context, checkAccess) {
-        if (checkAccess && !this.deoptimized)
-            this.applyDeoptimizations();
-        if (!this.assignmentDeoptimized)
-            this.applyAssignmentDeoptimization();
-        return (this.property.hasEffects(context) ||
-            this.object.hasEffects(context) ||
-            (checkAccess && this.hasAccessEffect(context)) ||
-            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (this.variable) {
-            return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
-        if (this.isUndefined) {
-            return true;
+        }
-        if (path.length < MAX_PATH_DEPTH) {
-            return this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey(), ...path], interaction, context);
+        }
-        return true;
+    }
-    include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.includeProperties(context, includeChildrenRecursively);
+    }
-    includeAsAssignmentTarget(context, includeChildrenRecursively, deoptimizeAccess) {
-        if (!this.assignmentDeoptimized)
-            this.applyAssignmentDeoptimization();
-        if (deoptimizeAccess) {
-            this.include(context, includeChildrenRecursively);
+        }
-        else {
-            this.includeProperties(context, includeChildrenRecursively);
+        }
+    }
-    includeCallArguments(context, parameters) {
-        if (this.variable) {
-            this.variable.includeCallArguments(context, parameters);
+        }
-        else {
-            super.includeCallArguments(context, parameters);
+        }
+    }
-    initialise() {
-        super.initialise();
-        this.propertyKey = getResolvablePropertyKey(this);
-        this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
+    }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = parseAst_js.BLANK) {
-        if (this.variable || this.isUndefined) {
-            const { snippets: { getPropertyAccess } } = options;
-            let replacement = this.variable ? this.variable.getName(getPropertyAccess) : 'undefined';
-            if (renderedParentType && isCalleeOfRenderedParent)
-                replacement = '0, ' + replacement;
-            code.overwrite(this.start, this.end, replacement, {
-                contentOnly: true,
-                storeName: true
-            });
+        }
-        else {
-            if (renderedParentType && isCalleeOfRenderedParent) {
-                code.appendRight(this.start, '0, ');
+            }
-            this.object.render(code, options, { renderedSurroundingElement });
-            this.property.render(code, options);
+        }
+    }
-    setAssignedValue(value) {
-        this.assignmentInteraction = {
-            args: [this.object, value],
-            type: INTERACTION_ASSIGNED
-        };
+    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        const { propertyReadSideEffects } = this.scope.context.options
-            .treeshake;
-        if (
-        // Namespaces are not bound and should not be deoptimized
-        this.bound &&
-            propertyReadSideEffects &&
-            !(this.variable || this.isUndefined)) {
-            const propertyKey = this.getPropertyKey();
-            this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [propertyKey], SHARED_RECURSION_TRACKER);
-            this.scope.context.requestTreeshakingPass();
+        }
-        if (this.variable) {
-            this.variable.addUsedPlace(this);
-            this.scope.context.requestTreeshakingPass();
+        }
+    }
-    applyAssignmentDeoptimization() {
-        this.assignmentDeoptimized = true;
-        const { propertyReadSideEffects } = this.scope.context.options
-            .treeshake;
-        if (
-        // Namespaces are not bound and should not be deoptimized
-        this.bound &&
-            propertyReadSideEffects &&
-            !(this.variable || this.isUndefined)) {
-            this.object.deoptimizeArgumentsOnInteractionAtPath(this.assignmentInteraction, [this.getPropertyKey()], SHARED_RECURSION_TRACKER);
-            this.scope.context.requestTreeshakingPass();
+        }
+    }
-    disallowNamespaceReassignment() {
-        if (this.object instanceof Identifier) {
-            const variable = this.scope.findVariable(this.object.name);
-            if (variable.isNamespace) {
-                if (this.variable) {
-                    this.scope.context.includeVariableInModule(this.variable);
+                }
-                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logIllegalImportReassignment(this.object.name, this.scope.context.module.id), this.start);
+            }
+        }
+    }
-    getPropertyKey() {
-        if (this.propertyKey === null) {
-            this.propertyKey = UnknownKey;
-            const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            return (this.propertyKey =
-                value === SymbolToStringTag
-                    ? value
-                    : typeof value === 'symbol'
-                        ? UnknownKey
-                        : String(value));
+        }
-        return this.propertyKey;
+    }
-    hasAccessEffect(context) {
-        const { propertyReadSideEffects } = this.scope.context.options
-            .treeshake;
-        return (!(this.variable || this.isUndefined) &&
-            propertyReadSideEffects &&
-            (propertyReadSideEffects === 'always' ||
-                this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey()], this.accessInteraction, context)));
+    }
-    includeProperties(context, includeChildrenRecursively) {
-        if (!this.included) {
-            this.included = true;
-            if (this.variable) {
-                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
-        this.object.include(context, includeChildrenRecursively);
-        this.property.include(context, includeChildrenRecursively);
+    }
+}
-function resolveNamespaceVariables(baseVariable, path, astContext) {
-    if (path.length === 0)
-        return baseVariable;
-    if (!baseVariable.isNamespace || baseVariable instanceof ExternalVariable)
-        return null;
-    const exportName = path[0].key;
-    const variable = baseVariable.context.traceExport(exportName);
-    if (!variable) {
-        if (path.length === 1) {
-            const fileName = baseVariable.context.fileName;
-            astContext.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
-            return 'undefined';
+        }
-        return null;
+    }
-    return resolveNamespaceVariables(variable, path.slice(1), astContext);
+}
-class CallExpressionBase extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.returnExpression = null;
-        this.deoptimizableDependentExpressions = [];
-        this.expressionsToBeDeoptimized = new Set();
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        const { args } = interaction;
-        const [returnExpression, isPure] = this.getReturnExpression(recursionTracker);
-        if (isPure)
-            return;
-        const deoptimizedExpressions = args.filter(expression => !!expression && expression !== UNKNOWN_EXPRESSION);
-        if (deoptimizedExpressions.length === 0)
-            return;
-        if (returnExpression === UNKNOWN_EXPRESSION) {
-            for (const expression of deoptimizedExpressions) {
-                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
-        else {
-            recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
-                for (const expression of deoptimizedExpressions) {
-                    this.expressionsToBeDeoptimized.add(expression);
+                }
-                returnExpression.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
-            }, null);
+        }
+    }
-    deoptimizeCache() {
-        if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
-            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
-            const { deoptimizableDependentExpressions, expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_SET;
-            this.deoptimizableDependentExpressions = parseAst_js.EMPTY_ARRAY;
-            for (const expression of deoptimizableDependentExpressions) {
-                expression.deoptimizeCache();
+            }
-            for (const expression of expressionsToBeDeoptimized) {
-                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+    }
-    deoptimizePath(path) {
-        if (path.length === 0 ||
-            this.scope.context.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
-            return;
+        }
-        const [returnExpression] = this.getReturnExpression();
-        if (returnExpression !== UNKNOWN_EXPRESSION) {
-            returnExpression.deoptimizePath(path);
+        }
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        const [returnExpression] = this.getReturnExpression(recursionTracker);
-        if (returnExpression === UNKNOWN_EXPRESSION) {
-            return UnknownValue;
+        }
-        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
-            this.deoptimizableDependentExpressions.push(origin);
-            return returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
-        }, UnknownValue);
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        const returnExpression = this.getReturnExpression(recursionTracker);
-        if (returnExpression[0] === UNKNOWN_EXPRESSION) {
-            return returnExpression;
+        }
-        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
-            this.deoptimizableDependentExpressions.push(origin);
-            const [expression, isPure] = returnExpression[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
-            return [expression, isPure || returnExpression[1]];
-        }, UNKNOWN_RETURN_EXPRESSION);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        const { type } = interaction;
-        if (type === INTERACTION_CALLED) {
-            const { args, withNew } = interaction;
-            if ((withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, args, this)) {
-                return false;
+            }
+        }
-        else if ((type === INTERACTION_ASSIGNED
-            ? context.assigned
-            : context.accessed).trackEntityAtPathAndGetIfTracked(path, this)) {
-            return false;
+        }
-        const [returnExpression, isPure] = this.getReturnExpression();
-        return ((type === INTERACTION_ASSIGNED || !isPure) &&
-            returnExpression.hasEffectsOnInteractionAtPath(path, interaction, context));
+    }
+}
-class CallExpression extends CallExpressionBase {
-    get optional() {
-        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
-    set optional(value) {
-        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
-    bind() {
-        super.bind();
-        if (this.callee instanceof Identifier) {
-            const variable = this.scope.findVariable(this.callee.name);
-            if (variable.isNamespace) {
-                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logCannotCallNamespace(this.callee.name), this.start);
+            }
-            if (this.callee.name === 'eval') {
-                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logEval(this.scope.context.module.id), this.start);
+            }
+        }
-        this.interaction = {
-            args: [
-                this.callee instanceof MemberExpression && !this.callee.variable
-                    ? this.callee.object
-                    : null,
-                ...this.arguments
-            ],
-            type: INTERACTION_CALLED,
-            withNew: false
-        };
+    }
-    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
-        return getChainElementLiteralValueAtPath(this, this.callee, path, recursionTracker, origin);
+    }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        for (const argument of this.arguments) {
-            if (argument.hasEffects(context))
-                return true;
+        }
-        if (this.annotationPure) {
-            return false;
+        }
-        return (this.callee.hasEffects(context) ||
-            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
-    hasEffectsAsChainElement(context) {
-        const calleeHasEffects = 'hasEffectsAsChainElement' in this.callee
-            ? this.callee.hasEffectsAsChainElement(context)
-            : this.callee.hasEffects(context);
-        if (calleeHasEffects === IS_SKIPPED_CHAIN)
-            return IS_SKIPPED_CHAIN;
-        if (this.optional &&
-            this.callee.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
-            return (!this.annotationPure && calleeHasEffects) || IS_SKIPPED_CHAIN;
+        }
-        // We only apply deoptimizations lazily once we know we are not skipping
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        for (const argument of this.arguments) {
-            if (argument.hasEffects(context))
-                return true;
+        }
-        return (!this.annotationPure &&
-            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
-    include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (includeChildrenRecursively) {
-            super.include(context, includeChildrenRecursively);
-            if (includeChildrenRecursively === INCLUDE_PARAMETERS &&
-                this.callee instanceof Identifier &&
-                this.callee.variable) {
-                this.callee.variable.markCalledFromTryStatement();
+            }
+        }
-        else {
-            this.included = true;
-            this.callee.include(context, false);
+        }
-        this.callee.includeCallArguments(context, this.arguments);
+    }
-    initialise() {
-        super.initialise();
-        if (this.annotations &&
-            this.scope.context.options.treeshake.annotations) {
-            this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
+        }
+    }
-    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
-        this.callee.render(code, options, {
-            isCalleeOfRenderedParent: true,
-            renderedSurroundingElement
-        });
-        renderCallArguments(code, options, this);
+    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.callee.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
-        this.scope.context.requestTreeshakingPass();
+    }
-    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
-        if (this.returnExpression === null) {
-            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
-            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
+        }
-        return this.returnExpression;
+    }
+}
-class CatchClause extends NodeBase {
-    createScope(parentScope) {
-        this.scope = new ParameterScope(parentScope, true);
+    }
-    parseNode(esTreeNode) {
-        const { body, param, type } = esTreeNode;
-        this.type = type;
-        if (param) {
-            this.param = new (this.scope.context.getNodeConstructor(param.type))(this, this.scope).parseNode(param);
-            this.param.declare('parameter', UNKNOWN_EXPRESSION);
+        }
-        this.body = new BlockStatement(this, this.scope.bodyScope).parseNode(body);
-        return super.parseNode(esTreeNode);
+    }
+}
-CatchClause.prototype.preventChildBlockScope = true;
-class ChainExpression extends NodeBase {
-    // deoptimizations are not relevant as we are not caching values
-    deoptimizeCache() { }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        const literalValue = this.expression.getLiteralValueAtPathAsChainElement(path, recursionTracker, origin);
-        return literalValue === IS_SKIPPED_CHAIN ? undefined : literalValue;
+    }
-    hasEffects(context) {
-        return this.expression.hasEffectsAsChainElement(context) === true;
+    }
-    removeAnnotations(code) {
-        this.expression.removeAnnotations(code);
+    }
-    applyDeoptimizations() { }
+}
-class ClassBodyScope extends ChildScope {
-    constructor(parent, classNode) {
-        const { context } = parent;
-        super(parent, context);
-        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, context, 'other')));
-        this.instanceScope = new ChildScope(this, context);
-        this.instanceScope.variables.set('this', new ThisVariable(context));
+    }
-    findLexicalBoundary() {
-        return this;
+    }
+}
-class ClassBody extends NodeBase {
-    createScope(parentScope) {
-        this.scope = new ClassBodyScope(parentScope, this.parent);
+    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        this.scope.context.includeVariableInModule(this.scope.thisVariable);
-        for (const definition of this.body) {
-            definition.include(context, includeChildrenRecursively);
+        }
+    }
-    parseNode(esTreeNode) {
-        const body = (this.body = []);
-        for (const definition of esTreeNode.body) {
-            body.push(new (this.scope.context.getNodeConstructor(definition.type))(this, definition.static ? this.scope : this.scope.instanceScope).parseNode(definition));
+        }
-        return super.parseNode(esTreeNode);
+    }
-    applyDeoptimizations() { }
+}
-function checkEffectForNodes(nodes, context) {
-    for (const node of nodes) {
-        if (node.hasEffects(context)) {
-            return true;
+        }
+    }
-    return false;
+}
-class MethodBase extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.accessedValue = null;
+    }
-    get computed() {
-        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
-    set computed(value) {
-        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (interaction.type === INTERACTION_ACCESSED && this.kind === 'get' && path.length === 0) {
-            return this.value.deoptimizeArgumentsOnInteractionAtPath({
-                args: interaction.args,
-                type: INTERACTION_CALLED,
-                withNew: false
-            }, EMPTY_PATH, recursionTracker);
+        }
-        if (interaction.type === INTERACTION_ASSIGNED && this.kind === 'set' && path.length === 0) {
-            return this.value.deoptimizeArgumentsOnInteractionAtPath({
-                args: interaction.args,
-                type: INTERACTION_CALLED,
-                withNew: false
-            }, EMPTY_PATH, recursionTracker);
+        }
-        this.getAccessedValue()[0].deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
-    // As getter properties directly receive their values from fixed function
-    // expressions, there is no known situation where a getter is deoptimized.
-    deoptimizeCache() { }
-    deoptimizePath(path) {
-        this.getAccessedValue()[0].deoptimizePath(path);
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getAccessedValue()[0].getLiteralValueAtPath(path, recursionTracker, origin);
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return this.getAccessedValue()[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
-    hasEffects(context) {
-        return this.key.hasEffects(context);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (this.kind === 'get' && interaction.type === INTERACTION_ACCESSED && path.length === 0) {
-            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
-                args: interaction.args,
-                type: INTERACTION_CALLED,
-                withNew: false
-            }, context);
+        }
-        // setters are only called for empty paths
-        if (this.kind === 'set' && interaction.type === INTERACTION_ASSIGNED) {
-            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
-                args: interaction.args,
-                type: INTERACTION_CALLED,
-                withNew: false
-            }, context);
+        }
-        return this.getAccessedValue()[0].hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
-    applyDeoptimizations() { }
-    getAccessedValue() {
-        if (this.accessedValue === null) {
-            if (this.kind === 'get') {
-                this.accessedValue = UNKNOWN_RETURN_EXPRESSION;
-                return (this.accessedValue = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, SHARED_RECURSION_TRACKER, this));
+            }
-            else {
-                return (this.accessedValue = [this.value, false]);
+            }
+        }
-        return this.accessedValue;
+    }
+}
-class MethodDefinition extends MethodBase {
-    hasEffects(context) {
-        return super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
-    applyDeoptimizations() { }
+}
-class StaticBlock extends NodeBase {
-    createScope(parentScope) {
-        this.scope = new BlockScope(parentScope);
+    }
-    hasEffects(context) {
-        for (const node of this.body) {
-            if (node.hasEffects(context))
-                return true;
+        }
-        return false;
+    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        for (const node of this.body) {
-            if (includeChildrenRecursively || node.shouldBeIncluded(context))
-                node.include(context, includeChildrenRecursively);
+        }
+    }
-    render(code, options) {
-        if (this.body.length > 0) {
-            const bodyStartPos = findFirstOccurrenceOutsideComment(code.original.slice(this.start, this.end), '{') + 1;
-            renderStatementList(this.body, code, this.start + bodyStartPos, this.end - 1, options);
+        }
-        else {
-            super.render(code, options);
+        }
+    }
+}
-function isStaticBlock(statement) {
-    return statement.type === parseAst_js.StaticBlock;
+}
-class ObjectMember extends ExpressionEntity {
-    constructor(object, key) {
-        super();
-        this.object = object;
-        this.key = key;
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.key, ...path], recursionTracker);
+    }
-    deoptimizePath(path) {
-        this.object.deoptimizePath([this.key, ...path]);
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.object.getLiteralValueAtPath([this.key, ...path], recursionTracker, origin);
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], interaction, recursionTracker, origin);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        return this.object.hasEffectsOnInteractionAtPath([this.key, ...path], interaction, context);
+    }
+}
-class ClassNode extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.objectEntity = null;
+    }
-    createScope(parentScope) {
-        this.scope = new ChildScope(parentScope, parentScope.context);
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
-    deoptimizeCache() {
-        this.getObjectEntity().deoptimizeAllProperties();
+    }
-    deoptimizePath(path) {
-        this.getObjectEntity().deoptimizePath(path);
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        const initEffect = this.superClass?.hasEffects(context) || this.body.hasEffects(context);
-        this.id?.markDeclarationReached();
-        return initEffect || super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        return interaction.type === INTERACTION_CALLED && path.length === 0
-            ? !interaction.withNew ||
-                (this.classConstructor === null
-                    ? this.superClass?.hasEffectsOnInteractionAtPath(path, interaction, context)
-                    : this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
-                false
-            : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
-    include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.included = true;
-        this.superClass?.include(context, includeChildrenRecursively);
-        this.body.include(context, includeChildrenRecursively);
-        for (const decorator of this.decorators)
-            decorator.include(context, includeChildrenRecursively);
-        if (this.id) {
-            this.id.markDeclarationReached();
-            this.id.include();
+        }
+    }
-    initialise() {
-        super.initialise();
-        this.id?.declare('class', this);
-        for (const method of this.body.body) {
-            if (method instanceof MethodDefinition && method.kind === 'constructor') {
-                this.classConstructor = method;
-                return;
+            }
+        }
-        this.classConstructor = null;
+    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        for (const definition of this.body.body) {
-            if (!isStaticBlock(definition) &&
-                !(definition.static ||
-                    (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
-                // Calls to methods are not tracked, ensure that the return value is deoptimized
-                definition.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
-        this.scope.context.requestTreeshakingPass();
+    }
-    getObjectEntity() {
-        if (this.objectEntity !== null) {
-            return this.objectEntity;
+        }
-        const staticProperties = [];
-        const dynamicMethods = [];
-        for (const definition of this.body.body) {
-            if (isStaticBlock(definition))
-                continue;
-            const properties = definition.static ? staticProperties : dynamicMethods;
-            const definitionKind = definition.kind;
-            // Note that class fields do not end up on the prototype
-            if (properties === dynamicMethods && !definitionKind)
-                continue;
-            const kind = definitionKind === 'set' || definitionKind === 'get' ? definitionKind : 'init';
-            let key;
-            if (definition.computed) {
-                const keyValue = definition.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-                if (typeof keyValue === 'symbol') {
-                    properties.push({ key: UnknownKey, kind, property: definition });
-                    continue;
+                }
-                else {
-                    key = String(keyValue);
+                }
+            }
-            else {
-                key =
-                    definition.key instanceof Identifier
-                        ? definition.key.name
-                        : String(definition.key.value);
+            }
-            properties.push({ key, kind, property: definition });
+        }
-        staticProperties.unshift({
-            key: 'prototype',
-            kind: 'init',
-            property: new ObjectEntity(dynamicMethods, this.superClass ? new ObjectMember(this.superClass, 'prototype') : OBJECT_PROTOTYPE)
-        });
-        return (this.objectEntity = new ObjectEntity(staticProperties, this.superClass || OBJECT_PROTOTYPE));
+    }
+}
-class ClassDeclaration extends ClassNode {
-    initialise() {
-        super.initialise();
-        if (this.id !== null) {
-            this.id.variable.isId = true;
+        }
+    }
-    parseNode(esTreeNode) {
-        if (esTreeNode.id !== null) {
-            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
+        }
-        return super.parseNode(esTreeNode);
+    }
-    render(code, options) {
-        const { exportNamesByVariable, format, snippets: { _, getPropertyAccess } } = options;
-        if (this.id) {
-            const { variable, name } = this.id;
-            if (format === 'system' && exportNamesByVariable.has(variable)) {
-                code.appendLeft(this.end, `${_}${getSystemExportStatement([variable], options)};`);
+            }
-            const renderedVariable = variable.getName(getPropertyAccess);
-            if (renderedVariable !== name) {
-                this.decorators.map(decorator => decorator.render(code, options));
-                this.superClass?.render(code, options);
-                this.body.render(code, {
-                    ...options,
-                    useOriginalName: (_variable) => _variable === variable
-                });
-                code.prependRight(this.start, `let ${renderedVariable}${_}=${_}`);
-                code.prependLeft(this.end, ';');
-                return;
+            }
+        }
-        super.render(code, options);
+    }
-    applyDeoptimizations() {
-        super.applyDeoptimizations();
-        const { id, scope } = this;
-        if (id) {
-            const { name, variable } = id;
-            for (const accessedVariable of scope.accessedOutsideVariables.values()) {
-                if (accessedVariable !== variable) {
-                    accessedVariable.forbidName(name);
+                }
+            }
+        }
+    }
+}
-class ClassExpression extends ClassNode {
-    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
-        super.render(code, options);
-        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
-            code.appendRight(this.start, '(');
-            code.prependLeft(this.end, ')');
+        }
+    }
+}
-class MultiExpression extends ExpressionEntity {
-    constructor(expressions) {
-        super();
-        this.expressions = expressions;
+    }
-    deoptimizePath(path) {
-        for (const expression of this.expressions) {
-            expression.deoptimizePath(path);
+        }
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return [
-            new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0])),
-            false
-        ];
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        for (const expression of this.expressions) {
-            if (expression.hasEffectsOnInteractionAtPath(path, interaction, context))
-                return true;
+        }
-        return false;
+    }
+}
-class ConditionalExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.expressionsToBeDeoptimized = [];
-        this.usedBranch = null;
+    }
-    get isBranchResolutionAnalysed() {
-        return isFlagSet(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */);
+    }
-    set isBranchResolutionAnalysed(value) {
-        this.flags = setFlag(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */, value);
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        this.consequent.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
-        this.alternate.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
-    deoptimizeCache() {
-        if (this.usedBranch !== null) {
-            const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
-            this.usedBranch = null;
-            unusedBranch.deoptimizePath(UNKNOWN_PATH);
-            const { expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
-            for (const expression of expressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
+            }
+        }
+    }
-    deoptimizePath(path) {
-        const usedBranch = this.getUsedBranch();
-        if (usedBranch) {
-            usedBranch.deoptimizePath(path);
+        }
-        else {
-            this.consequent.deoptimizePath(path);
-            this.alternate.deoptimizePath(path);
+        }
+    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch)
-            return UnknownValue;
-        this.expressionsToBeDeoptimized.push(origin);
-        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
+    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch)
-            return [
-                new MultiExpression([
-                    this.consequent.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
-                    this.alternate.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
-                ]),
-                false
-            ];
-        this.expressionsToBeDeoptimized.push(origin);
-        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
-    hasEffects(context) {
-        if (this.test.hasEffects(context))
-            return true;
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            return this.consequent.hasEffects(context) || this.alternate.hasEffects(context);
+        }
-        return usedBranch.hasEffects(context);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            return (this.consequent.hasEffectsOnInteractionAtPath(path, interaction, context) ||
-                this.alternate.hasEffectsOnInteractionAtPath(path, interaction, context));
+        }
-        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        const usedBranch = this.getUsedBranch();
-        if (includeChildrenRecursively || this.test.shouldBeIncluded(context) || usedBranch === null) {
-            this.test.include(context, includeChildrenRecursively);
-            this.consequent.include(context, includeChildrenRecursively);
-            this.alternate.include(context, includeChildrenRecursively);
+        }
-        else {
-            usedBranch.include(context, includeChildrenRecursively);
+        }
+    }
-    includeCallArguments(context, parameters) {
-        const usedBranch = this.getUsedBranch();
-        if (usedBranch) {
-            usedBranch.includeCallArguments(context, parameters);
+        }
-        else {
-            this.consequent.includeCallArguments(context, parameters);
-            this.alternate.includeCallArguments(context, parameters);
+        }
+    }
-    removeAnnotations(code) {
-        this.test.removeAnnotations(code);
+    }
-    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
-        const usedBranch = this.getUsedBranch();
-        if (this.test.included) {
-            this.test.render(code, options, { renderedSurroundingElement });
-            this.consequent.render(code, options);
-            this.alternate.render(code, options);
+        }
-        else {
-            const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
-            const inclusionStart = findNonWhiteSpace(code.original, (this.consequent.included
-                ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
-                : colonPos) + 1);
-            if (preventASI) {
-                removeLineBreaks(code, inclusionStart, usedBranch.start);
+            }
-            code.remove(this.start, inclusionStart);
-            if (this.consequent.included) {
-                code.remove(colonPos, this.end);
+            }
-            this.test.removeAnnotations(code);
-            usedBranch.render(code, options, {
-                isCalleeOfRenderedParent,
-                preventASI: true,
-                renderedParentType: renderedParentType || this.parent.type,
-                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
-            });
+        }
+    }
-    getUsedBranch() {
-        if (this.isBranchResolutionAnalysed) {
-            return this.usedBranch;
+        }
-        this.isBranchResolutionAnalysed = true;
-        const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-        return typeof testValue === 'symbol'
-            ? null
-            : (this.usedBranch = testValue ? this.consequent : this.alternate);
+    }
+}
-class ContinueStatement extends NodeBase {
-    hasEffects(context) {
-        if (this.label) {
-            if (!context.ignore.labels.has(this.label.name))
-                return true;
-            context.includedLabels.add(this.label.name);
+        }
-        else {
-            if (!context.ignore.continues)
-                return true;
-            context.hasContinue = true;
+        }
-        context.brokenFlow = true;
-        return false;
+    }
-    include(context) {
-        this.included = true;
-        if (this.label) {
-            this.label.include();
-            context.includedLabels.add(this.label.name);
+        }
-        else {
-            context.hasContinue = true;
+        }
-        context.brokenFlow = true;
+    }
+}
-class DebuggerStatement extends NodeBase {
-    hasEffects() {
-        return true;
+    }
+}
-class Decorator extends NodeBase {
-    hasEffects(context) {
-        return (this.expression.hasEffects(context) ||
-            this.expression.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context));
+    }
+}
-function hasLoopBodyEffects(context, body) {
-    const { brokenFlow, hasBreak, hasContinue, ignore } = context;
-    const { breaks, continues } = ignore;
-    ignore.breaks = true;
-    ignore.continues = true;
-    context.hasBreak = false;
-    context.hasContinue = false;
-    if (body.hasEffects(context))
-        return true;
-    ignore.breaks = breaks;
-    ignore.continues = continues;
-    context.hasBreak = hasBreak;
-    context.hasContinue = hasContinue;
-    context.brokenFlow = brokenFlow;
-    return false;
+}
-function includeLoopBody(context, body, includeChildrenRecursively) {
-    const { brokenFlow, hasBreak, hasContinue } = context;
-    context.hasBreak = false;
-    context.hasContinue = false;
-    body.include(context, includeChildrenRecursively, { asSingleStatement: true });
-    context.hasBreak = hasBreak;
-    context.hasContinue = hasContinue;
-    context.brokenFlow = brokenFlow;
+}
-class DoWhileStatement extends NodeBase {
-    hasEffects(context) {
-        if (this.test.hasEffects(context))
-            return true;
-        return hasLoopBodyEffects(context, this.body);
+    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        this.test.include(context, includeChildrenRecursively);
-        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+}
-class EmptyStatement extends NodeBase {
-    hasEffects() {
-        return false;
+    }
+}
-class ExportAllDeclaration extends NodeBase {
-    hasEffects() {
-        return false;
+    }
-    initialise() {
-        super.initialise();
-        this.scope.context.addExport(this);
+    }
-    render(code, _options, nodeRenderOptions) {
-        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
-    applyDeoptimizations() { }
+}
-ExportAllDeclaration.prototype.needsBoundaries = true;
 class FunctionDeclaration extends FunctionNode {
     initialise() {
 …
 ExportDefaultDeclaration.prototype.needsBoundaries = true;
+class ExportNamedDeclaration extends NodeBase {
+    bind() {
+        // Do not bind specifiers
+        this.declaration?.bind();
+    }
+    hasEffects(context) {
+        return !!this.declaration?.hasEffects(context);
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addExport(this);
+    }
+    removeAnnotations(code) {
+        this.declaration?.removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions) {
+        const { start, end } = nodeRenderOptions;
+        if (this.declaration === null) {
+            code.remove(start, end);
+        }
+        else {
+            code.remove(this.start, this.declaration.start);
+            this.declaration.render(code, options, { end, start });
+        }
+    }
+    applyDeoptimizations() { }
+}
+ExportNamedDeclaration.prototype.needsBoundaries = true;
+class ExportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+class ForInStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        if (left.hasEffectsAsAssignmentTarget(context, false) || right.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, body);
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "in" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 110 /* n */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+class ForOfStatement extends NodeBase {
+    get await() {
+        return isFlagSet(this.flags, 131072 /* Flag.await */);
+    }
+    set await(value) {
+        this.flags = setFlag(this.flags, 131072 /* Flag.await */, value);
+    }
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        // Placeholder until proper Symbol.Iterator support
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "of" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 102 /* f */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+class ForStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.init?.hasEffects(context) ||
+            this.test?.hasEffects(context) ||
+            this.update?.hasEffects(context)) {
+            return true;
+        }
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.init?.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        this.test?.include(context, includeChildrenRecursively);
+        this.update?.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+    render(code, options) {
+        this.init?.render(code, options, NO_SEMICOLON);
+        this.test?.render(code, options, NO_SEMICOLON);
+        this.update?.render(code, options, NO_SEMICOLON);
+        this.body.render(code, options);
+    }
+}
+class FunctionExpression extends FunctionNode {
+    createScope(parentScope) {
+        super.createScope((this.idScope = new ChildScope(parentScope, parentScope.context)));
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.idScope).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    onlyFunctionCallUsed() {
+        const isIIFE = this.parent.type === parseAst_js.CallExpression &&
+            this.parent.callee === this &&
+            (this.id === null || this.id.variable.getOnlyFunctionCallUsed());
+        return isIIFE || super.onlyFunctionCallUsed();
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+}
+class TrackingScope extends BlockScope {
+    constructor() {
+        super(...arguments);
+        this.hoistedDeclarations = [];
+    }
+    addDeclaration(identifier, context, init, kind) {
+        this.hoistedDeclarations.push(identifier);
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+const unset = Symbol('unset');
+class IfStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.testValue = unset;
+    }
+    deoptimizeCache() {
+        this.testValue = UnknownValue;
+    }
+    hasEffects(context) {
+        if (this.test.hasEffects(context)) {
+            return true;
+        }
+        const testValue = this.getTestValue();
+        if (typeof testValue === 'symbol') {
+            const { brokenFlow } = context;
+            if (this.consequent.hasEffects(context))
+                return true;
+            const consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+            if (this.alternate === null)
+                return false;
+            if (this.alternate.hasEffects(context))
+                return true;
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+            return false;
+        }
+        return testValue ? this.consequent.hasEffects(context) : !!this.alternate?.hasEffects(context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        if (includeChildrenRecursively) {
+            this.includeRecursively(includeChildrenRecursively, context);
+        }
+        else {
+            const testValue = this.getTestValue();
+            if (typeof testValue === 'symbol') {
+                this.includeUnknownTest(context);
+            }
+            else {
+                this.includeKnownTest(context, testValue);
+            }
+        }
+    }
+    parseNode(esTreeNode) {
+        this.consequent = new (this.scope.context.getNodeConstructor(esTreeNode.consequent.type))(this, (this.consequentScope = new TrackingScope(this.scope))).parseNode(esTreeNode.consequent);
+        if (esTreeNode.alternate) {
+            this.alternate = new (this.scope.context.getNodeConstructor(esTreeNode.alternate.type))(this, (this.alternateScope = new TrackingScope(this.scope))).parseNode(esTreeNode.alternate);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { snippets: { getPropertyAccess } } = options;
+        // Note that unknown test values are always included
+        const testValue = this.getTestValue();
+        const hoistedDeclarations = [];
+        const includesIfElse = this.test.included;
+        const noTreeshake = !this.scope.context.options.treeshake;
+        if (includesIfElse) {
+            this.test.render(code, options);
+        }
+        else {
+            code.remove(this.start, this.consequent.start);
+        }
+        if (this.consequent.included && (noTreeshake || typeof testValue === 'symbol' || testValue)) {
+            this.consequent.render(code, options);
+        }
+        else {
+            code.overwrite(this.consequent.start, this.consequent.end, includesIfElse ? ';' : '');
+            hoistedDeclarations.push(...this.consequentScope.hoistedDeclarations);
+        }
+        if (this.alternate) {
+            if (this.alternate.included && (noTreeshake || typeof testValue === 'symbol' || !testValue)) {
+                if (includesIfElse) {
+                    if (code.original.charCodeAt(this.alternate.start - 1) === 101) {
+                        code.prependLeft(this.alternate.start, ' ');
+                    }
+                }
+                else {
+                    code.remove(this.consequent.end, this.alternate.start);
+                }
+                this.alternate.render(code, options);
+            }
+            else {
+                if (includesIfElse && this.shouldKeepAlternateBranch()) {
+                    code.overwrite(this.alternate.start, this.end, ';');
+                }
+                else {
+                    code.remove(this.consequent.end, this.end);
+                }
+                hoistedDeclarations.push(...this.alternateScope.hoistedDeclarations);
+            }
+        }
+        this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
+    }
+    applyDeoptimizations() { }
+    getTestValue() {
+        if (this.testValue === unset) {
+            return (this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
+        }
+        return this.testValue;
+    }
+    includeKnownTest(context, testValue) {
+        if (this.test.shouldBeIncluded(context)) {
+            this.test.include(context, false);
+        }
+        if (testValue && this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+        }
+        if (!testValue && this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+        }
+    }
+    includeRecursively(includeChildrenRecursively, context) {
+        this.test.include(context, includeChildrenRecursively);
+        this.consequent.include(context, includeChildrenRecursively);
+        this.alternate?.include(context, includeChildrenRecursively);
+    }
+    includeUnknownTest(context) {
+        this.test.include(context, false);
+        const { brokenFlow } = context;
+        let consequentBrokenFlow = false;
+        if (this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+            consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+        }
+        if (this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+        }
+    }
+    renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess) {
+        const hoistedVariables = [
+            ...new Set(hoistedDeclarations.map(identifier => {
+                const variable = identifier.variable;
+                return variable.included ? variable.getName(getPropertyAccess) : '';
+            }))
+        ]
+            .filter(Boolean)
+            .join(', ');
+        if (hoistedVariables) {
+            const parentType = this.parent.type;
+            const needsBraces = parentType !== parseAst_js.Program && parentType !== parseAst_js.BlockStatement;
+            code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVariables}; `);
+            if (needsBraces) {
+                code.appendLeft(this.end, ` }`);
+            }
+        }
+    }
+    shouldKeepAlternateBranch() {
+        let currentParent = this.parent;
+        do {
+            if (currentParent instanceof IfStatement && currentParent.alternate) {
+                return true;
+            }
+            if (currentParent instanceof BlockStatement) {
+                return false;
+            }
+            currentParent = currentParent.parent;
+        } while (currentParent);
+        return false;
+    }
+}
+class ImportAttribute extends NodeBase {
+}
+class ImportDeclaration extends NodeBase {
+    // Do not bind specifiers or attributes
+    bind() { }
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addImport(this);
+    }
+    render(code, _options, nodeRenderOptions) {
+        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
+    applyDeoptimizations() { }
+}
+ImportDeclaration.prototype.needsBoundaries = true;
+class ImportDefaultSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
+const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
+const backSlashRegEx = /\\/g;
+function escapeId(id) {
+    if (!needsEscapeRegEx.test(id))
+        return id;
+    return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
+}
 …
 const HELPER_GENERATORS = {
     [DOCUMENT_CURRENT_SCRIPT](_t, { _, n }) {
         return `var${_}${DOCUMENT_CURRENT_SCRIPT}${_}=${_}typeof${_}document${_}!==${_}'undefined'${_}?${_}document.currentScript${_}:${_}null;${n}`;
+        return `var ${DOCUMENT_CURRENT_SCRIPT}${_}=${_}typeof document${_}!==${_}'undefined'${_}?${_}document.currentScript${_}:${_}null;${n}`;
     },
     [INTEROP_DEFAULT_COMPAT_VARIABLE](_t, snippets, liveBindings) {
 …
+}
+class Literal extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath() { }
+    getLiteralValueAtPath(path) {
+        if (path.length > 0 ||
+            // unknown literals can also be null but do not start with an "n"
+            (this.value === null && this.scope.context.code.charCodeAt(this.start) !== 110) ||
+            typeof this.value === 'bigint' ||
+            // to support shims for regular expressions
+            this.scope.context.code.charCodeAt(this.start) === 47) {
+            return UnknownValue;
+        }
+        return this.value;
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length !== 1)
+            return UNKNOWN_RETURN_EXPRESSION;
+        return getMemberReturnExpressionWhenCalled(this.members, path[0]);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                return path.length > (this.value === null ? 0 : 1);
+            }
+            case INTERACTION_ASSIGNED: {
+                return true;
+            }
+            case INTERACTION_CALLED: {
+                if (this.included &&
+                    this.value instanceof RegExp &&
+                    (this.value.global || this.value.sticky)) {
+                    return true;
+                }
+                return (path.length !== 1 ||
+                    hasMemberEffectWhenCalled(this.members, path[0], interaction, context));
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.members = getLiteralMembersForValue(this.value);
+    }
+    parseNode(esTreeNode) {
+        this.value = esTreeNode.value;
+        this.regex = esTreeNode.regex;
+        return super.parseNode(esTreeNode);
+    }
+    render(code) {
+        if (typeof this.value === 'string') {
+            code.indentExclusionRanges.push([this.start + 1, this.end - 1]);
+        }
+    }
+}
+function getChainElementLiteralValueAtPath(element, object, path, recursionTracker, origin) {
+    if ('getLiteralValueAtPathAsChainElement' in object) {
+        const calleeValue = object.getLiteralValueAtPathAsChainElement(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin);
+        if (calleeValue === IS_SKIPPED_CHAIN || (element.optional && calleeValue == null)) {
+            return IS_SKIPPED_CHAIN;
+        }
+    }
+    else if (element.optional &&
+        object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null) {
+        return IS_SKIPPED_CHAIN;
+    }
+    return element.getLiteralValueAtPath(path, recursionTracker, origin);
+}
+// To avoid infinite recursions
+const MAX_PATH_DEPTH = 7;
+function getResolvablePropertyKey(memberExpression) {
+    return memberExpression.computed
+        ? getResolvableComputedPropertyKey(memberExpression.property)
+        : memberExpression.property.name;
+}
+function getResolvableComputedPropertyKey(propertyKey) {
+    if (propertyKey instanceof Literal) {
+        return String(propertyKey.value);
+    }
+    return null;
+}
+function getPathIfNotComputed(memberExpression) {
+    const nextPathKey = memberExpression.propertyKey;
+    const object = memberExpression.object;
+    if (typeof nextPathKey === 'string') {
+        if (object instanceof Identifier) {
+            return [
+                { key: object.name, pos: object.start },
+                { key: nextPathKey, pos: memberExpression.property.start }
+            ];
+        }
+        if (object instanceof MemberExpression) {
+            const parentPath = getPathIfNotComputed(object);
+            return (parentPath && [...parentPath, { key: nextPathKey, pos: memberExpression.property.start }]);
+        }
+    }
+    return null;
+}
+function getStringFromPath(path) {
+    let pathString = path[0].key;
+    for (let index = 1; index < path.length; index++) {
+        pathString += '.' + path[index].key;
+    }
+    return pathString;
+}
+class MemberExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.expressionsToBeDeoptimized = [];
+    }
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    get optional() {
+        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
+    set optional(value) {
+        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
+    get assignmentDeoptimized() {
+        return isFlagSet(this.flags, 16 /* Flag.assignmentDeoptimized */);
+    }
+    set assignmentDeoptimized(value) {
+        this.flags = setFlag(this.flags, 16 /* Flag.assignmentDeoptimized */, value);
+    }
+    get bound() {
+        return isFlagSet(this.flags, 32 /* Flag.bound */);
+    }
+    set bound(value) {
+        this.flags = setFlag(this.flags, 32 /* Flag.bound */, value);
+    }
+    get isUndefined() {
+        return isFlagSet(this.flags, 64 /* Flag.isUndefined */);
+    }
+    set isUndefined(value) {
+        this.flags = setFlag(this.flags, 64 /* Flag.isUndefined */, value);
+    }
+    bind() {
+        this.bound = true;
+        const path = getPathIfNotComputed(this);
+        const baseVariable = path && this.scope.findVariable(path[0].key);
+        if (baseVariable?.isNamespace) {
+            const resolvedVariable = resolveNamespaceVariables(baseVariable, path.slice(1), this.scope.context);
+            if (!resolvedVariable) {
+                super.bind();
+            }
+            else if (resolvedVariable === 'undefined') {
+                this.isUndefined = true;
+            }
+            else {
+                this.variable = resolvedVariable;
+                this.scope.addNamespaceMemberAccess(getStringFromPath(path), resolvedVariable);
+            }
+        }
+        else {
+            super.bind();
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (this.variable) {
+            this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        }
+        else if (!this.isUndefined) {
+            if (path.length < MAX_PATH_DEPTH) {
+                this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.getPropertyKey(), ...path], recursionTracker);
+            }
+            else {
+                deoptimizeInteraction(interaction);
+            }
+        }
+    }
+    deoptimizeCache() {
+        const { expressionsToBeDeoptimized, object } = this;
+        this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+        this.propertyKey = UnknownKey;
+        object.deoptimizePath(UNKNOWN_PATH);
+        for (const expression of expressionsToBeDeoptimized) {
+            expression.deoptimizeCache();
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0)
+            this.disallowNamespaceReassignment();
+        if (this.variable) {
+            this.variable.deoptimizePath(path);
+        }
+        else if (!this.isUndefined && path.length < MAX_PATH_DEPTH) {
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizePath([
+                propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
+                ...path
+            ]);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return undefined;
+        }
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getLiteralValueAtPath([this.getPropertyKey(), ...path], recursionTracker, origin);
+        }
+        return UnknownValue;
+    }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return undefined;
+        }
+        return getChainElementLiteralValueAtPath(this, this.object, path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return [UNDEFINED_EXPRESSION, false];
+        }
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], interaction, recursionTracker, origin);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            this.hasAccessEffect(context));
+    }
+    hasEffectsAsChainElement(context) {
+        if (this.variable || this.isUndefined)
+            return this.hasEffects(context);
+        const objectHasEffects = 'hasEffectsAsChainElement' in this.object
+            ? this.object.hasEffectsAsChainElement(context)
+            : this.object.hasEffects(context);
+        if (objectHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return objectHasEffects || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return objectHasEffects || this.property.hasEffects(context) || this.hasAccessEffect(context);
+    }
+    hasEffectsAsAssignmentTarget(context, checkAccess) {
+        if (checkAccess && !this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            (checkAccess && this.hasAccessEffect(context)) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.variable) {
+            return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        if (this.isUndefined) {
+            return true;
+        }
+        if (path.length < MAX_PATH_DEPTH) {
+            return this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey(), ...path], interaction, context);
+        }
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.includeProperties(context, includeChildrenRecursively);
+    }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, deoptimizeAccess) {
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        if (deoptimizeAccess) {
+            this.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.includeProperties(context, includeChildrenRecursively);
+        }
+    }
+    includeCallArguments(context, parameters) {
+        if (this.variable) {
+            this.variable.includeCallArguments(context, parameters);
+        }
+        else {
+            super.includeCallArguments(context, parameters);
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.propertyKey = getResolvablePropertyKey(this);
+        this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
+    }
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = parseAst_js.BLANK) {
+        if (this.variable || this.isUndefined) {
+            const { snippets: { getPropertyAccess } } = options;
+            let replacement = this.variable ? this.variable.getName(getPropertyAccess) : 'undefined';
+            if (renderedParentType && isCalleeOfRenderedParent)
+                replacement = '0, ' + replacement;
+            code.overwrite(this.start, this.end, replacement, {
+                contentOnly: true,
+                storeName: true
+            });
+        }
+        else {
+            if (renderedParentType && isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+            this.object.render(code, options, { renderedSurroundingElement });
+            this.property.render(code, options);
+        }
+    }
+    setAssignedValue(value) {
+        this.assignmentInteraction = {
+            args: [this.object, value],
+            type: INTERACTION_ASSIGNED
+        };
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        if (
+        // Namespaces are not bound and should not be deoptimized
+        this.bound &&
+            propertyReadSideEffects &&
+            !(this.variable || this.isUndefined)) {
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [propertyKey], SHARED_RECURSION_TRACKER);
+            this.scope.context.requestTreeshakingPass();
+        }
+        if (this.variable) {
+            this.variable.addUsedPlace(this);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    applyAssignmentDeoptimization() {
+        this.assignmentDeoptimized = true;
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        if (
+        // Namespaces are not bound and should not be deoptimized
+        this.bound &&
+            propertyReadSideEffects &&
+            !(this.variable || this.isUndefined)) {
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.assignmentInteraction, [this.getPropertyKey()], SHARED_RECURSION_TRACKER);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    disallowNamespaceReassignment() {
+        if (this.object instanceof Identifier) {
+            const variable = this.scope.findVariable(this.object.name);
+            if (variable.isNamespace) {
+                if (this.variable) {
+                    this.scope.context.includeVariableInModule(this.variable);
+                }
+                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logIllegalImportReassignment(this.object.name, this.scope.context.module.id), this.start);
+            }
+        }
+    }
+    getPropertyKey() {
+        if (this.propertyKey === null) {
+            this.propertyKey = UnknownKey;
+            const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return (this.propertyKey =
+                value === SymbolToStringTag
+                    ? value
+                    : typeof value === 'symbol'
+                        ? UnknownKey
+                        : String(value));
+        }
+        return this.propertyKey;
+    }
+    hasAccessEffect(context) {
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        return (!(this.variable || this.isUndefined) &&
+            propertyReadSideEffects &&
+            (propertyReadSideEffects === 'always' ||
+                this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey()], this.accessInteraction, context)));
+    }
+    includeProperties(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            if (this.variable) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+        this.object.include(context, includeChildrenRecursively);
+        this.property.include(context, includeChildrenRecursively);
+    }
+}
+function resolveNamespaceVariables(baseVariable, path, astContext) {
+    if (path.length === 0)
+        return baseVariable;
+    if (!baseVariable.isNamespace || baseVariable instanceof ExternalVariable)
+        return null;
+    const exportName = path[0].key;
+    const variable = baseVariable.context.traceExport(exportName);
+    if (!variable) {
+        if (path.length === 1) {
+            const fileName = baseVariable.context.fileName;
+            astContext.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
+            return 'undefined';
+        }
+        return null;
+    }
+    return resolveNamespaceVariables(variable, path.slice(1), astContext);
+}
+const FILE_PREFIX = 'ROLLUP_FILE_URL_';
+const IMPORT = 'import';
+class MetaProperty extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.metaProperty = null;
+        this.preliminaryChunkId = null;
+        this.referenceId = null;
+    }
+    getReferencedFileName(outputPluginDriver) {
+        const { meta: { name }, metaProperty } = this;
+        if (name === IMPORT && metaProperty?.startsWith(FILE_PREFIX)) {
+            return outputPluginDriver.getFileName(metaProperty.slice(FILE_PREFIX.length));
+        }
+        return null;
+    }
+    hasEffects() {
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type !== INTERACTION_ACCESSED;
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            if (this.meta.name === IMPORT) {
+                this.scope.context.addImportMeta(this);
+                const parent = this.parent;
+                const metaProperty = (this.metaProperty =
+                    parent instanceof MemberExpression && typeof parent.propertyKey === 'string'
+                        ? parent.propertyKey
+                        : null);
+                if (metaProperty?.startsWith(FILE_PREFIX)) {
+                    this.referenceId = metaProperty.slice(FILE_PREFIX.length);
+                }
+            }
+        }
+    }
+    render(code, renderOptions) {
+        const { format, pluginDriver, snippets } = renderOptions;
+        const { scope: { context: { module } }, meta: { name }, metaProperty, parent, preliminaryChunkId, referenceId, start, end } = this;
+        const { id: moduleId } = module;
+        if (name !== IMPORT)
+            return;
+        const chunkId = preliminaryChunkId;
+        if (referenceId) {
+            const fileName = pluginDriver.getFileName(referenceId);
+            const relativePath = parseAst_js.normalize(path.relative(path.dirname(chunkId), fileName));
+            const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
+                { chunkId, fileName, format, moduleId, referenceId, relativePath }
+            ]) || relativeUrlMechanisms[format](relativePath);
+            code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
+            return;
+        }
+        let replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
+            metaProperty,
+            { chunkId, format, moduleId }
+        ]);
+        if (!replacement) {
+            replacement = importMetaMechanisms[format]?.(metaProperty, { chunkId, snippets });
+            renderOptions.accessedDocumentCurrentScript ||=
+                formatsMaybeAccessDocumentCurrentScript.includes(format) && replacement !== 'undefined';
+        }
+        if (typeof replacement === 'string') {
+            if (parent instanceof MemberExpression) {
+                code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
+            }
+            else {
+                code.overwrite(start, end, replacement, { contentOnly: true });
+            }
+        }
+    }
+    setResolution(format, accessedGlobalsByScope, preliminaryChunkId) {
+        this.preliminaryChunkId = preliminaryChunkId;
+        const accessedGlobals = (this.metaProperty?.startsWith(FILE_PREFIX) ? accessedFileUrlGlobals : accessedMetaUrlGlobals)[format];
+        if (accessedGlobals.length > 0) {
+            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
+        }
+    }
+}
+const formatsMaybeAccessDocumentCurrentScript = ['cjs', 'iife', 'umd'];
+const accessedMetaUrlGlobals = {
+    amd: ['document', 'module', 'URL'],
+    cjs: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT],
+    es: [],
+    iife: ['document', 'URL', DOCUMENT_CURRENT_SCRIPT],
+    system: ['module'],
+    umd: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT]
+};
+const accessedFileUrlGlobals = {
+    amd: ['document', 'require', 'URL'],
+    cjs: ['document', 'require', 'URL'],
+    es: [],
+    iife: ['document', 'URL'],
+    system: ['module', 'URL'],
+    umd: ['document', 'require', 'URL']
+};
+const getResolveUrl = (path, URL = 'URL') => `new ${URL}(${path}).href`;
+const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${escapeId(relativePath)}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ''}document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || document.baseURI`);
+const getGenericImportMetaMechanism = (getUrl) => (property, { chunkId }) => {
+    const urlMechanism = getUrl(chunkId);
+    return property === null
+        ? `({ url: ${urlMechanism} })`
+        : property === 'url'
+            ? urlMechanism
+            : 'undefined';
+};
+const getFileUrlFromFullPath = (path) => `require('u' + 'rl').pathToFileURL(${path}).href`;
+const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${escapeId(path)}'`);
+const getUrlFromDocument = (chunkId, umd = false) => `${umd ? `typeof document === 'undefined' ? location.href : ` : ''}(${DOCUMENT_CURRENT_SCRIPT} && ${DOCUMENT_CURRENT_SCRIPT}.tagName.toUpperCase() === 'SCRIPT' && ${DOCUMENT_CURRENT_SCRIPT}.src || new URL('${escapeId(chunkId)}', document.baseURI).href)`;
+const relativeUrlMechanisms = {
+    amd: relativePath => {
+        if (relativePath[0] !== '.')
+            relativePath = './' + relativePath;
+        return getResolveUrl(`require.toUrl('${escapeId(relativePath)}'), document.baseURI`);
+    },
+    cjs: relativePath => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath)})`,
+    es: relativePath => getResolveUrl(`'${escapeId(relativePath)}', import.meta.url`),
+    iife: relativePath => getRelativeUrlFromDocument(relativePath),
+    system: relativePath => getResolveUrl(`'${escapeId(relativePath)}', module.meta.url`),
+    umd: relativePath => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath, true)})`
+};
+const importMetaMechanisms = {
+    amd: getGenericImportMetaMechanism(() => getResolveUrl(`module.uri, document.baseURI`)),
+    cjs: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId)})`),
+    iife: getGenericImportMetaMechanism(chunkId => getUrlFromDocument(chunkId)),
+    system: (property, { snippets: { getPropertyAccess } }) => property === null ? `module.meta` : `module.meta${getPropertyAccess(property)}`,
+    umd: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId, true)})`)
+};
+class UndefinedVariable extends Variable {
+    constructor() {
+        super('undefined');
+    }
+    getLiteralValueAtPath() {
+        return undefined;
+    }
+}
+class ExportDefaultVariable extends LocalVariable {
+    constructor(name, exportDefaultDeclaration, context) {
+        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, 'other');
+        this.hasId = false;
+        this.originalId = null;
+        this.originalVariable = null;
+        const declaration = exportDefaultDeclaration.declaration;
+        if ((declaration instanceof FunctionDeclaration || declaration instanceof ClassDeclaration) &&
+            declaration.id) {
+            this.hasId = true;
+            this.originalId = declaration.id;
+        }
+        else if (declaration instanceof Identifier) {
+            this.originalId = declaration;
+        }
+    }
+    addReference(identifier) {
+        if (!this.hasId) {
+            this.name = identifier.name;
+        }
+    }
+    addUsedPlace(usedPlace) {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            super.addUsedPlace(usedPlace);
+        }
+        else {
+            original.addUsedPlace(usedPlace);
+        }
+    }
+    forbidName(name) {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            super.forbidName(name);
+        }
+        else {
+            original.forbidName(name);
+        }
+    }
+    getAssignedVariableName() {
+        return (this.originalId && this.originalId.name) || null;
+    }
+    getBaseVariableName() {
+        const original = this.getOriginalVariable();
+        return original === this ? super.getBaseVariableName() : original.getBaseVariableName();
+    }
+    getDirectOriginalVariable() {
+        return this.originalId &&
+            (this.hasId ||
+                !(this.originalId.isPossibleTDZ() ||
+                    this.originalId.variable.isReassigned ||
+                    this.originalId.variable instanceof UndefinedVariable ||
+                    // this avoids a circular dependency
+                    'syntheticNamespace' in this.originalId.variable))
+            ? this.originalId.variable
+            : null;
+    }
+    getName(getPropertyAccess) {
+        const original = this.getOriginalVariable();
+        return original === this
+            ? super.getName(getPropertyAccess)
+            : original.getName(getPropertyAccess);
+    }
+    getOriginalVariable() {
+        if (this.originalVariable)
+            return this.originalVariable;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let original = this;
+        let currentVariable;
+        const checkedVariables = new Set();
+        do {
+            checkedVariables.add(original);
+            currentVariable = original;
+            original = currentVariable.getDirectOriginalVariable();
+        } while (original instanceof ExportDefaultVariable && !checkedVariables.has(original));
+        return (this.originalVariable = original || currentVariable);
+    }
+}
+class NamespaceVariable extends Variable {
+    constructor(context) {
+        super(context.getModuleName());
+        this.memberVariables = null;
+        this.mergedNamespaces = [];
+        this.referencedEarly = false;
+        this.references = [];
+        this.context = context;
+        this.module = context.module;
+    }
+    addReference(identifier) {
+        this.references.push(identifier);
+        this.name = identifier.name;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (path.length > 1 || (path.length === 1 && interaction.type === INTERACTION_CALLED)) {
+            const key = path[0];
+            if (typeof key === 'string') {
+                this.getMemberVariables()[key]?.deoptimizeArgumentsOnInteractionAtPath(interaction, path.slice(1), recursionTracker);
+            }
+            else {
+                deoptimizeInteraction(interaction);
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length > 1) {
+            const key = path[0];
+            if (typeof key === 'string') {
+                this.getMemberVariables()[key]?.deoptimizePath(path.slice(1));
+            }
+        }
+    }
+    getLiteralValueAtPath(path) {
+        if (path[0] === SymbolToStringTag) {
+            return 'Module';
+        }
+        return UnknownValue;
+    }
+    getMemberVariables() {
+        if (this.memberVariables) {
+            return this.memberVariables;
+        }
+        const memberVariables = Object.create(null);
+        const sortedExports = [...this.context.getExports(), ...this.context.getReexports()].sort();
+        for (const name of sortedExports) {
+            if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
+                const exportedVariable = this.context.traceExport(name);
+                if (exportedVariable) {
+                    memberVariables[name] = exportedVariable;
+                }
+            }
+        }
+        return (this.memberVariables = memberVariables);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (path.length === 0) {
+            // This can only be a call anyway
+            return true;
+        }
+        if (path.length === 1 && type !== INTERACTION_CALLED) {
+            return type === INTERACTION_ASSIGNED;
+        }
+        const key = path[0];
+        if (typeof key !== 'string') {
+            return true;
+        }
+        const memberVariable = this.getMemberVariables()[key];
+        return (!memberVariable ||
+            memberVariable.hasEffectsOnInteractionAtPath(path.slice(1), interaction, context));
+    }
+    include() {
+        super.include();
+        this.context.includeAllExports();
+    }
+    prepare(accessedGlobalsByScope) {
+        if (this.mergedNamespaces.length > 0) {
+            this.module.scope.addAccessedGlobals([MERGE_NAMESPACES_VARIABLE], accessedGlobalsByScope);
+        }
+    }
+    renderBlock(options) {
+        const { exportNamesByVariable, format, freeze, indent: t, symbols, snippets: { _, cnst, getObject, getPropertyAccess, n, s } } = options;
+        const memberVariables = this.getMemberVariables();
+        const members = Object.entries(memberVariables)
+            .filter(([_, variable]) => variable.included)
+            .map(([name, variable]) => {
+            if (this.referencedEarly || variable.isReassigned || variable === this) {
+                return [
+                    null,
+                    `get ${stringifyObjectKeyIfNeeded(name)}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
+                ];
+            }
+            return [name, variable.getName(getPropertyAccess)];
+        });
+        members.unshift([null, `__proto__:${_}null`]);
+        let output = getObject(members, { lineBreakIndent: { base: '', t } });
+        if (this.mergedNamespaces.length > 0) {
+            const assignmentArguments = this.mergedNamespaces.map(variable => variable.getName(getPropertyAccess));
+            output = `/*#__PURE__*/${MERGE_NAMESPACES_VARIABLE}(${output},${_}[${assignmentArguments.join(`,${_}`)}])`;
+        }
+        else {
+            // The helper to merge namespaces will also take care of freezing and toStringTag
+            if (symbols) {
+                output = `/*#__PURE__*/Object.defineProperty(${output},${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)})`;
+            }
+            if (freeze) {
+                output = `/*#__PURE__*/Object.freeze(${output})`;
+            }
+        }
+        const name = this.getName(getPropertyAccess);
+        output = `${cnst} ${name}${_}=${_}${output};`;
+        if (format === 'system' && exportNamesByVariable.has(this)) {
+            output += `${n}${getSystemExportStatement([this], options)};`;
+        }
+        return output;
+    }
+    renderFirst() {
+        return this.referencedEarly;
+    }
+    setMergedNamespaces(mergedNamespaces) {
+        this.mergedNamespaces = mergedNamespaces;
+        const moduleExecIndex = this.context.getModuleExecIndex();
+        for (const identifier of this.references) {
+            const { context } = identifier.scope;
+            if (context.getModuleExecIndex() <= moduleExecIndex) {
+                this.referencedEarly = true;
+                break;
+            }
+        }
+    }
+}
+NamespaceVariable.prototype.isNamespace = true;
+class SyntheticNamedExportVariable extends Variable {
+    constructor(context, name, syntheticNamespace) {
+        super(name);
+        this.baseVariable = null;
+        this.context = context;
+        this.module = context.module;
+        this.syntheticNamespace = syntheticNamespace;
+    }
+    getBaseVariable() {
+        if (this.baseVariable)
+            return this.baseVariable;
+        let baseVariable = this.syntheticNamespace;
+        while (baseVariable instanceof ExportDefaultVariable ||
+            baseVariable instanceof SyntheticNamedExportVariable) {
+            if (baseVariable instanceof ExportDefaultVariable) {
+                const original = baseVariable.getOriginalVariable();
+                if (original === baseVariable)
+                    break;
+                baseVariable = original;
+            }
+            if (baseVariable instanceof SyntheticNamedExportVariable) {
+                baseVariable = baseVariable.syntheticNamespace;
+            }
+        }
+        return (this.baseVariable = baseVariable);
+    }
+    getBaseVariableName() {
+        return this.syntheticNamespace.getBaseVariableName();
+    }
+    getName(getPropertyAccess) {
+        return `${this.syntheticNamespace.getName(getPropertyAccess)}${getPropertyAccess(this.name)}`;
+    }
+    include() {
+        super.include();
+        this.context.includeVariableInModule(this.syntheticNamespace);
+    }
+    setRenderNames(baseName, name) {
+        super.setRenderNames(baseName, name);
+    }
+}
+class ExternalChunk {
+    constructor(module, options, inputBase) {
+        this.options = options;
+        this.inputBase = inputBase;
+        this.defaultVariableName = '';
+        this.namespaceVariableName = '';
+        this.variableName = '';
+        this.fileName = null;
+        this.importAttributes = null;
+        this.id = module.id;
+        this.moduleInfo = module.info;
+        this.renormalizeRenderPath = module.renormalizeRenderPath;
+        this.suggestedVariableName = module.suggestedVariableName;
+    }
+    getFileName() {
+        if (this.fileName) {
+            return this.fileName;
+        }
+        const { paths } = this.options;
+        return (this.fileName =
+            (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
+                (this.renormalizeRenderPath ? parseAst_js.normalize(path.relative(this.inputBase, this.id)) : this.id));
+    }
+    getImportAttributes(snippets) {
+        return (this.importAttributes ||= formatAttributes(this.options.format === 'es' &&
+            this.options.externalImportAttributes &&
+            this.moduleInfo.attributes, snippets));
+    }
+    getImportPath(importer) {
+        return escapeId(this.renormalizeRenderPath
+            ? parseAst_js.getImportPath(importer, this.getFileName(), this.options.format === 'amd', false)
+            : this.getFileName());
+    }
+}
+function formatAttributes(attributes, { getObject }) {
+    if (!attributes) {
+        return null;
+    }
+    const assertionEntries = Object.entries(attributes).map(([key, value]) => [key, `'${value}'`]);
+    if (assertionEntries.length > 0) {
+        return getObject(assertionEntries, { lineBreakIndent: null });
+    }
+    return null;
+}
+function removeJsExtension(name) {
+    return name.endsWith('.js') ? name.slice(0, -3) : name;
+}
+function getCompleteAmdId(options, chunkId) {
+    if (options.autoId) {
+        return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
+    }
+    return options.id ?? '';
+}
+function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, mechanism = 'return ') {
+    const { _, getDirectReturnFunction, getFunctionIntro, getPropertyAccess, n, s } = snippets;
+    if (!namedExportsMode) {
+        return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess)};`;
+    }
+    let exportBlock = '';
+    if (namedExportsMode) {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
+            for (const specifier of reexports) {
+                if (specifier.reexported !== '*') {
+                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+                    if (exportBlock)
+                        exportBlock += n;
+                    if (specifier.imported !== '*' && specifier.needsLiveBinding) {
+                        const [left, right] = getDirectReturnFunction([], {
+                            functionReturn: true,
+                            lineBreakIndent: null,
+                            name: null
+                        });
+                        exportBlock +=
+                            `Object.defineProperty(exports,${_}${JSON.stringify(specifier.reexported)},${_}{${n}` +
+                                `${t}enumerable:${_}true,${n}` +
+                                `${t}get:${_}${left}${importName}${right}${n}});`;
+                    }
+                    else if (specifier.reexported === '__proto__') {
+                        exportBlock +=
+                            `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
+                                `${t}enumerable:${_}true,${n}` +
+                                `${t}value:${_}${importName}${n}});`;
+                    }
+                    else {
+                        exportBlock += `exports${getPropertyAccess(specifier.reexported)}${_}=${_}${importName};`;
+                    }
+                }
+            }
+        }
+    }
+    for (const { exported, local } of exports) {
+        const lhs = `exports${getPropertyAccess(exported)}`;
+        const rhs = local;
+        if (lhs !== rhs) {
+            if (exportBlock)
+                exportBlock += n;
+            exportBlock +=
+                exported === '__proto__'
+                    ? `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
+                        `${t}enumerable:${_}true,${n}` +
+                        `${t}value:${_}${rhs}${n}});`
+                    : `${lhs}${_}=${_}${rhs};`;
+        }
+    }
+    if (namedExportsMode) {
+        for (const { name, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    if (exportBlock)
+                        exportBlock += n;
+                    if (!specifier.needsLiveBinding && reexportProtoFromExternal) {
+                        const protoString = "'__proto__'";
+                        exportBlock +=
+                            `Object.prototype.hasOwnProperty.call(${name},${_}${protoString})${_}&&${n}` +
+                                `${t}!Object.prototype.hasOwnProperty.call(exports,${_}${protoString})${_}&&${n}` +
+                                `${t}Object.defineProperty(exports,${_}${protoString},${_}{${n}` +
+                                `${t}${t}enumerable:${_}true,${n}` +
+                                `${t}${t}value:${_}${name}[${protoString}]${n}` +
+                                `${t}});${n}${n}`;
+                    }
+                    const copyPropertyIfNecessary = `{${n}${t}if${_}(k${_}!==${_}'default'${_}&&${_}!Object.prototype.hasOwnProperty.call(exports,${_}k))${_}${getDefineProperty(name, specifier.needsLiveBinding, t, snippets)}${s}${n}}`;
+                    exportBlock += `Object.keys(${name}).forEach(${getFunctionIntro(['k'], {
+                        isAsync: false,
+                        name: null
+                    })}${copyPropertyIfNecessary});`;
+                }
+            }
+        }
+    }
+    if (exportBlock) {
+        return `${n}${n}${exportBlock}`;
+    }
+    return '';
+}
+function getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess) {
+    if (exports.length > 0) {
+        return exports[0].local;
+    }
+    else {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (reexports) {
+                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+            }
+        }
+    }
+}
+function getReexportedImportName(moduleVariableName, imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings, getPropertyAccess) {
+    if (imported === 'default') {
+        if (!isChunk) {
+            const moduleInterop = interop(moduleId);
+            const variableName = defaultInteropHelpersByInteropType[moduleInterop]
+                ? defaultVariableName
+                : moduleVariableName;
+            return isDefaultAProperty(moduleInterop, externalLiveBindings)
+                ? `${variableName}${getPropertyAccess('default')}`
+                : variableName;
+        }
+        return depNamedExportsMode
+            ? `${moduleVariableName}${getPropertyAccess('default')}`
+            : moduleVariableName;
+    }
+    if (imported === '*') {
+        return (isChunk ? !depNamedExportsMode : namespaceInteropHelpersByInteropType[interop(moduleId)])
+            ? namespaceVariableName
+            : moduleVariableName;
+    }
+    return `${moduleVariableName}${getPropertyAccess(imported)}`;
+}
+function getEsModuleValue(getObject) {
+    return getObject([['value', 'true']], {
+        lineBreakIndent: null
+    });
+}
+function getNamespaceMarkers(hasNamedExports, addEsModule, addNamespaceToStringTag, { _, getObject }) {
+    if (hasNamedExports) {
+        if (addEsModule) {
+            if (addNamespaceToStringTag) {
+                return `Object.defineProperties(exports,${_}${getObject([
+                    ['__esModule', getEsModuleValue(getObject)],
+                    [null, `[Symbol.toStringTag]:${_}${getToStringTagValue(getObject)}`]
+                ], {
+                    lineBreakIndent: null
+                })});`;
+            }
+            return `Object.defineProperty(exports,${_}'__esModule',${_}${getEsModuleValue(getObject)});`;
+        }
+        if (addNamespaceToStringTag) {
+            return `Object.defineProperty(exports,${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)});`;
+        }
+    }
+    return '';
+}
+const getDefineProperty = (name, needsLiveBinding, t, { _, getDirectReturnFunction, n }) => {
+    if (needsLiveBinding) {
+        const [left, right] = getDirectReturnFunction([], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: null
+        });
+        return (`Object.defineProperty(exports,${_}k,${_}{${n}` +
+            `${t}${t}enumerable:${_}true,${n}` +
+            `${t}${t}get:${_}${left}${name}[k]${right}${n}${t}})`);
+    }
+    return `exports[k]${_}=${_}${name}[k]`;
+};
+function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, indent, snippets) {
+    const { _, cnst, n } = snippets;
+    const neededInteropHelpers = new Set();
+    const interopStatements = [];
+    const addInteropStatement = (helperVariableName, helper, dependencyVariableName) => {
+        neededInteropHelpers.add(helper);
+        interopStatements.push(`${cnst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`);
+    };
+    for (const { defaultVariableName, imports, importPath, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        if (isChunk) {
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                if (imported === '*' && reexported !== '*') {
+                    if (!namedExportsMode) {
+                        addInteropStatement(namespaceVariableName, INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE, name);
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            const moduleInterop = interop(importPath);
+            let hasDefault = false;
+            let hasNamespace = false;
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                let helper;
+                let variableName;
+                if (imported === 'default') {
+                    if (!hasDefault) {
+                        hasDefault = true;
+                        if (defaultVariableName !== namespaceVariableName) {
+                            variableName = defaultVariableName;
+                            helper = defaultInteropHelpersByInteropType[moduleInterop];
+                        }
+                    }
+                }
+                else if (imported === '*' && reexported !== '*' && !hasNamespace) {
+                    hasNamespace = true;
+                    helper = namespaceInteropHelpersByInteropType[moduleInterop];
+                    variableName = namespaceVariableName;
+                }
+                if (helper) {
+                    addInteropStatement(variableName, helper, name);
+                }
+            }
+        }
+    }
+    return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, indent, snippets, externalLiveBindings, freeze, symbols)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
+}
+function addJsExtension(name) {
+    return name.endsWith('.js') ? name : name + '.js';
+}
+// AMD resolution will only respect the AMD baseUrl if the .js extension is omitted.
+// The assumption is that this makes sense for all relative ids:
+// https://requirejs.org/docs/api.html#jsfiles
+function updateExtensionForRelativeAmdId(id, forceJsExtensionForImports) {
+    if (id[0] !== '.') {
+        return id;
+    }
+    return forceJsExtensionForImports ? addJsExtension(id) : removeJsExtension(id);
+}
+const builtinModules = [
+        "assert",
+        "assert/strict",
+        "async_hooks",
+        "buffer",
+        "child_process",
+        "cluster",
+        "console",
+        "constants",
+        "crypto",
+        "dgram",
+        "diagnostics_channel",
+        "dns",
+        "dns/promises",
+        "domain",
+        "events",
+        "fs",
+        "fs/promises",
+        "http",
+        "http2",
+        "https",
+        "inspector",
+        "inspector/promises",
+        "module",
+        "net",
+        "os",
+        "path",
+        "path/posix",
+        "path/win32",
+        "perf_hooks",
+        "process",
+        "punycode",
+        "querystring",
+        "readline",
+        "readline/promises",
+        "repl",
+        "stream",
+        "stream/consumers",
+        "stream/promises",
+        "stream/web",
+        "string_decoder",
+        "timers",
+        "timers/promises",
+        "tls",
+        "trace_events",
+        "tty",
+        "url",
+        "util",
+        "util/types",
+        "v8",
+        "vm",
+        "wasi",
+        "worker_threads",
+        "zlib"
+];
+const nodeBuiltins = new Set(builtinModules);
+function warnOnBuiltins(log, dependencies) {
+    const externalBuiltins = dependencies
+        .map(({ importPath }) => importPath)
+        .filter(importPath => nodeBuiltins.has(importPath) || importPath.startsWith('node:'));
+    if (externalBuiltins.length === 0)
+        return;
+    log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingNodeBuiltins(externalBuiltins));
+}
+function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, log, outro, snippets }, { amd, esModule, externalLiveBindings, freeze, generatedCode: { symbols }, interop, reexportProtoFromExternal, strict }) {
+    warnOnBuiltins(log, dependencies);
+    const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
+    const parameters = dependencies.map(m => m.name);
+    const { n, getNonArrowFunctionIntro, _ } = snippets;
+    if (namedExportsMode && hasExports) {
+        parameters.unshift(`exports`);
+        deps.unshift(`'exports'`);
+    }
+    if (accessedGlobals.has('require')) {
+        parameters.unshift('require');
+        deps.unshift(`'require'`);
+    }
+    if (accessedGlobals.has('module')) {
+        parameters.unshift('module');
+        deps.unshift(`'module'`);
+    }
+    const completeAmdId = getCompleteAmdId(amd, id);
+    const defineParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (deps.length > 0 ? `[${deps.join(`,${_}`)}],${_}` : ``);
+    const useStrict = strict ? `${_}'use strict';` : '';
+    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .indent(t)
+        // factory function should be wrapped by parentheses to avoid lazy parsing,
+        // cf. https://v8.dev/blog/preparser#pife
+        .prepend(`${amd.define}(${defineParameters}(${getNonArrowFunctionIntro(parameters, {
+        isAsync: false,
+        name: null
+    })}{${useStrict}${n}${n}`)
+        .append(`${n}${n}}));`);
+}
+function cjs(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets }, { compact, esModule, externalLiveBindings, freeze, interop, generatedCode: { symbols }, reexportProtoFromExternal, strict }) {
+    const { _, n } = snippets;
+    const useStrict = strict ? `'use strict';${n}${n}` : '';
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers += n + n;
+    }
+    const importBlock = getImportBlock$1(dependencies, snippets, compact);
+    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
+    magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, `module.exports${_}=${_}`);
+    magicString.append(`${exportBlock}${outro}`);
+}
+function getImportBlock$1(dependencies, { _, cnst, n }, compact) {
+    let importBlock = '';
+    let definingVariable = false;
+    for (const { importPath, name, reexports, imports } of dependencies) {
+        if (!reexports && !imports) {
+            if (importBlock) {
+                importBlock += compact && !definingVariable ? ',' : `;${n}`;
+            }
+            definingVariable = false;
+            importBlock += `require('${importPath}')`;
+        }
+        else {
+            importBlock += compact && definingVariable ? ',' : `${importBlock ? `;${n}` : ''}${cnst} `;
+            definingVariable = true;
+            importBlock += `${name}${_}=${_}require('${importPath}')`;
+        }
+    }
+    if (importBlock) {
+        return `${importBlock};${n}${n}`;
+    }
+    return '';
+}
+function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencies, exports, snippets }, { externalLiveBindings, freeze, generatedCode: { symbols }, importAttributesKey }) {
+    const { n } = snippets;
+    const importBlock = getImportBlock(dependencies, importAttributesKey, snippets);
+    if (importBlock.length > 0)
+        intro += importBlock.join(n) + n + n;
+    intro += getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols);
+    if (intro)
+        magicString.prepend(intro);
+    const exportBlock = getExportBlock(exports, snippets);
+    if (exportBlock.length > 0)
+        magicString.append(n + n + exportBlock.join(n).trim());
+    if (outro)
+        magicString.append(outro);
+    magicString.trim();
+}
+function getImportBlock(dependencies, importAttributesKey, { _ }) {
+    const importBlock = [];
+    for (const { importPath, reexports, imports, name, attributes } of dependencies) {
+        const assertion = attributes ? `${_}${importAttributesKey}${_}${attributes}` : '';
+        const pathWithAssertion = `'${importPath}'${assertion};`;
+        if (!reexports && !imports) {
+            importBlock.push(`import${_}${pathWithAssertion}`);
+            continue;
+        }
+        if (imports) {
+            let defaultImport = null;
+            let starImport = null;
+            const importedNames = [];
+            for (const specifier of imports) {
+                if (specifier.imported === 'default') {
+                    defaultImport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    starImport = specifier;
+                }
+                else {
+                    importedNames.push(specifier);
+                }
+            }
+            if (starImport) {
+                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}${pathWithAssertion}`);
+            }
+            if (defaultImport && importedNames.length === 0) {
+                importBlock.push(`import ${defaultImport.local} from${_}${pathWithAssertion}`);
+            }
+            else if (importedNames.length > 0) {
+                importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
+                    .map(specifier => specifier.imported === specifier.local
+                    ? specifier.imported
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${specifier.local}`)
+                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
+        if (reexports) {
+            let starExport = null;
+            const namespaceReexports = [];
+            const namedReexports = [];
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    starExport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    namespaceReexports.push(specifier);
+                }
+                else {
+                    namedReexports.push(specifier);
+                }
+            }
+            if (starExport) {
+                importBlock.push(`export${_}*${_}from${_}${pathWithAssertion}`);
+            }
+            if (namespaceReexports.length > 0) {
+                if (!imports ||
+                    !imports.some(specifier => specifier.imported === '*' && specifier.local === name)) {
+                    importBlock.push(`import${_}*${_}as ${name} from${_}${pathWithAssertion}`);
+                }
+                for (const specifier of namespaceReexports) {
+                    importBlock.push(`export${_}{${_}${name === specifier.reexported
+                        ? name
+                        : `${name} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`} };`);
+                }
+            }
+            if (namedReexports.length > 0) {
+                importBlock.push(`export${_}{${_}${namedReexports
+                    .map(specifier => specifier.imported === specifier.reexported
+                    ? stringifyIdentifierIfNeeded(specifier.imported)
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`)
+                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
+    }
+    return importBlock;
+}
+function getExportBlock(exports, { _, cnst }) {
+    const exportBlock = [];
+    const exportDeclaration = new Array(exports.length);
+    let index = 0;
+    for (const specifier of exports) {
+        if (specifier.expression) {
+            exportBlock.push(`${cnst} ${specifier.local}${_}=${_}${specifier.expression};`);
+        }
+        exportDeclaration[index++] =
+            specifier.exported === specifier.local
+                ? specifier.local
+                : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`;
+    }
+    if (exportDeclaration.length > 0) {
+        exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
+    }
+    return exportBlock;
+}
+const keypath = (keypath, getPropertyAccess) => keypath.split('.').map(getPropertyAccess).join('');
+function setupNamespace(name, root, globals, { _, getPropertyAccess, s }, compact, log) {
+    const parts = name.split('.');
+    // Check if the key exists in the object's prototype.
+    const isReserved = parts[0] in Object.prototype;
+    if (log && isReserved) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logReservedNamespace(parts[0]));
+    }
+    parts[0] =
+        (typeof globals === 'function'
+            ? globals(parts[0])
+            : isReserved
+                ? parts[0]
+                : globals[parts[0]]) || parts[0];
+    parts.pop();
+    let propertyPath = root;
+    return (parts
+        .map(part => {
+        propertyPath += getPropertyAccess(part);
+        return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}${s}`;
+    })
+        .join(compact ? ',' : '\n') + (compact && parts.length > 0 ? ';' : '\n'));
+}
+function assignToDeepVariable(deepName, root, globals, assignment, { _, getPropertyAccess }, log) {
+    const parts = deepName.split('.');
+    // Check if the key exists in the object's prototype.
+    const isReserved = parts[0] in Object.prototype;
+    if (log && isReserved) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logReservedNamespace(parts[0]));
+    }
+    parts[0] =
+        (typeof globals === 'function'
+            ? globals(parts[0])
+            : isReserved
+                ? parts[0]
+                : globals[parts[0]]) || parts[0];
+    const last = parts.pop();
+    let propertyPath = root;
+    let deepAssignment = [
+        ...parts.map(part => {
+            propertyPath += getPropertyAccess(part);
+            return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}`;
+        }),
+        `${propertyPath}${getPropertyAccess(last)}`
+    ].join(`,${_}`) + `${_}=${_}${assignment}`;
+    if (parts.length > 0) {
+        deepAssignment = `(${deepAssignment})`;
+    }
+    return deepAssignment;
+}
+function trimEmptyImports(dependencies) {
+    let index = dependencies.length;
+    while (index--) {
+        const { imports, reexports } = dependencies[index];
+        if (imports || reexports) {
+            return dependencies.slice(0, index + 1);
+        }
+    }
+    return [];
+}
+function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, namedExportsMode, log, outro, snippets }, { compact, esModule, extend, freeze, externalLiveBindings, reexportProtoFromExternal, globals, interop, name, generatedCode: { symbols }, strict }) {
+    const { _, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
+    const isNamespaced = name && name.includes('.');
+    const useVariableAssignment = !extend && !isNamespaced;
+    if (name && useVariableAssignment && !isLegal(name)) {
+        return parseAst_js.error(parseAst_js.logIllegalIdentifierAsName(name));
+    }
+    warnOnBuiltins(log, dependencies);
+    const external = trimEmptyImports(dependencies);
+    const deps = external.map(dep => dep.globalName || 'null');
+    const parameters = external.map(m => m.name);
+    if (hasExports && !name) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingNameOptionForIifeExport());
+    }
+    if (namedExportsMode && hasExports) {
+        if (extend) {
+            deps.unshift(`this${keypath(name, getPropertyAccess)}${_}=${_}this${keypath(name, getPropertyAccess)}${_}||${_}{}`);
+            parameters.unshift('exports');
+        }
+        else {
+            deps.unshift('{}');
+            parameters.unshift('exports');
+        }
+    }
+    const useStrict = strict ? `${t}'use strict';${n}` : '';
+    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
+    magicString.prepend(`${intro}${interopBlock}`);
+    let wrapperIntro = `(${getNonArrowFunctionIntro(parameters, {
+        isAsync: false,
+        name: null
+    })}{${n}${useStrict}${n}`;
+    if (hasExports) {
+        if (name && !(extend && namedExportsMode)) {
+            wrapperIntro =
+                (useVariableAssignment ? `var ${name}` : `this${keypath(name, getPropertyAccess)}`) +
+                    `${_}=${_}${wrapperIntro}`;
+        }
+        if (isNamespaced) {
+            wrapperIntro = setupNamespace(name, 'this', globals, snippets, compact, log) + wrapperIntro;
+        }
+    }
+    let wrapperOutro = `${n}${n}})(${deps.join(`,${_}`)});`;
+    if (hasExports && !extend && namedExportsMode) {
+        wrapperOutro = `${n}${n}${t}return exports;${wrapperOutro}`;
+    }
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .indent(t)
+        .prepend(wrapperIntro)
+        .append(wrapperOutro);
+}
+const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
+function system(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, snippets, outro, usesTopLevelAwait }, { externalLiveBindings, freeze, name, generatedCode: { symbols }, strict, systemNullSetters }) {
+    const { _, getFunctionIntro, getNonArrowFunctionIntro, n, s } = snippets;
+    const { importBindings, setters, starExcludes } = analyzeDependencies(dependencies, exports, t, snippets);
+    const registeredName = name ? `'${name}',${_}` : '';
+    const wrapperParameters = accessedGlobals.has('module')
+        ? ['exports', 'module']
+        : hasExports
+            ? ['exports']
+            : [];
+    // factory function should be wrapped by parentheses to avoid lazy parsing,
+    // cf. https://v8.dev/blog/preparser#pife
+    let wrapperStart = `System.register(${registeredName}[` +
+        dependencies.map(({ importPath }) => `'${importPath}'`).join(`,${_}`) +
+        `],${_}(${getNonArrowFunctionIntro(wrapperParameters, {
+            isAsync: false,
+            name: null
+        })}{${n}${t}${strict ? "'use strict';" : ''}` +
+        getStarExcludesBlock(starExcludes, t, snippets) +
+        getImportBindingsBlock(importBindings, t, snippets) +
+        `${n}${t}return${_}{${setters.length > 0
+            ? `${n}${t}${t}setters:${_}[${setters
+                .map(setter => setter
+                ? `${getFunctionIntro(['module'], {
+                    isAsync: false,
+                    name: null
+                })}{${n}${t}${t}${t}${setter}${n}${t}${t}}`
+                : systemNullSetters
+                    ? `null`
+                    : `${getFunctionIntro([], { isAsync: false, name: null })}{}`)
+                .join(`,${_}`)}],`
+            : ''}${n}`;
+    wrapperStart += `${t}${t}execute:${_}(${getNonArrowFunctionIntro([], {
+        isAsync: usesTopLevelAwait,
+        name: null
+    })}{${n}${n}`;
+    const wrapperEnd = `${t}${t}})${n}${t}}${s}${n}}));`;
+    magicString
+        .prepend(intro +
+        getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols) +
+        getHoistedExportsBlock(exports, t, snippets))
+        .append(`${outro}${n}${n}` +
+        getSyntheticExportsBlock(exports, t, snippets) +
+        getMissingExportsBlock(exports, t, snippets))
+        .indent(`${t}${t}${t}`)
+        .append(wrapperEnd)
+        .prepend(wrapperStart);
+}
+function analyzeDependencies(dependencies, exports, t, { _, cnst, getObject, getPropertyAccess, n }) {
+    const importBindings = [];
+    const setters = [];
+    let starExcludes = null;
+    for (const { imports, reexports } of dependencies) {
+        const setter = [];
+        if (imports) {
+            for (const specifier of imports) {
+                importBindings.push(specifier.local);
+                if (specifier.imported === '*') {
+                    setter.push(`${specifier.local}${_}=${_}module;`);
+                }
+                else {
+                    setter.push(`${specifier.local}${_}=${_}module${getPropertyAccess(specifier.imported)};`);
+                }
+            }
+        }
+        if (reexports) {
+            const reexportedNames = [];
+            let hasStarReexport = false;
+            for (const { imported, reexported } of reexports) {
+                if (reexported === '*') {
+                    hasStarReexport = true;
+                }
+                else {
+                    reexportedNames.push([
+                        reexported,
+                        imported === '*' ? 'module' : `module${getPropertyAccess(imported)}`
+                    ]);
+                }
+            }
+            if (reexportedNames.length > 1 || hasStarReexport) {
+                if (hasStarReexport) {
+                    if (!starExcludes) {
+                        starExcludes = getStarExcludes({ dependencies, exports });
+                    }
+                    reexportedNames.unshift([null, `__proto__:${_}null`]);
+                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
+                    setter.push(`${cnst} setter${_}=${_}${exportMapping};`, `for${_}(${cnst} name in module)${_}{`, `${t}if${_}(!_starExcludes[name])${_}setter[name]${_}=${_}module[name];`, '}', 'exports(setter);');
+                }
+                else {
+                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
+                    setter.push(`exports(${exportMapping});`);
+                }
+            }
+            else {
+                const [key, value] = reexportedNames[0];
+                setter.push(`exports(${JSON.stringify(key)},${_}${value});`);
+            }
+        }
+        setters.push(setter.join(`${n}${t}${t}${t}`));
+    }
+    return { importBindings, setters, starExcludes };
+}
+const getStarExcludes = ({ dependencies, exports }) => {
+    const starExcludes = new Set(exports.map(expt => expt.exported));
+    starExcludes.add('default');
+    for (const { reexports } of dependencies) {
+        if (reexports) {
+            for (const reexport of reexports) {
+                if (reexport.reexported !== '*')
+                    starExcludes.add(reexport.reexported);
+            }
+        }
+    }
+    return starExcludes;
+};
+const getStarExcludesBlock = (starExcludes, t, { _, cnst, getObject, n }) => {
+    if (starExcludes) {
+        const fields = [...starExcludes].map(property => [
+            property,
+            '1'
+        ]);
+        fields.unshift([null, `__proto__:${_}null`]);
+        return `${n}${t}${cnst} _starExcludes${_}=${_}${getObject(fields, {
+            lineBreakIndent: { base: t, t }
+        })};`;
+    }
+    return '';
+};
+const getImportBindingsBlock = (importBindings, t, { _, n }) => (importBindings.length > 0 ? `${n}${t}var ${importBindings.join(`,${_}`)};` : '');
+const getHoistedExportsBlock = (exports, t, snippets) => getExportsBlock(exports.filter(expt => expt.hoisted).map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
+function getExportsBlock(exports, t, { _, n }) {
+    if (exports.length === 0) {
+        return '';
+    }
+    if (exports.length === 1) {
+        return `exports(${JSON.stringify(exports[0].name)},${_}${exports[0].value});${n}${n}`;
+    }
+    return (`exports({${n}` +
+        exports
+            .map(({ name, value }) => `${t}${stringifyObjectKeyIfNeeded(name)}:${_}${value}`)
+            .join(`,${n}`) +
+        `${n}});${n}${n}`);
+}
+const getSyntheticExportsBlock = (exports, t, snippets) => getExportsBlock(exports
+    .filter(expt => expt.expression)
+    .map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
+const getMissingExportsBlock = (exports, t, snippets) => getExportsBlock(exports
+    .filter(expt => expt.local === MISSING_EXPORT_SHIM_VARIABLE)
+    .map(expt => ({ name: expt.exported, value: MISSING_EXPORT_SHIM_VARIABLE })), t, snippets);
+function globalProperty(name, globalVariable, getPropertyAccess) {
+    if (!name)
+        return 'null';
+    return `${globalVariable}${keypath(name, getPropertyAccess)}`;
+}
+function safeAccess(name, globalVariable, { _, getPropertyAccess }) {
+    let propertyPath = globalVariable;
+    return name
+        .split('.')
+        .map(part => (propertyPath += getPropertyAccess(part)))
+        .join(`${_}&&${_}`);
+}
+function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, log, outro, snippets }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, generatedCode: { symbols }, globals, noConflict, reexportProtoFromExternal, strict }) {
+    const { _, cnst, getFunctionIntro, getNonArrowFunctionIntro, getPropertyAccess, n, s } = snippets;
+    const factoryVariable = compact ? 'f' : 'factory';
+    const globalVariable = compact ? 'g' : 'global';
+    if (hasExports && !name) {
+        return parseAst_js.error(parseAst_js.logMissingNameOptionForUmdExport());
+    }
+    warnOnBuiltins(log, dependencies);
+    const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
+    const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
+    const trimmedImports = trimEmptyImports(dependencies);
+    const globalDeps = trimmedImports.map(module => globalProperty(module.globalName, globalVariable, getPropertyAccess));
+    const factoryParameters = trimmedImports.map(m => m.name);
+    if (namedExportsMode && (hasExports || noConflict)) {
+        amdDeps.unshift(`'exports'`);
+        cjsDeps.unshift(`exports`);
+        globalDeps.unshift(assignToDeepVariable(name, globalVariable, globals, `${extend ? `${globalProperty(name, globalVariable, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets, log));
+        factoryParameters.unshift('exports');
+    }
+    const completeAmdId = getCompleteAmdId(amd, id);
+    const amdParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (amdDeps.length > 0 ? `[${amdDeps.join(`,${_}`)}],${_}` : ``);
+    const define = amd.define;
+    const cjsExport = !namedExportsMode && hasExports ? `module.exports${_}=${_}` : ``;
+    const useStrict = strict ? `${_}'use strict';${n}` : ``;
+    let iifeExport;
+    if (noConflict) {
+        const noConflictExportsVariable = compact ? 'e' : 'exports';
+        let factory;
+        if (!namedExportsMode && hasExports) {
+            factory = `${cnst} ${noConflictExportsVariable}${_}=${_}${assignToDeepVariable(name, globalVariable, globals, `${factoryVariable}(${globalDeps.join(`,${_}`)})`, snippets, log)};`;
+        }
+        else {
+            const module = globalDeps.shift();
+            factory =
+                `${cnst} ${noConflictExportsVariable}${_}=${_}${module};${n}` +
+                    `${t}${t}${factoryVariable}(${[noConflictExportsVariable, ...globalDeps].join(`,${_}`)});`;
+        }
+        iifeExport =
+            `(${getFunctionIntro([], { isAsync: false, name: null })}{${n}` +
+                `${t}${t}${cnst} current${_}=${_}${safeAccess(name, globalVariable, snippets)};${n}` +
+                `${t}${t}${factory}${n}` +
+                `${t}${t}${noConflictExportsVariable}.noConflict${_}=${_}${getFunctionIntro([], {
+                    isAsync: false,
+                    name: null
+                })}{${_}` +
+                `${globalProperty(name, globalVariable, getPropertyAccess)}${_}=${_}current;${_}return ${noConflictExportsVariable}${s}${_}};${n}` +
+                `${t}})()`;
+    }
+    else {
+        iifeExport = `${factoryVariable}(${globalDeps.join(`,${_}`)})`;
+        if (!namedExportsMode && hasExports) {
+            iifeExport = assignToDeepVariable(name, globalVariable, globals, iifeExport, snippets, log);
+        }
+    }
+    const iifeNeedsGlobal = hasExports || (noConflict && namedExportsMode) || globalDeps.length > 0;
+    const wrapperParameters = [factoryVariable];
+    if (iifeNeedsGlobal) {
+        wrapperParameters.unshift(globalVariable);
+    }
+    const globalArgument = iifeNeedsGlobal ? `this,${_}` : '';
+    const iifeStart = iifeNeedsGlobal
+        ? `(${globalVariable}${_}=${_}typeof globalThis${_}!==${_}'undefined'${_}?${_}globalThis${_}:${_}${globalVariable}${_}||${_}self,${_}`
+        : '';
+    const iifeEnd = iifeNeedsGlobal ? ')' : '';
+    const cjsIntro = iifeNeedsGlobal
+        ? `${t}typeof exports${_}===${_}'object'${_}&&${_}typeof module${_}!==${_}'undefined'${_}?` +
+            `${_}${cjsExport}${factoryVariable}(${cjsDeps.join(`,${_}`)})${_}:${n}`
+        : '';
+    const wrapperIntro = `(${getNonArrowFunctionIntro(wrapperParameters, { isAsync: false, name: null })}{${n}` +
+        cjsIntro +
+        `${t}typeof ${define}${_}===${_}'function'${_}&&${_}${define}.amd${_}?${_}${define}(${amdParameters}${factoryVariable})${_}:${n}` +
+        `${t}${iifeStart}${iifeExport}${iifeEnd};${n}` +
+        // factory function should be wrapped by parentheses to avoid lazy parsing,
+        // cf. https://v8.dev/blog/preparser#pife
+        `})(${globalArgument}(${getNonArrowFunctionIntro(factoryParameters, {
+            isAsync: false,
+            name: null
+        })}{${useStrict}${n}`;
+    const wrapperOutro = n + n + '}));';
+    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .trim()
+        .indent(t)
+        .append(wrapperOutro)
+        .prepend(wrapperIntro);
+}
+const finalisers = { amd, cjs, es, iife, system, umd };
+function getDefaultExportFromCjs (x) {
+        return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+        if (typeof f == "function") {
+                var a = function a () {
+                        if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+                        }
+                        return f.apply(this, arguments);
+                };
+                a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+        Object.keys(n).forEach(function (k) {
+                var d = Object.getOwnPropertyDescriptor(n, k);
+                Object.defineProperty(a, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () {
+                                return n[k];
+                        }
+                });
+        });
+        return a;
+}
+var utils = {};
+var constants;
+var hasRequiredConstants;
+function requireConstants () {
+        if (hasRequiredConstants) return constants;
+        hasRequiredConstants = 1;
+        const WIN_SLASH = '\\\\/';
+        const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+        /**
+         * Posix glob regex
+         */
+        const DOT_LITERAL = '\\.';
+        const PLUS_LITERAL = '\\+';
+        const QMARK_LITERAL = '\\?';
+        const SLASH_LITERAL = '\\/';
+        const ONE_CHAR = '(?=.)';
+        const QMARK = '[^/]';
+        const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+        const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+        const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+        const NO_DOT = `(?!${DOT_LITERAL})`;
+        const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+        const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+        const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+        const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+        const STAR = `${QMARK}*?`;
+        const SEP = '/';
+        const POSIX_CHARS = {
+          DOT_LITERAL,
+          PLUS_LITERAL,
+          QMARK_LITERAL,
+          SLASH_LITERAL,
+          ONE_CHAR,
+          QMARK,
+          END_ANCHOR,
+          DOTS_SLASH,
+          NO_DOT,
+          NO_DOTS,
+          NO_DOT_SLASH,
+          NO_DOTS_SLASH,
+          QMARK_NO_DOT,
+          STAR,
+          START_ANCHOR,
+          SEP
+        };
+        /**
+         * Windows glob regex
+         */
+        const WINDOWS_CHARS = {
+          ...POSIX_CHARS,
+          SLASH_LITERAL: `[${WIN_SLASH}]`,
+          QMARK: WIN_NO_SLASH,
+          STAR: `${WIN_NO_SLASH}*?`,
+          DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+          NO_DOT: `(?!${DOT_LITERAL})`,
+          NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+          NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+          NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+          QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+          START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+          END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+          SEP: '\\'
+        };
+        /**
+         * POSIX Bracket Regex
+         */
+        const POSIX_REGEX_SOURCE = {
+          alnum: 'a-zA-Z0-9',
+          alpha: 'a-zA-Z',
+          ascii: '\\x00-\\x7F',
+          blank: ' \\t',
+          cntrl: '\\x00-\\x1F\\x7F',
+          digit: '0-9',
+          graph: '\\x21-\\x7E',
+          lower: 'a-z',
+          print: '\\x20-\\x7E ',
+          punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+          space: ' \\t\\r\\n\\v\\f',
+          upper: 'A-Z',
+          word: 'A-Za-z0-9_',
+          xdigit: 'A-Fa-f0-9'
+        };
+        constants = {
+          MAX_LENGTH: 1024 * 64,
+          POSIX_REGEX_SOURCE,
+          // regular expressions
+          REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+          REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+          REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+          REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+          REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+          REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+          // Replace globs with equivalent patterns to reduce parsing time.
+          REPLACEMENTS: {
+            '***': '*',
+            '**/**': '**',
+            '**/**/**': '**'
+          },
+          // Digits
+          CHAR_0: 48, /* 0 */
+          CHAR_9: 57, /* 9 */
+          // Alphabet chars.
+          CHAR_UPPERCASE_A: 65, /* A */
+          CHAR_LOWERCASE_A: 97, /* a */
+          CHAR_UPPERCASE_Z: 90, /* Z */
+          CHAR_LOWERCASE_Z: 122, /* z */
+          CHAR_LEFT_PARENTHESES: 40, /* ( */
+          CHAR_RIGHT_PARENTHESES: 41, /* ) */
+          CHAR_ASTERISK: 42, /* * */
+          // Non-alphabetic chars.
+          CHAR_AMPERSAND: 38, /* & */
+          CHAR_AT: 64, /* @ */
+          CHAR_BACKWARD_SLASH: 92, /* \ */
+          CHAR_CARRIAGE_RETURN: 13, /* \r */
+          CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+          CHAR_COLON: 58, /* : */
+          CHAR_COMMA: 44, /* , */
+          CHAR_DOT: 46, /* . */
+          CHAR_DOUBLE_QUOTE: 34, /* " */
+          CHAR_EQUAL: 61, /* = */
+          CHAR_EXCLAMATION_MARK: 33, /* ! */
+          CHAR_FORM_FEED: 12, /* \f */
+          CHAR_FORWARD_SLASH: 47, /* / */
+          CHAR_GRAVE_ACCENT: 96, /* ` */
+          CHAR_HASH: 35, /* # */
+          CHAR_HYPHEN_MINUS: 45, /* - */
+          CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+          CHAR_LEFT_CURLY_BRACE: 123, /* { */
+          CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+          CHAR_LINE_FEED: 10, /* \n */
+          CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+          CHAR_PERCENT: 37, /* % */
+          CHAR_PLUS: 43, /* + */
+          CHAR_QUESTION_MARK: 63, /* ? */
+          CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+          CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+          CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+          CHAR_SEMICOLON: 59, /* ; */
+          CHAR_SINGLE_QUOTE: 39, /* ' */
+          CHAR_SPACE: 32, /*   */
+          CHAR_TAB: 9, /* \t */
+          CHAR_UNDERSCORE: 95, /* _ */
+          CHAR_VERTICAL_LINE: 124, /* | */
+          CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+          /**
+           * Create EXTGLOB_CHARS
+           */
+          extglobChars(chars) {
+            return {
+              '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+              '?': { type: 'qmark', open: '(?:', close: ')?' },
+              '+': { type: 'plus', open: '(?:', close: ')+' },
+              '*': { type: 'star', open: '(?:', close: ')*' },
+              '@': { type: 'at', open: '(?:', close: ')' }
+            };
+          },
+          /**
+           * Create GLOB_CHARS
+           */
+          globChars(win32) {
+            return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+          }
+        };
+        return constants;
+}
+/*global navigator*/
+var hasRequiredUtils;
+function requireUtils () {
+        if (hasRequiredUtils) return utils;
+        hasRequiredUtils = 1;
+        (function (exports) {
+                const {
+                  REGEX_BACKSLASH,
+                  REGEX_REMOVE_BACKSLASH,
+                  REGEX_SPECIAL_CHARS,
+                  REGEX_SPECIAL_CHARS_GLOBAL
+                } = /*@__PURE__*/ requireConstants();
+                exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+                exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+                exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+                exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+                exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+                exports.isWindows = () => {
+                  if (typeof navigator !== 'undefined' && navigator.platform) {
+                    const platform = navigator.platform.toLowerCase();
+                    return platform === 'win32' || platform === 'windows';
+                  }
+                  if (typeof process !== 'undefined' && process.platform) {
+                    return process.platform === 'win32';
+                  }
+                  return false;
+                };
+                exports.removeBackslashes = str => {
+                  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+                    return match === '\\' ? '' : match;
+                  });
+                };
+                exports.escapeLast = (input, char, lastIdx) => {
+                  const idx = input.lastIndexOf(char, lastIdx);
+                  if (idx === -1) return input;
+                  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+                  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+                };
+                exports.removePrefix = (input, state = {}) => {
+                  let output = input;
+                  if (output.startsWith('./')) {
+                    output = output.slice(2);
+                    state.prefix = './';
+                  }
+                  return output;
+                };
+                exports.wrapOutput = (input, state = {}, options = {}) => {
+                  const prepend = options.contains ? '' : '^';
+                  const append = options.contains ? '' : '$';
+                  let output = `${prepend}(?:${input})${append}`;
+                  if (state.negated === true) {
+                    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;
+}
+var scan_1;
+var hasRequiredScan;
+function requireScan () {
+        if (hasRequiredScan) return scan_1;
+        hasRequiredScan = 1;
+        const utils = /*@__PURE__*/ requireUtils();
+        const {
+          CHAR_ASTERISK,             /* * */
+          CHAR_AT,                   /* @ */
+          CHAR_BACKWARD_SLASH,       /* \ */
+          CHAR_COMMA,                /* , */
+          CHAR_DOT,                  /* . */
+          CHAR_EXCLAMATION_MARK,     /* ! */
+          CHAR_FORWARD_SLASH,        /* / */
+          CHAR_LEFT_CURLY_BRACE,     /* { */
+          CHAR_LEFT_PARENTHESES,     /* ( */
+          CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+          CHAR_PLUS,                 /* + */
+          CHAR_QUESTION_MARK,        /* ? */
+          CHAR_RIGHT_CURLY_BRACE,    /* } */
+          CHAR_RIGHT_PARENTHESES,    /* ) */
+          CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+        } = /*@__PURE__*/ requireConstants();
+        const isPathSeparator = code => {
+          return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+        };
+        const depth = token => {
+          if (token.isPrefix !== true) {
+            token.depth = token.isGlobstar ? Infinity : 1;
+          }
+        };
+        /**
+         * Quickly scans a glob pattern and returns an object with a handful of
+         * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+         * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+         * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+         *
+         * ```js
+         * const pm = require('picomatch');
+         * console.log(pm.scan('foo/bar/*.js'));
+         * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+         * ```
+         * @param {String} `str`
+         * @param {Object} `options`
+         * @return {Object} Returns an object with tokens and regex source string.
+         * @api public
+         */
+        const scan = (input, options) => {
+          const opts = options || {};
+          const length = input.length - 1;
+          const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+          const slashes = [];
+          const tokens = [];
+          const parts = [];
+          let str = input;
+          let index = -1;
+          let start = 0;
+          let lastIndex = 0;
+          let isBrace = false;
+          let isBracket = false;
+          let isGlob = false;
+          let isExtglob = false;
+          let isGlobstar = false;
+          let braceEscaped = false;
+          let backslashes = false;
+          let negated = false;
+          let negatedExtglob = false;
+          let finished = false;
+          let braces = 0;
+          let prev;
+          let code;
+          let token = { value: '', depth: 0, isGlob: false };
+          const eos = () => index >= length;
+          const peek = () => str.charCodeAt(index + 1);
+          const advance = () => {
+            prev = code;
+            return str.charCodeAt(++index);
+          };
+          while (index < length) {
+            code = advance();
+            let next;
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              if (code === CHAR_LEFT_CURLY_BRACE) {
+                braceEscaped = true;
+              }
+              continue;
+            }
+            if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+              braces++;
+              while (eos() !== true && (code = advance())) {
+                if (code === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  advance();
+                  continue;
+                }
+                if (code === CHAR_LEFT_CURLY_BRACE) {
+                  braces++;
+                  continue;
+                }
+                if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+                  isBrace = token.isBrace = true;
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  if (scanToEnd === true) {
+                    continue;
+                  }
+                  break;
+                }
+                if (braceEscaped !== true && code === CHAR_COMMA) {
+                  isBrace = token.isBrace = true;
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  if (scanToEnd === true) {
+                    continue;
+                  }
+                  break;
+                }
+                if (code === CHAR_RIGHT_CURLY_BRACE) {
+                  braces--;
+                  if (braces === 0) {
+                    braceEscaped = false;
+                    isBrace = token.isBrace = true;
+                    finished = true;
+                    break;
+                  }
+                }
+              }
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_FORWARD_SLASH) {
+              slashes.push(index);
+              tokens.push(token);
+              token = { value: '', depth: 0, isGlob: false };
+              if (finished === true) continue;
+              if (prev === CHAR_DOT && index === (start + 1)) {
+                start += 2;
+                continue;
+              }
+              lastIndex = index + 1;
+              continue;
+            }
+            if (opts.noext !== true) {
+              const isExtglobChar = code === CHAR_PLUS
+                || code === CHAR_AT
+                || code === CHAR_ASTERISK
+                || code === CHAR_QUESTION_MARK
+                || code === CHAR_EXCLAMATION_MARK;
+              if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+                isGlob = token.isGlob = true;
+                isExtglob = token.isExtglob = true;
+                finished = true;
+                if (code === CHAR_EXCLAMATION_MARK && index === start) {
+                  negatedExtglob = true;
+                }
+                if (scanToEnd === true) {
+                  while (eos() !== true && (code = advance())) {
+                    if (code === CHAR_BACKWARD_SLASH) {
+                      backslashes = token.backslashes = true;
+                      code = advance();
+                      continue;
+                    }
+                    if (code === CHAR_RIGHT_PARENTHESES) {
+                      isGlob = token.isGlob = true;
+                      finished = true;
+                      break;
+                    }
+                  }
+                  continue;
+                }
+                break;
+              }
+            }
+            if (code === CHAR_ASTERISK) {
+              if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_QUESTION_MARK) {
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_LEFT_SQUARE_BRACKET) {
+              while (eos() !== true && (next = advance())) {
+                if (next === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  advance();
+                  continue;
+                }
+                if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                  isBracket = token.isBracket = true;
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  break;
+                }
+              }
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+              negated = token.negated = true;
+              start++;
+              continue;
+            }
+            if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+              isGlob = token.isGlob = true;
+              if (scanToEnd === true) {
+                while (eos() !== true && (code = advance())) {
+                  if (code === CHAR_LEFT_PARENTHESES) {
+                    backslashes = token.backslashes = true;
+                    code = advance();
+                    continue;
+                  }
+                  if (code === CHAR_RIGHT_PARENTHESES) {
+                    finished = true;
+                    break;
+                  }
+                }
+                continue;
+              }
+              break;
+            }
+            if (isGlob === true) {
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+          }
+          if (opts.noext === true) {
+            isExtglob = false;
+            isGlob = false;
+          }
+          let base = str;
+          let prefix = '';
+          let glob = '';
+          if (start > 0) {
+            prefix = str.slice(0, start);
+            str = str.slice(start);
+            lastIndex -= start;
+          }
+          if (base && isGlob === true && lastIndex > 0) {
+            base = str.slice(0, lastIndex);
+            glob = str.slice(lastIndex);
+          } else if (isGlob === true) {
+            base = '';
+            glob = str;
+          } else {
+            base = str;
+          }
+          if (base && base !== '' && base !== '/' && base !== str) {
+            if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+              base = base.slice(0, -1);
+            }
+          }
+          if (opts.unescape === true) {
+            if (glob) glob = utils.removeBackslashes(glob);
+            if (base && backslashes === true) {
+              base = utils.removeBackslashes(base);
+            }
+          }
+          const state = {
+            prefix,
+            input,
+            start,
+            base,
+            glob,
+            isBrace,
+            isBracket,
+            isGlob,
+            isExtglob,
+            isGlobstar,
+            negated,
+            negatedExtglob
+          };
+          if (opts.tokens === true) {
+            state.maxDepth = 0;
+            if (!isPathSeparator(code)) {
+              tokens.push(token);
+            }
+            state.tokens = tokens;
+          }
+          if (opts.parts === true || opts.tokens === true) {
+            let prevIndex;
+            for (let idx = 0; idx < slashes.length; idx++) {
+              const n = prevIndex ? prevIndex + 1 : start;
+              const i = slashes[idx];
+              const value = input.slice(n, i);
+              if (opts.tokens) {
+                if (idx === 0 && start !== 0) {
+                  tokens[idx].isPrefix = true;
+                  tokens[idx].value = prefix;
+                } else {
+                  tokens[idx].value = value;
+                }
+                depth(tokens[idx]);
+                state.maxDepth += tokens[idx].depth;
+              }
+              if (idx !== 0 || value !== '') {
+                parts.push(value);
+              }
+              prevIndex = i;
+            }
+            if (prevIndex && prevIndex + 1 < input.length) {
+              const value = input.slice(prevIndex + 1);
+              parts.push(value);
+              if (opts.tokens) {
+                tokens[tokens.length - 1].value = value;
+                depth(tokens[tokens.length - 1]);
+                state.maxDepth += tokens[tokens.length - 1].depth;
+              }
+            }
+            state.slashes = slashes;
+            state.parts = parts;
+          }
+          return state;
+        };
+        scan_1 = scan;
+        return scan_1;
+}
+var parse_1;
+var hasRequiredParse;
+function requireParse () {
+        if (hasRequiredParse) return parse_1;
+        hasRequiredParse = 1;
+        const constants = /*@__PURE__*/ requireConstants();
+        const utils = /*@__PURE__*/ requireUtils();
+        /**
+         * Constants
+         */
+        const {
+          MAX_LENGTH,
+          POSIX_REGEX_SOURCE,
+          REGEX_NON_SPECIAL_CHARS,
+          REGEX_SPECIAL_CHARS_BACKREF,
+          REPLACEMENTS
+        } = constants;
+        /**
+         * Helpers
+         */
+        const expandRange = (args, options) => {
+          if (typeof options.expandRange === 'function') {
+            return options.expandRange(...args, options);
+          }
+          args.sort();
+          const value = `[${args.join('-')}]`;
+          return value;
+        };
+        /**
+         * Create the message for a syntax error
+         */
+        const syntaxError = (type, char) => {
+          return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+        };
+        /**
+         * Parse the given input string.
+         * @param {String} input
+         * @param {Object} options
+         * @return {Object}
+         */
+        const parse = (input, options) => {
+          if (typeof input !== 'string') {
+            throw new TypeError('Expected a string');
+          }
+          input = REPLACEMENTS[input] || input;
+          const opts = { ...options };
+          const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+          let len = input.length;
+          if (len > max) {
+            throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+          }
+          const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+          const tokens = [bos];
+          const capture = opts.capture ? '' : '?:';
+          // create constants based on platform, for windows or posix
+          const PLATFORM_CHARS = constants.globChars(opts.windows);
+          const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+          const {
+            DOT_LITERAL,
+            PLUS_LITERAL,
+            SLASH_LITERAL,
+            ONE_CHAR,
+            DOTS_SLASH,
+            NO_DOT,
+            NO_DOT_SLASH,
+            NO_DOTS_SLASH,
+            QMARK,
+            QMARK_NO_DOT,
+            STAR,
+            START_ANCHOR
+          } = PLATFORM_CHARS;
+          const globstar = opts => {
+            return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+          };
+          const nodot = opts.dot ? '' : NO_DOT;
+          const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+          let star = opts.bash === true ? globstar(opts) : STAR;
+          if (opts.capture) {
+            star = `(${star})`;
+          }
+          // minimatch options support
+          if (typeof opts.noext === 'boolean') {
+            opts.noextglob = opts.noext;
+          }
+          const state = {
+            input,
+            index: -1,
+            start: 0,
+            dot: opts.dot === true,
+            consumed: '',
+            output: '',
+            prefix: '',
+            backtrack: false,
+            negated: false,
+            brackets: 0,
+            braces: 0,
+            parens: 0,
+            quotes: 0,
+            globstar: false,
+            tokens
+          };
+          input = utils.removePrefix(input, state);
+          len = input.length;
+          const extglobs = [];
+          const braces = [];
+          const stack = [];
+          let prev = bos;
+          let value;
+          /**
+           * Tokenizing helpers
+           */
+          const eos = () => state.index === len - 1;
+          const peek = state.peek = (n = 1) => input[state.index + n];
+          const advance = state.advance = () => input[++state.index] || '';
+          const remaining = () => input.slice(state.index + 1);
+          const consume = (value = '', num = 0) => {
+            state.consumed += value;
+            state.index += num;
+          };
+          const append = token => {
+            state.output += token.output != null ? token.output : token.value;
+            consume(token.value);
+          };
+          const negate = () => {
+            let count = 1;
+            while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+              advance();
+              state.start++;
+              count++;
+            }
+            if (count % 2 === 0) {
+              return false;
+            }
+            state.negated = true;
+            state.start++;
+            return true;
+          };
+          const increment = type => {
+            state[type]++;
+            stack.push(type);
+          };
+          const decrement = type => {
+            state[type]--;
+            stack.pop();
+          };
+          /**
+           * Push tokens onto the tokens array. This helper speeds up
+           * tokenizing by 1) helping us avoid backtracking as much as possible,
+           * and 2) helping us avoid creating extra tokens when consecutive
+           * characters are plain text. This improves performance and simplifies
+           * lookbehinds.
+           */
+          const push = tok => {
+            if (prev.type === 'globstar') {
+              const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+              const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+              if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+                state.output = state.output.slice(0, -prev.output.length);
+                prev.type = 'star';
+                prev.value = '*';
+                prev.output = star;
+                state.output += prev.output;
+              }
+            }
+            if (extglobs.length && tok.type !== 'paren') {
+              extglobs[extglobs.length - 1].inner += tok.value;
+            }
+            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;
+              return;
+            }
+            tok.prev = prev;
+            tokens.push(tok);
+            prev = tok;
+          };
+          const extglobOpen = (type, value) => {
+            const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+            token.prev = prev;
+            token.parens = state.parens;
+            token.output = state.output;
+            const output = (opts.capture ? '(' : '') + token.open;
+            increment('parens');
+            push({ type, value, output: state.output ? '' : ONE_CHAR });
+            push({ type: 'paren', extglob: true, value: advance(), output });
+            extglobs.push(token);
+          };
+          const extglobClose = token => {
+            let output = token.close + (opts.capture ? ')' : '');
+            let rest;
+            if (token.type === 'negate') {
+              let extglobStar = star;
+              if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+                extglobStar = globstar(opts);
+              }
+              if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+                output = token.close = `)$))${extglobStar}`;
+              }
+              if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+                // In this case, we need to parse the string and use it in the output of the original pattern.
+                // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+                //
+                // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+                const expression = parse(rest, { ...options, fastpaths: false }).output;
+                output = token.close = `)${expression})${extglobStar})`;
+              }
+              if (token.prev.type === 'bos') {
+                state.negatedExtglob = true;
+              }
+            }
+            push({ type: 'paren', extglob: true, value, output });
+            decrement('parens');
+          };
+          /**
+           * Fast paths
+           */
+          if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+            let backslashes = false;
+            let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+              if (first === '\\') {
+                backslashes = true;
+                return m;
+              }
+              if (first === '?') {
+                if (esc) {
+                  return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+                }
+                if (index === 0) {
+                  return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+                }
+                return QMARK.repeat(chars.length);
+              }
+              if (first === '.') {
+                return DOT_LITERAL.repeat(chars.length);
+              }
+              if (first === '*') {
+                if (esc) {
+                  return esc + first + (rest ? star : '');
+                }
+                return star;
+              }
+              return esc ? m : `\\${m}`;
+            });
+            if (backslashes === true) {
+              if (opts.unescape === true) {
+                output = output.replace(/\\/g, '');
+              } else {
+                output = output.replace(/\\+/g, m => {
+                  return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+                });
+              }
+            }
+            if (output === input && opts.contains === true) {
+              state.output = input;
+              return state;
+            }
+            state.output = utils.wrapOutput(output, state, options);
+            return state;
+          }
+          /**
+           * Tokenize input until we reach end-of-string
+           */
+          while (!eos()) {
+            value = advance();
+            if (value === '\u0000') {
+              continue;
+            }
+            /**
+             * Escaped characters
+             */
+            if (value === '\\') {
+              const next = peek();
+              if (next === '/' && opts.bash !== true) {
+                continue;
+              }
+              if (next === '.' || next === ';') {
+                continue;
+              }
+              if (!next) {
+                value += '\\';
+                push({ type: 'text', value });
+                continue;
+              }
+              // collapse slashes to reduce potential for exploits
+              const match = /^\\+/.exec(remaining());
+              let slashes = 0;
+              if (match && match[0].length > 2) {
+                slashes = match[0].length;
+                state.index += slashes;
+                if (slashes % 2 !== 0) {
+                  value += '\\';
+                }
+              }
+              if (opts.unescape === true) {
+                value = advance();
+              } else {
+                value += advance();
+              }
+              if (state.brackets === 0) {
+                push({ type: 'text', value });
+                continue;
+              }
+            }
+            /**
+             * If we're inside a regex character class, continue
+             * until we reach the closing bracket.
+             */
+            if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+              if (opts.posix !== false && value === ':') {
+                const inner = prev.value.slice(1);
+                if (inner.includes('[')) {
+                  prev.posix = true;
+                  if (inner.includes(':')) {
+                    const idx = prev.value.lastIndexOf('[');
+                    const pre = prev.value.slice(0, idx);
+                    const rest = prev.value.slice(idx + 2);
+                    const posix = POSIX_REGEX_SOURCE[rest];
+                    if (posix) {
+                      prev.value = pre + posix;
+                      state.backtrack = true;
+                      advance();
+                      if (!bos.output && tokens.indexOf(prev) === 1) {
+                        bos.output = ONE_CHAR;
+                      }
+                      continue;
+                    }
+                  }
+                }
+              }
+              if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+                value = `\\${value}`;
+              }
+              if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+                value = `\\${value}`;
+              }
+              if (opts.posix === true && value === '!' && prev.value === '[') {
+                value = '^';
+              }
+              prev.value += value;
+              append({ value });
+              continue;
+            }
+            /**
+             * If we're inside a quoted string, continue
+             * until we reach the closing double quote.
+             */
+            if (state.quotes === 1 && value !== '"') {
+              value = utils.escapeRegex(value);
+              prev.value += value;
+              append({ value });
+              continue;
+            }
+            /**
+             * Double quotes
+             */
+            if (value === '"') {
+              state.quotes = state.quotes === 1 ? 0 : 1;
+              if (opts.keepQuotes === true) {
+                push({ type: 'text', value });
+              }
+              continue;
+            }
+            /**
+             * Parentheses
+             */
+            if (value === '(') {
+              increment('parens');
+              push({ type: 'paren', value });
+              continue;
+            }
+            if (value === ')') {
+              if (state.parens === 0 && opts.strictBrackets === true) {
+                throw new SyntaxError(syntaxError('opening', '('));
+              }
+              const extglob = extglobs[extglobs.length - 1];
+              if (extglob && state.parens === extglob.parens + 1) {
+                extglobClose(extglobs.pop());
+                continue;
+              }
+              push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+              decrement('parens');
+              continue;
+            }
+            /**
+             * Square brackets
+             */
+            if (value === '[') {
+              if (opts.nobracket === true || !remaining().includes(']')) {
+                if (opts.nobracket !== true && opts.strictBrackets === true) {
+                  throw new SyntaxError(syntaxError('closing', ']'));
+                }
+                value = `\\${value}`;
+              } else {
+                increment('brackets');
+              }
+              push({ type: 'bracket', value });
+              continue;
+            }
+            if (value === ']') {
+              if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+                push({ type: 'text', value, output: `\\${value}` });
+                continue;
+              }
+              if (state.brackets === 0) {
+                if (opts.strictBrackets === true) {
+                  throw new SyntaxError(syntaxError('opening', '['));
+                }
+                push({ type: 'text', value, output: `\\${value}` });
+                continue;
+              }
+              decrement('brackets');
+              const prevValue = prev.value.slice(1);
+              if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+                value = `/${value}`;
+              }
+              prev.value += value;
+              append({ value });
+              // when literal brackets are explicitly disabled
+              // assume we should match with a regex character class
+              if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+                continue;
+              }
+              const escaped = utils.escapeRegex(prev.value);
+              state.output = state.output.slice(0, -prev.value.length);
+              // when literal brackets are explicitly enabled
+              // assume we should escape the brackets to match literal characters
+              if (opts.literalBrackets === true) {
+                state.output += escaped;
+                prev.value = escaped;
+                continue;
+              }
+              // when the user specifies nothing, try to match both
+              prev.value = `(${capture}${escaped}|${prev.value})`;
+              state.output += prev.value;
+              continue;
+            }
+            /**
+             * Braces
+             */
+            if (value === '{' && opts.nobrace !== true) {
+              increment('braces');
+              const open = {
+                type: 'brace',
+                value,
+                output: '(',
+                outputIndex: state.output.length,
+                tokensIndex: state.tokens.length
+              };
+              braces.push(open);
+              push(open);
+              continue;
+            }
+            if (value === '}') {
+              const brace = braces[braces.length - 1];
+              if (opts.nobrace === true || !brace) {
+                push({ type: 'text', value, output: value });
+                continue;
+              }
+              let output = ')';
+              if (brace.dots === true) {
+                const arr = tokens.slice();
+                const range = [];
+                for (let i = arr.length - 1; i >= 0; i--) {
+                  tokens.pop();
+                  if (arr[i].type === 'brace') {
+                    break;
+                  }
+                  if (arr[i].type !== 'dots') {
+                    range.unshift(arr[i].value);
+                  }
+                }
+                output = expandRange(range, opts);
+                state.backtrack = true;
+              }
+              if (brace.comma !== true && brace.dots !== true) {
+                const out = state.output.slice(0, brace.outputIndex);
+                const toks = state.tokens.slice(brace.tokensIndex);
+                brace.value = brace.output = '\\{';
+                value = output = '\\}';
+                state.output = out;
+                for (const t of toks) {
+                  state.output += (t.output || t.value);
+                }
+              }
+              push({ type: 'brace', value, output });
+              decrement('braces');
+              braces.pop();
+              continue;
+            }
+            /**
+             * Pipes
+             */
+            if (value === '|') {
+              if (extglobs.length > 0) {
+                extglobs[extglobs.length - 1].conditions++;
+              }
+              push({ type: 'text', value });
+              continue;
+            }
+            /**
+             * Commas
+             */
+            if (value === ',') {
+              let output = value;
+              const brace = braces[braces.length - 1];
+              if (brace && stack[stack.length - 1] === 'braces') {
+                brace.comma = true;
+                output = '|';
+              }
+              push({ type: 'comma', value, output });
+              continue;
+            }
+            /**
+             * Slashes
+             */
+            if (value === '/') {
+              // if the beginning of the glob is "./", advance the start
+              // to the current index, and don't add the "./" characters
+              // to the state. This greatly simplifies lookbehinds when
+              // checking for BOS characters like "!" and "." (not "./")
+              if (prev.type === 'dot' && state.index === state.start + 1) {
+                state.start = state.index + 1;
+                state.consumed = '';
+                state.output = '';
+                tokens.pop();
+                prev = bos; // reset "prev" to the first token
+                continue;
+              }
+              push({ type: 'slash', value, output: SLASH_LITERAL });
+              continue;
+            }
+            /**
+             * Dots
+             */
+            if (value === '.') {
+              if (state.braces > 0 && prev.type === 'dot') {
+                if (prev.value === '.') prev.output = DOT_LITERAL;
+                const brace = braces[braces.length - 1];
+                prev.type = 'dots';
+                prev.output += value;
+                prev.value += value;
+                brace.dots = true;
+                continue;
+              }
+              if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+                push({ type: 'text', value, output: DOT_LITERAL });
+                continue;
+              }
+              push({ type: 'dot', value, output: DOT_LITERAL });
+              continue;
+            }
+            /**
+             * Question marks
+             */
+            if (value === '?') {
+              const isGroup = prev && prev.value === '(';
+              if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+                extglobOpen('qmark', value);
+                continue;
+              }
+              if (prev && prev.type === 'paren') {
+                const next = peek();
+                let output = value;
+                if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+                  output = `\\${value}`;
+                }
+                push({ type: 'text', value, output });
+                continue;
+              }
+              if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+                push({ type: 'qmark', value, output: QMARK_NO_DOT });
+                continue;
+              }
+              push({ type: 'qmark', value, output: QMARK });
+              continue;
+            }
+            /**
+             * Exclamation
+             */
+            if (value === '!') {
+              if (opts.noextglob !== true && peek() === '(') {
+                if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+                  extglobOpen('negate', value);
+                  continue;
+                }
+              }
+              if (opts.nonegate !== true && state.index === 0) {
+                negate();
+                continue;
+              }
+            }
+            /**
+             * Plus
+             */
+            if (value === '+') {
+              if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+                extglobOpen('plus', value);
+                continue;
+              }
+              if ((prev && prev.value === '(') || opts.regex === false) {
+                push({ type: 'plus', value, output: PLUS_LITERAL });
+                continue;
+              }
+              if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+                push({ type: 'plus', value });
+                continue;
+              }
+              push({ type: 'plus', value: PLUS_LITERAL });
+              continue;
+            }
+            /**
+             * Plain text
+             */
+            if (value === '@') {
+              if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+                push({ type: 'at', extglob: true, value, output: '' });
+                continue;
+              }
+              push({ type: 'text', value });
+              continue;
+            }
+            /**
+             * Plain text
+             */
+            if (value !== '*') {
+              if (value === '$' || value === '^') {
+                value = `\\${value}`;
+              }
+              const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+              if (match) {
+                value += match[0];
+                state.index += match[0].length;
+              }
+              push({ type: 'text', value });
+              continue;
+            }
+            /**
+             * Stars
+             */
+            if (prev && (prev.type === 'globstar' || prev.star === true)) {
+              prev.type = 'star';
+              prev.star = true;
+              prev.value += value;
+              prev.output = star;
+              state.backtrack = true;
+              state.globstar = true;
+              consume(value);
+              continue;
+            }
+            let rest = remaining();
+            if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+              extglobOpen('star', value);
+              continue;
+            }
+            if (prev.type === 'star') {
+              if (opts.noglobstar === true) {
+                consume(value);
+                continue;
+              }
+              const prior = prev.prev;
+              const before = prior.prev;
+              const isStart = prior.type === 'slash' || prior.type === 'bos';
+              const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+              if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+                push({ type: 'star', value, output: '' });
+                continue;
+              }
+              const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+              const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+              if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+                push({ type: 'star', value, output: '' });
+                continue;
+              }
+              // strip consecutive `/**/`
+              while (rest.slice(0, 3) === '/**') {
+                const after = input[state.index + 4];
+                if (after && after !== '/') {
+                  break;
+                }
+                rest = rest.slice(3);
+                consume('/**', 3);
+              }
+              if (prior.type === 'bos' && eos()) {
+                prev.type = 'globstar';
+                prev.value += value;
+                prev.output = globstar(opts);
+                state.output = prev.output;
+                state.globstar = true;
+                consume(value);
+                continue;
+              }
+              if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+                state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                prior.output = `(?:${prior.output}`;
+                prev.type = 'globstar';
+                prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+                prev.value += value;
+                state.globstar = true;
+                state.output += prior.output + prev.output;
+                consume(value);
+                continue;
+              }
+              if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+                const end = rest[1] !== void 0 ? '|$' : '';
+                state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                prior.output = `(?:${prior.output}`;
+                prev.type = 'globstar';
+                prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+                prev.value += value;
+                state.output += prior.output + prev.output;
+                state.globstar = true;
+                consume(value + advance());
+                push({ type: 'slash', value: '/', output: '' });
+                continue;
+              }
+              if (prior.type === 'bos' && rest[0] === '/') {
+                prev.type = 'globstar';
+                prev.value += value;
+                prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+                state.output = prev.output;
+                state.globstar = true;
+                consume(value + advance());
+                push({ type: 'slash', value: '/', output: '' });
+                continue;
+              }
+              // remove single star from output
+              state.output = state.output.slice(0, -prev.output.length);
+              // reset previous token to globstar
+              prev.type = 'globstar';
+              prev.output = globstar(opts);
+              prev.value += value;
+              // reset output with globstar
+              state.output += prev.output;
+              state.globstar = true;
+              consume(value);
+              continue;
+            }
+            const token = { type: 'star', value, output: star };
+            if (opts.bash === true) {
+              token.output = '.*?';
+              if (prev.type === 'bos' || prev.type === 'slash') {
+                token.output = nodot + token.output;
+              }
+              push(token);
+              continue;
+            }
+            if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+              token.output = value;
+              push(token);
+              continue;
+            }
+            if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+              if (prev.type === 'dot') {
+                state.output += NO_DOT_SLASH;
+                prev.output += NO_DOT_SLASH;
+              } else if (opts.dot === true) {
+                state.output += NO_DOTS_SLASH;
+                prev.output += NO_DOTS_SLASH;
+              } else {
+                state.output += nodot;
+                prev.output += nodot;
+              }
+              if (peek() !== '*') {
+                state.output += ONE_CHAR;
+                prev.output += ONE_CHAR;
+              }
+            }
+            push(token);
+          }
+          while (state.brackets > 0) {
+            if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+            state.output = utils.escapeLast(state.output, '[');
+            decrement('brackets');
+          }
+          while (state.parens > 0) {
+            if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+            state.output = utils.escapeLast(state.output, '(');
+            decrement('parens');
+          }
+          while (state.braces > 0) {
+            if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+            state.output = utils.escapeLast(state.output, '{');
+            decrement('braces');
+          }
+          if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+            push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+          }
+          // rebuild the output if we had to backtrack at any point
+          if (state.backtrack === true) {
+            state.output = '';
+            for (const token of state.tokens) {
+              state.output += token.output != null ? token.output : token.value;
+              if (token.suffix) {
+                state.output += token.suffix;
+              }
+            }
+          }
+          return state;
+        };
+        /**
+         * Fast paths for creating regular expressions for common glob patterns.
+         * This can significantly speed up processing and has very little downside
+         * impact when none of the fast paths match.
+         */
+        parse.fastpaths = (input, options) => {
+          const opts = { ...options };
+          const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+          const len = input.length;
+          if (len > max) {
+            throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+          }
+          input = REPLACEMENTS[input] || input;
+          // create constants based on platform, for windows or posix
+          const {
+            DOT_LITERAL,
+            SLASH_LITERAL,
+            ONE_CHAR,
+            DOTS_SLASH,
+            NO_DOT,
+            NO_DOTS,
+            NO_DOTS_SLASH,
+            STAR,
+            START_ANCHOR
+          } = constants.globChars(opts.windows);
+          const nodot = opts.dot ? NO_DOTS : NO_DOT;
+          const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+          const capture = opts.capture ? '' : '?:';
+          const state = { negated: false, prefix: '' };
+          let star = opts.bash === true ? '.*?' : STAR;
+          if (opts.capture) {
+            star = `(${star})`;
+          }
+          const globstar = opts => {
+            if (opts.noglobstar === true) return star;
+            return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+          };
+          const create = str => {
+            switch (str) {
+              case '*':
+                return `${nodot}${ONE_CHAR}${star}`;
+              case '.*':
+                return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+              case '*.*':
+                return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+              case '*/*':
+                return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+              case '**':
+                return nodot + globstar(opts);
+              case '**/*':
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+              case '**/*.*':
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+              case '**/.*':
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+              default: {
+                const match = /^(.*?)\.(\w+)$/.exec(str);
+                if (!match) return;
+                const source = create(match[1]);
+                if (!source) return;
+                return source + DOT_LITERAL + match[2];
+              }
+            }
+          };
+          const output = utils.removePrefix(input, state);
+          let source = create(output);
+          if (source && opts.strictSlashes !== true) {
+            source += `${SLASH_LITERAL}?`;
+          }
+          return source;
+        };
+        parse_1 = parse;
+        return parse_1;
+}
+var picomatch_1$1;
+var hasRequiredPicomatch$1;
+function requirePicomatch$1 () {
+        if (hasRequiredPicomatch$1) return picomatch_1$1;
+        hasRequiredPicomatch$1 = 1;
+        const scan = /*@__PURE__*/ requireScan();
+        const parse = /*@__PURE__*/ requireParse();
+        const utils = /*@__PURE__*/ requireUtils();
+        const constants = /*@__PURE__*/ requireConstants();
+        const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+        /**
+         * Creates a matcher function from one or more glob patterns. The
+         * returned function takes a string to match as its first argument,
+         * and returns true if the string is a match. The returned matcher
+         * function also takes a boolean as the second argument that, when true,
+         * returns an object with additional information.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * // picomatch(glob[, options]);
+         *
+         * const isMatch = picomatch('*.!(*a)');
+         * console.log(isMatch('a.a')); //=> false
+         * console.log(isMatch('a.b')); //=> true
+         * ```
+         * @name picomatch
+         * @param {String|Array} `globs` One or more glob patterns.
+         * @param {Object=} `options`
+         * @return {Function=} Returns a matcher function.
+         * @api public
+         */
+        const picomatch = (glob, options, returnState = false) => {
+          if (Array.isArray(glob)) {
+            const fns = glob.map(input => picomatch(input, options, returnState));
+            const arrayMatcher = str => {
+              for (const isMatch of fns) {
+                const state = isMatch(str);
+                if (state) return state;
+              }
+              return false;
+            };
+            return arrayMatcher;
+          }
+          const isState = isObject(glob) && glob.tokens && glob.input;
+          if (glob === '' || (typeof glob !== 'string' && !isState)) {
+            throw new TypeError('Expected pattern to be a non-empty string');
+          }
+          const opts = options || {};
+          const posix = opts.windows;
+          const regex = isState
+            ? picomatch.compileRe(glob, options)
+            : picomatch.makeRe(glob, options, false, true);
+          const state = regex.state;
+          delete regex.state;
+          let isIgnored = () => false;
+          if (opts.ignore) {
+            const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+            isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+          }
+          const matcher = (input, returnObject = false) => {
+            const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+            const result = { glob, state, regex, posix, input, output, match, isMatch };
+            if (typeof opts.onResult === 'function') {
+              opts.onResult(result);
+            }
+            if (isMatch === false) {
+              result.isMatch = false;
+              return returnObject ? result : false;
+            }
+            if (isIgnored(input)) {
+              if (typeof opts.onIgnore === 'function') {
+                opts.onIgnore(result);
+              }
+              result.isMatch = false;
+              return returnObject ? result : false;
+            }
+            if (typeof opts.onMatch === 'function') {
+              opts.onMatch(result);
+            }
+            return returnObject ? result : true;
+          };
+          if (returnState) {
+            matcher.state = state;
+          }
+          return matcher;
+        };
+        /**
+         * Test `input` with the given `regex`. This is used by the main
+         * `picomatch()` function to test the input string.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * // picomatch.test(input, regex[, options]);
+         *
+         * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+         * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+         * ```
+         * @param {String} `input` String to test.
+         * @param {RegExp} `regex`
+         * @return {Object} Returns an object with matching info.
+         * @api public
+         */
+        picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+          if (typeof input !== 'string') {
+            throw new TypeError('Expected input to be a string');
+          }
+          if (input === '') {
+            return { isMatch: false, output: '' };
+          }
+          const opts = options || {};
+          const format = opts.format || (posix ? utils.toPosixSlashes : null);
+          let match = input === glob;
+          let output = (match && format) ? format(input) : input;
+          if (match === false) {
+            output = format ? format(input) : input;
+            match = output === glob;
+          }
+          if (match === false || opts.capture === true) {
+            if (opts.matchBase === true || opts.basename === true) {
+              match = picomatch.matchBase(input, regex, options, posix);
+            } else {
+              match = regex.exec(output);
+            }
+          }
+          return { isMatch: Boolean(match), match, output };
+        };
+        /**
+         * Match the basename of a filepath.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * // picomatch.matchBase(input, glob[, options]);
+         * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+         * ```
+         * @param {String} `input` String to test.
+         * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+         * @return {Boolean}
+         * @api public
+         */
+        picomatch.matchBase = (input, glob, options) => {
+          const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+          return regex.test(utils.basename(input));
+        };
+        /**
+         * Returns true if **any** of the given glob `patterns` match the specified `string`.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * // picomatch.isMatch(string, patterns[, options]);
+         *
+         * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+         * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+         * ```
+         * @param {String|Array} str The string to test.
+         * @param {String|Array} patterns One or more glob patterns to use for matching.
+         * @param {Object} [options] See available [options](#options).
+         * @return {Boolean} Returns true if any patterns match `str`
+         * @api public
+         */
+        picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+        /**
+         * Parse a glob pattern to create the source string for a regular
+         * expression.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * const result = picomatch.parse(pattern[, options]);
+         * ```
+         * @param {String} `pattern`
+         * @param {Object} `options`
+         * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+         * @api public
+         */
+        picomatch.parse = (pattern, options) => {
+          if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+          return parse(pattern, { ...options, fastpaths: false });
+        };
+        /**
+         * Scan a glob pattern to separate the pattern into segments.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * // picomatch.scan(input[, options]);
+         *
+         * const result = picomatch.scan('!./foo/*.js');
+         * console.log(result);
+         * { prefix: '!./',
+         *   input: '!./foo/*.js',
+         *   start: 3,
+         *   base: 'foo',
+         *   glob: '*.js',
+         *   isBrace: false,
+         *   isBracket: false,
+         *   isGlob: true,
+         *   isExtglob: false,
+         *   isGlobstar: false,
+         *   negated: true }
+         * ```
+         * @param {String} `input` Glob pattern to scan.
+         * @param {Object} `options`
+         * @return {Object} Returns an object with
+         * @api public
+         */
+        picomatch.scan = (input, options) => scan(input, options);
+        /**
+         * Compile a regular expression from the `state` object returned by the
+         * [parse()](#parse) method.
+         *
+         * @param {Object} `state`
+         * @param {Object} `options`
+         * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+         * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+         * @return {RegExp}
+         * @api public
+         */
+        picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+          if (returnOutput === true) {
+            return state.output;
+          }
+          const opts = options || {};
+          const prepend = opts.contains ? '' : '^';
+          const append = opts.contains ? '' : '$';
+          let source = `${prepend}(?:${state.output})${append}`;
+          if (state && state.negated === true) {
+            source = `^(?!${source}).*$`;
+          }
+          const regex = picomatch.toRegex(source, options);
+          if (returnState === true) {
+            regex.state = state;
+          }
+          return regex;
+        };
+        /**
+         * Create a regular expression from a parsed glob pattern.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * const state = picomatch.parse('*.js');
+         * // picomatch.compileRe(state[, options]);
+         *
+         * console.log(picomatch.compileRe(state));
+         * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+         * ```
+         * @param {String} `state` The object returned from the `.parse` method.
+         * @param {Object} `options`
+         * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+         * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+         * @return {RegExp} Returns a regex created from the given pattern.
+         * @api public
+         */
+        picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+          if (!input || typeof input !== 'string') {
+            throw new TypeError('Expected a non-empty string');
+          }
+          let parsed = { negated: false, fastpaths: true };
+          if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+            parsed.output = parse.fastpaths(input, options);
+          }
+          if (!parsed.output) {
+            parsed = parse(input, options);
+          }
+          return picomatch.compileRe(parsed, options, returnOutput, returnState);
+        };
+        /**
+         * Create a regular expression from the given regex source string.
+         *
+         * ```js
+         * const picomatch = require('picomatch');
+         * // picomatch.toRegex(source[, options]);
+         *
+         * const { output } = picomatch.parse('*.js');
+         * console.log(picomatch.toRegex(output));
+         * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+         * ```
+         * @param {String} `source` Regular expression source string.
+         * @param {Object} `options`
+         * @return {RegExp}
+         * @api public
+         */
+        picomatch.toRegex = (source, options) => {
+          try {
+            const opts = options || {};
+            return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+          } catch (err) {
+            if (options && options.debug === true) throw err;
+            return /$^/;
+          }
+        };
+        /**
+         * Picomatch constants.
+         * @return {Object}
+         */
+        picomatch.constants = constants;
+        /**
+         * Expose "picomatch"
+         */
+        picomatch_1$1 = picomatch;
+        return picomatch_1$1;
+}
+var picomatch_1;
+var hasRequiredPicomatch;
+function requirePicomatch () {
+        if (hasRequiredPicomatch) return picomatch_1;
+        hasRequiredPicomatch = 1;
+        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();
+const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatchExports);
+const extractors = {
+    ArrayPattern(names, param) {
+        for (const element of param.elements) {
+            if (element)
+                extractors[element.type](names, element);
+        }
+    },
+    AssignmentPattern(names, param) {
+        extractors[param.left.type](names, param.left);
+    },
+    Identifier(names, param) {
+        names.push(param.name);
+    },
+    MemberExpression() { },
+    ObjectPattern(names, param) {
+        for (const prop of param.properties) {
+            // @ts-ignore Typescript reports that this is not a valid type
+            if (prop.type === 'RestElement') {
+                extractors.RestElement(names, prop);
+            }
+            else {
+                extractors[prop.value.type](names, prop.value);
+            }
+        }
+    },
+    RestElement(names, param) {
+        extractors[param.argument.type](names, param.argument);
+    }
+};
+const extractAssignedNames = function extractAssignedNames(param) {
+    const names = [];
+    extractors[param.type](names, param);
+    return names;
+};
+// Helper since Typescript can't detect readonly arrays with Array.isArray
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+const normalizePathRegExp = new RegExp(`\\${require$$0.win32.sep}`, 'g');
+const normalizePath = function normalizePath(filename) {
+    return filename.replace(normalizePathRegExp, require$$0.posix.sep);
+};
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || require$$0.isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath(id);
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = normalizePath(require$$0.resolve(resolutionBase || ''))
+        // escape all possible (posix + win) path characters that might interfere with regex
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    // Note that we use posix.join because:
+    // 1. the basePath has been normalized to use /
+    // 2. the incoming glob (id) matcher, also uses /
+    // otherwise Node will force backslash (\) on windows
+    return require$$0.posix.join(basePath, normalizePath(id));
+}
+const createFilter = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                // this refactor is a tad overly verbose but makes for easy debugging
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = pm(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray(include).map(getMatcher);
+    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    if (!includeMatchers.length && !excludeMatchers.length)
+        return (id) => typeof id === 'string' && !id.includes('\0');
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (id.includes('\0'))
+            return false;
+        const pathId = normalizePath(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher.test(pathId))
+                return true;
+        }
+        return !includeMatchers.length;
+    };
+};
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+class ArrayPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        for (const element of this.elements) {
+            element?.addExportedVariables(variables, exportNamesByVariable);
+        }
+    }
+    declare(kind) {
+        const variables = [];
+        for (const element of this.elements) {
+            if (element !== null) {
+                variables.push(...element.declare(kind, UNKNOWN_EXPRESSION));
+            }
+        }
+        return variables;
+    }
+    // Patterns can only be deoptimized at the empty path at the moment
+    deoptimizePath() {
+        for (const element of this.elements) {
+            element?.deoptimizePath(EMPTY_PATH);
+        }
+    }
+    // Patterns are only checked at the empty path at the moment
+    hasEffectsOnInteractionAtPath(_path, interaction, context) {
+        for (const element of this.elements) {
+            if (element?.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
+                return true;
+        }
+        return false;
+    }
+    markDeclarationReached() {
+        for (const element of this.elements) {
+            element?.markDeclarationReached();
+        }
+    }
+}
+class ArrowFunctionExpression extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    get expression() {
+        return isFlagSet(this.flags, 8388608 /* Flag.expression */);
+    }
+    set expression(value) {
+        this.flags = setFlag(this.flags, 8388608 /* Flag.expression */, value);
+    }
+    createScope(parentScope) {
+        this.scope = new ReturnValueScope(parentScope, false);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context)) {
+            return true;
+        }
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        if (interaction.type === INTERACTION_CALLED) {
+            const { ignore, brokenFlow } = context;
+            context.ignore = {
+                breaks: false,
+                continues: false,
+                labels: new Set(),
+                returnYield: true,
+                this: false
+            };
+            if (this.body.hasEffects(context))
+                return true;
+            context.ignore = ignore;
+            context.brokenFlow = brokenFlow;
+        }
+        return false;
+    }
+    onlyFunctionCallUsed() {
+        const isIIFE = this.parent.type === parseAst_js.CallExpression &&
+            this.parent.callee === this;
+        return isIIFE || super.onlyFunctionCallUsed();
+    }
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        for (const parameter of this.params) {
+            if (!(parameter instanceof Identifier)) {
+                parameter.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([], OBJECT_PROTOTYPE));
+    }
+}
+class ObjectPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        for (const property of this.properties) {
+            if (property.type === parseAst_js.Property) {
+                property.value.addExportedVariables(variables, exportNamesByVariable);
+            }
+            else {
+                property.argument.addExportedVariables(variables, exportNamesByVariable);
+            }
+        }
+    }
+    declare(kind, init) {
+        const variables = [];
+        for (const property of this.properties) {
+            variables.push(...property.declare(kind, init));
+        }
+        return variables;
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            for (const property of this.properties) {
+                property.deoptimizePath(path);
+            }
+        }
+    }
+    hasEffectsOnInteractionAtPath(
+    // At the moment, this is only triggered for assignment left-hand sides,
+    // where the path is empty
+    _path, interaction, context) {
+        for (const property of this.properties) {
+            if (property.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
+                return true;
+        }
+        return false;
+    }
+    markDeclarationReached() {
+        for (const property of this.properties) {
+            property.markDeclarationReached();
+        }
+    }
+}
+class AssignmentExpression extends NodeBase {
+    hasEffects(context) {
+        const { deoptimized, left, operator, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        // MemberExpressions do not access the property before assignments if the
+        // operator is '='.
+        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, operator !== '='));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        const { deoptimized, left, right, operator } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        if (includeChildrenRecursively ||
+            operator !== '=' ||
+            left.included ||
+            left.hasEffectsAsAssignmentTarget(createHasEffectsContext(), false)) {
+            left.includeAsAssignmentTarget(context, includeChildrenRecursively, operator !== '=');
+        }
+        right.include(context, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        if (this.left instanceof Identifier) {
+            const variable = this.scope.variables.get(this.left.name);
+            if (variable?.kind === 'const') {
+                this.scope.context.error(parseAst_js.logConstVariableReassignError(), this.left.start);
+            }
+        }
+        this.left.setAssignedValue(this.right);
+    }
+    render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
+        const { left, right, start, end, parent } = this;
+        if (left.included) {
+            left.render(code, options);
+            right.render(code, options);
+        }
+        else {
+            const inclusionStart = findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, '=', left.end) + 1);
+            code.remove(start, inclusionStart);
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, right.start);
+            }
+            right.render(code, options, {
+                renderedParentType: renderedParentType || parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || parent.type
+            });
+        }
+        if (options.format === 'system') {
+            if (left instanceof Identifier) {
+                const variable = left.variable;
+                const exportNames = options.exportNamesByVariable.get(variable);
+                if (exportNames) {
+                    if (exportNames.length === 1) {
+                        renderSystemExportExpression(variable, start, end, code, options);
+                    }
+                    else {
+                        renderSystemExportSequenceAfterExpression(variable, start, end, parent.type !== parseAst_js.ExpressionStatement, code, options);
+                    }
+                    return;
+                }
+            }
+            else {
+                const systemPatternExports = [];
+                left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
+                if (systemPatternExports.length > 0) {
+                    renderSystemExportFunction(systemPatternExports, start, end, renderedSurroundingElement === parseAst_js.ExpressionStatement, code, options);
+                    return;
+                }
+            }
+        }
+        if (left.included &&
+            left instanceof ObjectPattern &&
+            (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
+                renderedSurroundingElement === parseAst_js.ArrowFunctionExpression)) {
+            code.appendRight(start, '(');
+            code.prependLeft(end, ')');
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+class AssignmentPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.left.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        return this.left.declare(kind, init);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.left.deoptimizePath(path);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 || this.left.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
+    }
+    markDeclarationReached() {
+        this.left.markDeclarationReached();
+    }
+    render(code, options, { isShorthandProperty } = parseAst_js.BLANK) {
+        this.left.render(code, options, { isShorthandProperty });
+        this.right.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+class AwaitExpression extends NodeBase {
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            checkTopLevelAwait: if (!this.scope.context.usesTopLevelAwait) {
+                let parent = this.parent;
+                do {
+                    if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression)
+                        break checkTopLevelAwait;
+                } while ((parent = parent.parent));
+                this.scope.context.usesTopLevelAwait = true;
+            }
+        }
+        this.argument.include(context, includeChildrenRecursively);
+    }
+}
+const binaryOperators = {
+    '!=': (left, right) => left != right,
+    '!==': (left, right) => left !== right,
+    '%': (left, right) => left % right,
+    '&': (left, right) => left & right,
+    '*': (left, right) => left * right,
+    // At the moment, "**" will be transpiled to Math.pow
+    '**': (left, right) => left ** right,
+    '+': (left, right) => left + right,
+    '-': (left, right) => left - right,
+    '/': (left, right) => left / right,
+    '<': (left, right) => left < right,
+    '<<': (left, right) => left << right,
+    '<=': (left, right) => left <= right,
+    '==': (left, right) => left == right,
+    '===': (left, right) => left === right,
+    '>': (left, right) => left > right,
+    '>=': (left, right) => left >= right,
+    '>>': (left, right) => left >> right,
+    '>>>': (left, right) => left >>> right,
+    '^': (left, right) => left ^ right,
+    '|': (left, right) => left | right
+    // We use the fallback for cases where we return something unknown
+    // in: () => UnknownValue,
+    // instanceof: () => UnknownValue,
+};
+class BinaryExpression extends NodeBase {
+    deoptimizeCache() { }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length > 0)
+            return UnknownValue;
+        const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof leftValue === 'symbol')
+            return UnknownValue;
+        const rightValue = this.right.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof rightValue === 'symbol')
+            return UnknownValue;
+        const operatorFunction = binaryOperators[this.operator];
+        if (!operatorFunction)
+            return UnknownValue;
+        return operatorFunction(leftValue, rightValue);
+    }
+    hasEffects(context) {
+        // support some implicit type coercion runtime errors
+        if (this.operator === '+' &&
+            this.parent instanceof ExpressionStatement &&
+            this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '') {
+            return true;
+        }
+        return super.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
+    removeAnnotations(code) {
+        this.left.removeAnnotations(code);
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        this.left.render(code, options, { renderedSurroundingElement });
+        this.right.render(code, options);
+    }
+}
+class BreakStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.label) {
+            if (!context.ignore.labels.has(this.label.name))
+                return true;
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            if (!context.ignore.breaks)
+                return true;
+            context.hasBreak = true;
+        }
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context) {
+        this.included = true;
+        if (this.label) {
+            this.label.include();
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            context.hasBreak = true;
+        }
+        context.brokenFlow = true;
+    }
+}
+function renderCallArguments(code, options, node) {
+    if (node.arguments.length > 0) {
+        if (node.arguments[node.arguments.length - 1].included) {
+            for (const argument of node.arguments) {
+                argument.render(code, options);
+            }
+        }
+        else {
+            let lastIncludedIndex = node.arguments.length - 2;
+            while (lastIncludedIndex >= 0 && !node.arguments[lastIncludedIndex].included) {
+                lastIncludedIndex--;
+            }
+            if (lastIncludedIndex >= 0) {
+                for (let index = 0; index <= lastIncludedIndex; index++) {
+                    node.arguments[index].render(code, options);
+                }
+                code.remove(findFirstOccurrenceOutsideComment(code.original, ',', node.arguments[lastIncludedIndex].end), node.end - 1);
+            }
+            else {
+                code.remove(findFirstOccurrenceOutsideComment(code.original, '(', node.callee.end) + 1, node.end - 1);
+            }
+        }
+    }
+}
+class CallExpressionBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.returnExpression = null;
+        this.deoptimizableDependentExpressions = [];
+        this.expressionsToBeDeoptimized = new Set();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        const { args } = interaction;
+        const [returnExpression, isPure] = this.getReturnExpression(recursionTracker);
+        if (isPure)
+            return;
+        const deoptimizedExpressions = args.filter(expression => !!expression && expression !== UNKNOWN_EXPRESSION);
+        if (deoptimizedExpressions.length === 0)
+            return;
+        if (returnExpression === UNKNOWN_EXPRESSION) {
+            for (const expression of deoptimizedExpressions) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        else {
+            recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+                for (const expression of deoptimizedExpressions) {
+                    this.expressionsToBeDeoptimized.add(expression);
+                }
+                returnExpression.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+            }, null);
+        }
+    }
+    deoptimizeCache() {
+        if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            const { deoptimizableDependentExpressions, expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_SET;
+            this.deoptimizableDependentExpressions = parseAst_js.EMPTY_ARRAY;
+            for (const expression of deoptimizableDependentExpressions) {
+                expression.deoptimizeCache();
+            }
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 ||
+            this.scope.context.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
+            return;
+        }
+        const [returnExpression] = this.getReturnExpression();
+        if (returnExpression !== UNKNOWN_EXPRESSION) {
+            returnExpression.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const [returnExpression] = this.getReturnExpression(recursionTracker);
+        if (returnExpression === UNKNOWN_EXPRESSION) {
+            return UnknownValue;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+            this.deoptimizableDependentExpressions.push(origin);
+            return returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+        }, UnknownValue);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const returnExpression = this.getReturnExpression(recursionTracker);
+        if (returnExpression[0] === UNKNOWN_EXPRESSION) {
+            return returnExpression;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+            this.deoptimizableDependentExpressions.push(origin);
+            const [expression, isPure] = returnExpression[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+            return [expression, isPure || returnExpression[1]];
+        }, UNKNOWN_RETURN_EXPRESSION);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (type === INTERACTION_CALLED) {
+            const { args, withNew } = interaction;
+            if ((withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, args, this)) {
+                return false;
+            }
+        }
+        else if ((type === INTERACTION_ASSIGNED
+            ? context.assigned
+            : context.accessed).trackEntityAtPathAndGetIfTracked(path, this)) {
+            return false;
+        }
+        const [returnExpression, isPure] = this.getReturnExpression();
+        return ((type === INTERACTION_ASSIGNED || !isPure) &&
+            returnExpression.hasEffectsOnInteractionAtPath(path, interaction, context));
+    }
+}
+class CallExpression extends CallExpressionBase {
+    get optional() {
+        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
+    set optional(value) {
+        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
+    bind() {
+        super.bind();
+        if (this.callee instanceof Identifier) {
+            const variable = this.scope.findVariable(this.callee.name);
+            if (variable.isNamespace) {
+                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logCannotCallNamespace(this.callee.name), this.start);
+            }
+            if (this.callee.name === 'eval') {
+                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logEval(this.scope.context.module.id), this.start);
+            }
+        }
+        this.interaction = {
+            args: [
+                this.callee instanceof MemberExpression && !this.callee.variable
+                    ? this.callee.object
+                    : null,
+                ...this.arguments
+            ],
+            type: INTERACTION_CALLED,
+            withNew: false
+        };
+    }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        return getChainElementLiteralValueAtPath(this, this.callee, path, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        if (this.annotationPure) {
+            return false;
+        }
+        return (this.callee.hasEffects(context) ||
+            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
+    hasEffectsAsChainElement(context) {
+        const calleeHasEffects = 'hasEffectsAsChainElement' in this.callee
+            ? this.callee.hasEffectsAsChainElement(context)
+            : this.callee.hasEffects(context);
+        if (calleeHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.callee.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return (!this.annotationPure && calleeHasEffects) || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        return (!this.annotationPure &&
+            (calleeHasEffects ||
+                this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context)));
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+            if (includeChildrenRecursively === INCLUDE_PARAMETERS &&
+                this.callee instanceof Identifier &&
+                this.callee.variable) {
+                this.callee.variable.markCalledFromTryStatement();
+            }
+        }
+        else {
+            this.included = true;
+            this.callee.include(context, false);
+        }
+        this.callee.includeCallArguments(context, this.arguments);
+    }
+    initialise() {
+        super.initialise();
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
+        }
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        this.callee.render(code, options, {
+            isCalleeOfRenderedParent: true,
+            renderedSurroundingElement
+        });
+        renderCallArguments(code, options, this);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.callee.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+        this.scope.context.requestTreeshakingPass();
+    }
+    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
+}
+class CatchClause extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new ParameterScope(parentScope, true);
+    }
+    parseNode(esTreeNode) {
+        const { body, param, type } = esTreeNode;
+        this.type = type;
+        if (param) {
+            this.param = new (this.scope.context.getNodeConstructor(param.type))(this, this.scope).parseNode(param);
+            this.param.declare('parameter', UNKNOWN_EXPRESSION);
+        }
+        this.body = new BlockStatement(this, this.scope.bodyScope).parseNode(body);
+        return super.parseNode(esTreeNode);
+    }
+}
+CatchClause.prototype.preventChildBlockScope = true;
+class ChainExpression extends NodeBase {
+    // deoptimizations are not relevant as we are not caching values
+    deoptimizeCache() { }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const literalValue = this.expression.getLiteralValueAtPathAsChainElement(path, recursionTracker, origin);
+        return literalValue === IS_SKIPPED_CHAIN ? undefined : literalValue;
+    }
+    hasEffects(context) {
+        return this.expression.hasEffectsAsChainElement(context) === true;
+    }
+    removeAnnotations(code) {
+        this.expression.removeAnnotations(code);
+    }
+    applyDeoptimizations() { }
+}
+class ClassBodyScope extends ChildScope {
+    constructor(parent, classNode) {
+        const { context } = parent;
+        super(parent, context);
+        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, context, 'other')));
+        this.instanceScope = new ChildScope(this, context);
+        this.instanceScope.variables.set('this', new ThisVariable(context));
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+}
+class ClassBody extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new ClassBodyScope(parentScope, this.parent);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.scope.context.includeVariableInModule(this.scope.thisVariable);
+        for (const definition of this.body) {
+            definition.include(context, includeChildrenRecursively);
+        }
+    }
+    parseNode(esTreeNode) {
+        const body = (this.body = new Array(esTreeNode.body.length));
+        let index = 0;
+        for (const definition of esTreeNode.body) {
+            body[index++] = new (this.scope.context.getNodeConstructor(definition.type))(this, definition.static ? this.scope : this.scope.instanceScope).parseNode(definition);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    applyDeoptimizations() { }
+}
+class ClassExpression extends ClassNode {
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+}
+class MultiExpression extends ExpressionEntity {
+    constructor(expressions) {
+        super();
+        this.expressions = expressions;
+    }
+    deoptimizePath(path) {
+        for (const expression of this.expressions) {
+            expression.deoptimizePath(path);
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return [
+            new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0])),
+            false
+        ];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        for (const expression of this.expressions) {
+            if (expression.hasEffectsOnInteractionAtPath(path, interaction, context))
+                return true;
+        }
+        return false;
+    }
+}
+class ConditionalExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.expressionsToBeDeoptimized = [];
+        this.usedBranch = null;
+    }
+    get isBranchResolutionAnalysed() {
+        return isFlagSet(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */);
+    }
+    set isBranchResolutionAnalysed(value) {
+        this.flags = setFlag(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.consequent.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        this.alternate.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        if (this.usedBranch !== null) {
+            const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
+            this.usedBranch = null;
+            unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            const { expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+        }
+    }
+    deoptimizePath(path) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.deoptimizePath(path);
+        }
+        else {
+            this.consequent.deoptimizePath(path);
+            this.alternate.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return UnknownValue;
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return [
+                new MultiExpression([
+                    this.consequent.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.alternate.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return this.consequent.hasEffects(context) || this.alternate.hasEffects(context);
+        }
+        return usedBranch.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return (this.consequent.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.alternate.hasEffectsOnInteractionAtPath(path, interaction, context));
+        }
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const usedBranch = this.getUsedBranch();
+        if (includeChildrenRecursively || this.test.shouldBeIncluded(context) || usedBranch === null) {
+            this.test.include(context, includeChildrenRecursively);
+            this.consequent.include(context, includeChildrenRecursively);
+            this.alternate.include(context, includeChildrenRecursively);
+        }
+        else {
+            usedBranch.include(context, includeChildrenRecursively);
+        }
+    }
+    includeCallArguments(context, parameters) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.includeCallArguments(context, parameters);
+        }
+        else {
+            this.consequent.includeCallArguments(context, parameters);
+            this.alternate.includeCallArguments(context, parameters);
+        }
+    }
+    removeAnnotations(code) {
+        this.test.removeAnnotations(code);
+    }
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
+        const usedBranch = this.getUsedBranch();
+        if (this.test.included) {
+            this.test.render(code, options, { renderedSurroundingElement });
+            this.consequent.render(code, options);
+            this.alternate.render(code, options);
+        }
+        else {
+            const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
+            const inclusionStart = findNonWhiteSpace(code.original, (this.consequent.included
+                ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
+                : colonPos) + 1);
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, usedBranch.start);
+            }
+            code.remove(this.start, inclusionStart);
+            if (this.consequent.included) {
+                code.remove(colonPos, this.end);
+            }
+            this.test.removeAnnotations(code);
+            usedBranch.render(code, options, {
+                isCalleeOfRenderedParent,
+                preventASI: true,
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
+            });
+        }
+    }
+    getUsedBranch() {
+        if (this.isBranchResolutionAnalysed) {
+            return this.usedBranch;
+        }
+        this.isBranchResolutionAnalysed = true;
+        const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        return typeof testValue === 'symbol'
+            ? null
+            : (this.usedBranch = testValue ? this.consequent : this.alternate);
+    }
+}
+class ContinueStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.label) {
+            if (!context.ignore.labels.has(this.label.name))
+                return true;
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            if (!context.ignore.continues)
+                return true;
+            context.hasContinue = true;
+        }
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context) {
+        this.included = true;
+        if (this.label) {
+            this.label.include();
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            context.hasContinue = true;
+        }
+        context.brokenFlow = true;
+    }
+}
+class DebuggerStatement extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+}
+class Decorator extends NodeBase {
+    hasEffects(context) {
+        return (this.expression.hasEffects(context) ||
+            this.expression.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context));
+    }
+}
+function hasLoopBodyEffects(context, body) {
+    const { brokenFlow, hasBreak, hasContinue, ignore } = context;
+    const { breaks, continues } = ignore;
+    ignore.breaks = true;
+    ignore.continues = true;
+    context.hasBreak = false;
+    context.hasContinue = false;
+    if (body.hasEffects(context))
+        return true;
+    ignore.breaks = breaks;
+    ignore.continues = continues;
+    context.hasBreak = hasBreak;
+    context.hasContinue = hasContinue;
+    context.brokenFlow = brokenFlow;
+    return false;
+}
+function includeLoopBody(context, body, includeChildrenRecursively) {
+    const { brokenFlow, hasBreak, hasContinue } = context;
+    context.hasBreak = false;
+    context.hasContinue = false;
+    body.include(context, includeChildrenRecursively, { asSingleStatement: true });
+    context.hasBreak = hasBreak;
+    context.hasContinue = hasContinue;
+    context.brokenFlow = brokenFlow;
+}
+class DoWhileStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.test.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+}
+class EmptyStatement extends NodeBase {
+    hasEffects() {
+        return false;
+    }
+}
+class ExportAllDeclaration extends NodeBase {
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addExport(this);
+    }
+    render(code, _options, nodeRenderOptions) {
+        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
+    applyDeoptimizations() { }
+}
+ExportAllDeclaration.prototype.needsBoundaries = true;
+class ExportNamedDeclaration extends NodeBase {
+    bind() {
+        // Do not bind specifiers
+        this.declaration?.bind();
+    }
+    hasEffects(context) {
+        return !!this.declaration?.hasEffects(context);
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addExport(this);
+    }
+    removeAnnotations(code) {
+        this.declaration?.removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions) {
+        const { start, end } = nodeRenderOptions;
+        if (this.declaration === null) {
+            code.remove(start, end);
+        }
+        else {
+            code.remove(this.start, this.declaration.start);
+            this.declaration.render(code, options, { end, start });
+        }
+    }
+    applyDeoptimizations() { }
+}
+ExportNamedDeclaration.prototype.needsBoundaries = true;
+class ExportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+class ForInStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        if (left.hasEffectsAsAssignmentTarget(context, false) || right.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, body);
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "in" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 110 /* n */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+class ForOfStatement extends NodeBase {
+    get await() {
+        return isFlagSet(this.flags, 131072 /* Flag.await */);
+    }
+    set await(value) {
+        this.flags = setFlag(this.flags, 131072 /* Flag.await */, value);
+    }
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        // Placeholder until proper Symbol.Iterator support
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "of" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 102 /* f */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+class ForStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.init?.hasEffects(context) ||
+            this.test?.hasEffects(context) ||
+            this.update?.hasEffects(context)) {
+            return true;
+        }
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.init?.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        this.test?.include(context, includeChildrenRecursively);
+        this.update?.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+    render(code, options) {
+        this.init?.render(code, options, NO_SEMICOLON);
+        this.test?.render(code, options, NO_SEMICOLON);
+        this.update?.render(code, options, NO_SEMICOLON);
+        this.body.render(code, options);
+    }
+}
+class FunctionExpression extends FunctionNode {
+    createScope(parentScope) {
+        super.createScope((this.idScope = new ChildScope(parentScope, parentScope.context)));
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.idScope).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    onlyFunctionCallUsed() {
+        const isIIFE = this.parent.type === parseAst_js.CallExpression &&
+            this.parent.callee === this &&
+            (this.id === null || this.id.variable.getOnlyFunctionCallUsed());
+        return isIIFE || super.onlyFunctionCallUsed();
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+}
+class TrackingScope extends BlockScope {
+    constructor() {
+        super(...arguments);
+        this.hoistedDeclarations = [];
+    }
+    addDeclaration(identifier, context, init, kind) {
+        this.hoistedDeclarations.push(identifier);
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+const unset = Symbol('unset');
+class IfStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.testValue = unset;
+    }
+    deoptimizeCache() {
+        this.testValue = UnknownValue;
+    }
+    hasEffects(context) {
+        if (this.test.hasEffects(context)) {
+            return true;
+        }
+        const testValue = this.getTestValue();
+        if (typeof testValue === 'symbol') {
+            const { brokenFlow } = context;
+            if (this.consequent.hasEffects(context))
+                return true;
+            const consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+            if (this.alternate === null)
+                return false;
+            if (this.alternate.hasEffects(context))
+                return true;
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+            return false;
+        }
+        return testValue ? this.consequent.hasEffects(context) : !!this.alternate?.hasEffects(context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        if (includeChildrenRecursively) {
+            this.includeRecursively(includeChildrenRecursively, context);
+        }
+        else {
+            const testValue = this.getTestValue();
+            if (typeof testValue === 'symbol') {
+                this.includeUnknownTest(context);
+            }
+            else {
+                this.includeKnownTest(context, testValue);
+            }
+        }
+    }
+    parseNode(esTreeNode) {
+        this.consequent = new (this.scope.context.getNodeConstructor(esTreeNode.consequent.type))(this, (this.consequentScope = new TrackingScope(this.scope))).parseNode(esTreeNode.consequent);
+        if (esTreeNode.alternate) {
+            this.alternate = new (this.scope.context.getNodeConstructor(esTreeNode.alternate.type))(this, (this.alternateScope = new TrackingScope(this.scope))).parseNode(esTreeNode.alternate);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { snippets: { getPropertyAccess } } = options;
+        // Note that unknown test values are always included
+        const testValue = this.getTestValue();
+        const hoistedDeclarations = [];
+        const includesIfElse = this.test.included;
+        const noTreeshake = !this.scope.context.options.treeshake;
+        if (includesIfElse) {
+            this.test.render(code, options);
+        }
+        else {
+            code.remove(this.start, this.consequent.start);
+        }
+        if (this.consequent.included && (noTreeshake || typeof testValue === 'symbol' || testValue)) {
+            this.consequent.render(code, options);
+        }
+        else {
+            code.overwrite(this.consequent.start, this.consequent.end, includesIfElse ? ';' : '');
+            hoistedDeclarations.push(...this.consequentScope.hoistedDeclarations);
+        }
+        if (this.alternate) {
+            if (this.alternate.included && (noTreeshake || typeof testValue === 'symbol' || !testValue)) {
+                if (includesIfElse) {
+                    if (code.original.charCodeAt(this.alternate.start - 1) === 101) {
+                        code.prependLeft(this.alternate.start, ' ');
+                    }
+                }
+                else {
+                    code.remove(this.consequent.end, this.alternate.start);
+                }
+                this.alternate.render(code, options);
+            }
+            else {
+                if (includesIfElse && this.shouldKeepAlternateBranch()) {
+                    code.overwrite(this.alternate.start, this.end, ';');
+                }
+                else {
+                    code.remove(this.consequent.end, this.end);
+                }
+                hoistedDeclarations.push(...this.alternateScope.hoistedDeclarations);
+            }
+        }
+        this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
+    }
+    applyDeoptimizations() { }
+    getTestValue() {
+        if (this.testValue === unset) {
+            return (this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
+        }
+        return this.testValue;
+    }
+    includeKnownTest(context, testValue) {
+        if (this.test.shouldBeIncluded(context)) {
+            this.test.include(context, false);
+        }
+        if (testValue && this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+        }
+        if (!testValue && this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+        }
+    }
+    includeRecursively(includeChildrenRecursively, context) {
+        this.test.include(context, includeChildrenRecursively);
+        this.consequent.include(context, includeChildrenRecursively);
+        this.alternate?.include(context, includeChildrenRecursively);
+    }
+    includeUnknownTest(context) {
+        this.test.include(context, false);
+        const { brokenFlow } = context;
+        let consequentBrokenFlow = false;
+        if (this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+            consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+        }
+        if (this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+        }
+    }
+    renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess) {
+        const hoistedVariables = [
+            ...new Set(hoistedDeclarations.map(identifier => {
+                const variable = identifier.variable;
+                return variable.included ? variable.getName(getPropertyAccess) : '';
+            }))
+        ]
+            .filter(Boolean)
+            .join(', ');
+        if (hoistedVariables) {
+            const parentType = this.parent.type;
+            const needsBraces = parentType !== parseAst_js.Program && parentType !== parseAst_js.BlockStatement;
+            code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVariables}; `);
+            if (needsBraces) {
+                code.appendLeft(this.end, ` }`);
+            }
+        }
+    }
+    shouldKeepAlternateBranch() {
+        let currentParent = this.parent;
+        do {
+            if (currentParent instanceof IfStatement && currentParent.alternate) {
+                return true;
+            }
+            if (currentParent instanceof BlockStatement) {
+                return false;
+            }
+            currentParent = currentParent.parent;
+        } while (currentParent);
+        return false;
+    }
+}
+class ImportAttribute extends NodeBase {
+}
+class ImportDeclaration extends NodeBase {
+    // Do not bind specifiers or attributes
+    bind() { }
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addImport(this);
+    }
+    render(code, _options, nodeRenderOptions) {
+        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
+    applyDeoptimizations() { }
+}
+ImportDeclaration.prototype.needsBoundaries = true;
+class ImportDefaultSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
 function isReassignedExportsMember(variable, exportNamesByVariable) {
     return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
 …
+}
+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 FILE_PREFIX = 'ROLLUP_FILE_URL_';
-const IMPORT = 'import';
-class MetaProperty extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.metaProperty = null;
-        this.preliminaryChunkId = null;
-        this.referenceId = null;
+    }
-    getReferencedFileName(outputPluginDriver) {
-        const { meta: { name }, metaProperty } = this;
-        if (name === IMPORT && metaProperty?.startsWith(FILE_PREFIX)) {
-            return outputPluginDriver.getFileName(metaProperty.slice(FILE_PREFIX.length));
+        }
-        return null;
+    }
-    hasEffects() {
-        return false;
+    }
-    hasEffectsOnInteractionAtPath(path, { type }) {
-        return path.length > 1 || type !== INTERACTION_ACCESSED;
+    }
-    include() {
-        if (!this.included) {
-            this.included = true;
-            if (this.meta.name === IMPORT) {
-                this.scope.context.addImportMeta(this);
-                const parent = this.parent;
-                const metaProperty = (this.metaProperty =
-                    parent instanceof MemberExpression && typeof parent.propertyKey === 'string'
-                        ? parent.propertyKey
-                        : null);
-                if (metaProperty?.startsWith(FILE_PREFIX)) {
-                    this.referenceId = metaProperty.slice(FILE_PREFIX.length);
+                }
+            }
+        }
+    }
-    render(code, renderOptions) {
-        const { format, pluginDriver, snippets } = renderOptions;
-        const { scope: { context: { module } }, meta: { name }, metaProperty, parent, preliminaryChunkId, referenceId, start, end } = this;
-        const { id: moduleId } = module;
-        if (name !== IMPORT)
-            return;
-        const chunkId = preliminaryChunkId;
-        if (referenceId) {
-            const fileName = pluginDriver.getFileName(referenceId);
-            const relativePath = parseAst_js.normalize(path$2.relative(path$2.dirname(chunkId), fileName));
-            const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
-                { chunkId, fileName, format, moduleId, referenceId, relativePath }
-            ]) || relativeUrlMechanisms[format](relativePath);
-            code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
-            return;
+        }
-        let replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
-            metaProperty,
-            { chunkId, format, moduleId }
-        ]);
-        if (!replacement) {
-            replacement = importMetaMechanisms[format]?.(metaProperty, { chunkId, snippets });
-            renderOptions.accessedDocumentCurrentScript ||=
-                formatsMaybeAccessDocumentCurrentScript.includes(format) && replacement !== 'undefined';
+        }
-        if (typeof replacement === 'string') {
-            if (parent instanceof MemberExpression) {
-                code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
+            }
-            else {
-                code.overwrite(start, end, replacement, { contentOnly: true });
+            }
+        }
+    }
-    setResolution(format, accessedGlobalsByScope, preliminaryChunkId) {
-        this.preliminaryChunkId = preliminaryChunkId;
-        const accessedGlobals = (this.metaProperty?.startsWith(FILE_PREFIX) ? accessedFileUrlGlobals : accessedMetaUrlGlobals)[format];
-        if (accessedGlobals.length > 0) {
-            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
+        }
+    }
+}
-const formatsMaybeAccessDocumentCurrentScript = ['cjs', 'iife', 'umd'];
-const accessedMetaUrlGlobals = {
-    amd: ['document', 'module', 'URL'],
-    cjs: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT],
-    es: [],
-    iife: ['document', 'URL', DOCUMENT_CURRENT_SCRIPT],
-    system: ['module'],
-    umd: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT]
-};
-const accessedFileUrlGlobals = {
-    amd: ['document', 'require', 'URL'],
-    cjs: ['document', 'require', 'URL'],
-    es: [],
-    iife: ['document', 'URL'],
-    system: ['module', 'URL'],
-    umd: ['document', 'require', 'URL']
-};
-const getResolveUrl = (path, URL = 'URL') => `new ${URL}(${path}).href`;
-const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${escapeId(relativePath)}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ''}document.currentScript && document.currentScript.src || document.baseURI`);
-const getGenericImportMetaMechanism = (getUrl) => (property, { chunkId }) => {
-    const urlMechanism = getUrl(chunkId);
-    return property === null
-        ? `({ url: ${urlMechanism} })`
-        : property === 'url'
-            ? urlMechanism
-            : 'undefined';
-};
-const getFileUrlFromFullPath = (path) => `require('u' + 'rl').pathToFileURL(${path}).href`;
-const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${escapeId(path)}'`);
-const getUrlFromDocument = (chunkId, umd = false) => `${umd ? `typeof document === 'undefined' ? location.href : ` : ''}(${DOCUMENT_CURRENT_SCRIPT} && ${DOCUMENT_CURRENT_SCRIPT}.src || new URL('${escapeId(chunkId)}', document.baseURI).href)`;
-const relativeUrlMechanisms = {
-    amd: relativePath => {
-        if (relativePath[0] !== '.')
-            relativePath = './' + relativePath;
-        return getResolveUrl(`require.toUrl('${escapeId(relativePath)}'), document.baseURI`);
-    },
-    cjs: relativePath => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath)})`,
-    es: relativePath => getResolveUrl(`'${escapeId(relativePath)}', import.meta.url`),
-    iife: relativePath => getRelativeUrlFromDocument(relativePath),
-    system: relativePath => getResolveUrl(`'${escapeId(relativePath)}', module.meta.url`),
-    umd: relativePath => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath, true)})`
-};
-const importMetaMechanisms = {
-    amd: getGenericImportMetaMechanism(() => getResolveUrl(`module.uri, document.baseURI`)),
-    cjs: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId)})`),
-    iife: getGenericImportMetaMechanism(chunkId => getUrlFromDocument(chunkId)),
-    system: (property, { snippets: { getPropertyAccess } }) => property === null ? `module.meta` : `module.meta${getPropertyAccess(property)}`,
-    umd: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId, true)})`)
-};
 class NewExpression extends NodeBase {
     hasEffects(context) {
 …
     render(code, options, nodeRenderOptions) {
         if (this.consequent.length > 0) {
+            this.test && this.test.render(code, options);
+            if (this.test) {
+                this.test.render(code, options);
+            }
             const testEnd = this.test
                 ? this.test.end
 …
         code.indentExclusionRanges.push([this.start, this.end]);
         super.render(code, options);
+    }
+}
-class UndefinedVariable extends Variable {
-    constructor() {
-        super('undefined');
+    }
-    getLiteralValueAtPath() {
-        return undefined;
+    }
+}
-class ExportDefaultVariable extends LocalVariable {
-    constructor(name, exportDefaultDeclaration, context) {
-        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, 'other');
-        this.hasId = false;
-        this.originalId = null;
-        this.originalVariable = null;
-        const declaration = exportDefaultDeclaration.declaration;
-        if ((declaration instanceof FunctionDeclaration || declaration instanceof ClassDeclaration) &&
-            declaration.id) {
-            this.hasId = true;
-            this.originalId = declaration.id;
+        }
-        else if (declaration instanceof Identifier) {
-            this.originalId = declaration;
+        }
+    }
-    addReference(identifier) {
-        if (!this.hasId) {
-            this.name = identifier.name;
+        }
+    }
-    addUsedPlace(usedPlace) {
-        const original = this.getOriginalVariable();
-        if (original === this) {
-            super.addUsedPlace(usedPlace);
+        }
-        else {
-            original.addUsedPlace(usedPlace);
+        }
+    }
-    forbidName(name) {
-        const original = this.getOriginalVariable();
-        if (original === this) {
-            super.forbidName(name);
+        }
-        else {
-            original.forbidName(name);
+        }
+    }
-    getAssignedVariableName() {
-        return (this.originalId && this.originalId.name) || null;
+    }
-    getBaseVariableName() {
-        const original = this.getOriginalVariable();
-        return original === this ? super.getBaseVariableName() : original.getBaseVariableName();
+    }
-    getDirectOriginalVariable() {
-        return this.originalId &&
-            (this.hasId ||
-                !(this.originalId.isPossibleTDZ() ||
-                    this.originalId.variable.isReassigned ||
-                    this.originalId.variable instanceof UndefinedVariable ||
-                    // this avoids a circular dependency
-                    'syntheticNamespace' in this.originalId.variable))
-            ? this.originalId.variable
-            : null;
+    }
-    getName(getPropertyAccess) {
-        const original = this.getOriginalVariable();
-        return original === this
-            ? super.getName(getPropertyAccess)
-            : original.getName(getPropertyAccess);
+    }
-    getOriginalVariable() {
-        if (this.originalVariable)
-            return this.originalVariable;
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let original = this;
-        let currentVariable;
-        const checkedVariables = new Set();
-        do {
-            checkedVariables.add(original);
-            currentVariable = original;
-            original = currentVariable.getDirectOriginalVariable();
-        } while (original instanceof ExportDefaultVariable && !checkedVariables.has(original));
-        return (this.originalVariable = original || currentVariable);
+    }
+}
 …
     'ImportNamespaceSpecifier',
     'ImportSpecifier',
+    'JSXAttribute',
+    'JSXClosingElement',
+    'JSXClosingFragment',
+    'JSXElement',
+    'JSXEmptyExpression',
+    'JSXExpressionContainer',
+    'JSXFragment',
+    'JSXIdentifier',
+    'JSXMemberExpression',
+    'JSXNamespacedName',
+    'JSXOpeningElement',
+    'JSXOpeningFragment',
+    'JSXSpreadAttribute',
+    'JSXSpreadChild',
+    'JSXText',
     'LabeledStatement',
     'Literal',
 …
     ImportNamespaceSpecifier,
     ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
     LabeledStatement,
     Literal,
 …
         const { scope } = node;
         const bodyPosition = buffer[position];
-        const body = (node.body = []);
         if (bodyPosition) {
             const length = buffer[bodyPosition];
+            const body = (node.body = new Array(length));
             for (let index = 0; index < length; index++) {
                 const nodePosition = buffer[bodyPosition + 1 + index];
+                body.push(convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer));
+            }
+                body[index] = convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer);
+            }
+        }
+        else {
+            node.body = [];
+        }
     },
 …
         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) {
 …
         return parseAst_js.EMPTY_ARRAY;
     const length = buffer[position++];
     const list = [];
+    const list = new Array(length);
     for (let index = 0; index < length; index++) {
         const nodePosition = buffer[position++];
         list.push(nodePosition ? convertNode(parent, parentScope, nodePosition, buffer) : null);
+        list[index] = nodePosition ? convertNode(parent, parentScope, nodePosition, buffer) : null;
+    }
     return list;
 …
     ImportNamespaceSpecifier,
     ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
     LabeledStatement,
     Literal,
 …
 };
-const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
 class ExportShimVariable extends Variable {
     constructor(module) {
 …
         super.include();
         this.module.needsExportShim = true;
+    }
+}
-class NamespaceVariable extends Variable {
-    constructor(context) {
-        super(context.getModuleName());
-        this.memberVariables = null;
-        this.mergedNamespaces = [];
-        this.referencedEarly = false;
-        this.references = [];
-        this.context = context;
-        this.module = context.module;
+    }
-    addReference(identifier) {
-        this.references.push(identifier);
-        this.name = identifier.name;
+    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (path.length > 1 || (path.length === 1 && interaction.type === INTERACTION_CALLED)) {
-            const key = path[0];
-            if (typeof key === 'string') {
-                this.getMemberVariables()[key]?.deoptimizeArgumentsOnInteractionAtPath(interaction, path.slice(1), recursionTracker);
+            }
-            else {
-                deoptimizeInteraction(interaction);
+            }
+        }
+    }
-    deoptimizePath(path) {
-        if (path.length > 1) {
-            const key = path[0];
-            if (typeof key === 'string') {
-                this.getMemberVariables()[key]?.deoptimizePath(path.slice(1));
+            }
+        }
+    }
-    getLiteralValueAtPath(path) {
-        if (path[0] === SymbolToStringTag) {
-            return 'Module';
+        }
-        return UnknownValue;
+    }
-    getMemberVariables() {
-        if (this.memberVariables) {
-            return this.memberVariables;
+        }
-        const memberVariables = Object.create(null);
-        const sortedExports = [...this.context.getExports(), ...this.context.getReexports()].sort();
-        for (const name of sortedExports) {
-            if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
-                const exportedVariable = this.context.traceExport(name);
-                if (exportedVariable) {
-                    memberVariables[name] = exportedVariable;
+                }
+            }
+        }
-        return (this.memberVariables = memberVariables);
+    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        const { type } = interaction;
-        if (path.length === 0) {
-            // This can only be a call anyway
-            return true;
+        }
-        if (path.length === 1 && type !== INTERACTION_CALLED) {
-            return type === INTERACTION_ASSIGNED;
+        }
-        const key = path[0];
-        if (typeof key !== 'string') {
-            return true;
+        }
-        const memberVariable = this.getMemberVariables()[key];
-        return (!memberVariable ||
-            memberVariable.hasEffectsOnInteractionAtPath(path.slice(1), interaction, context));
+    }
-    include() {
-        super.include();
-        this.context.includeAllExports();
+    }
-    prepare(accessedGlobalsByScope) {
-        if (this.mergedNamespaces.length > 0) {
-            this.module.scope.addAccessedGlobals([MERGE_NAMESPACES_VARIABLE], accessedGlobalsByScope);
+        }
+    }
-    renderBlock(options) {
-        const { exportNamesByVariable, format, freeze, indent: t, symbols, snippets: { _, cnst, getObject, getPropertyAccess, n, s } } = options;
-        const memberVariables = this.getMemberVariables();
-        const members = Object.entries(memberVariables)
-            .filter(([_, variable]) => variable.included)
-            .map(([name, variable]) => {
-            if (this.referencedEarly || variable.isReassigned || variable === this) {
-                return [
-                    null,
-                    `get ${stringifyObjectKeyIfNeeded(name)}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
-                ];
+            }
-            return [name, variable.getName(getPropertyAccess)];
-        });
-        members.unshift([null, `__proto__:${_}null`]);
-        let output = getObject(members, { lineBreakIndent: { base: '', t } });
-        if (this.mergedNamespaces.length > 0) {
-            const assignmentArguments = this.mergedNamespaces.map(variable => variable.getName(getPropertyAccess));
-            output = `/*#__PURE__*/${MERGE_NAMESPACES_VARIABLE}(${output},${_}[${assignmentArguments.join(`,${_}`)}])`;
+        }
-        else {
-            // The helper to merge namespaces will also take care of freezing and toStringTag
-            if (symbols) {
-                output = `/*#__PURE__*/Object.defineProperty(${output},${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)})`;
+            }
-            if (freeze) {
-                output = `/*#__PURE__*/Object.freeze(${output})`;
+            }
+        }
-        const name = this.getName(getPropertyAccess);
-        output = `${cnst} ${name}${_}=${_}${output};`;
-        if (format === 'system' && exportNamesByVariable.has(this)) {
-            output += `${n}${getSystemExportStatement([this], options)};`;
+        }
-        return output;
+    }
-    renderFirst() {
-        return this.referencedEarly;
+    }
-    setMergedNamespaces(mergedNamespaces) {
-        this.mergedNamespaces = mergedNamespaces;
-        const moduleExecIndex = this.context.getModuleExecIndex();
-        for (const identifier of this.references) {
-            const { context } = identifier.scope;
-            if (context.getModuleExecIndex() <= moduleExecIndex) {
-                this.referencedEarly = true;
-                break;
+            }
+        }
+    }
+}
-NamespaceVariable.prototype.isNamespace = true;
-class SyntheticNamedExportVariable extends Variable {
-    constructor(context, name, syntheticNamespace) {
-        super(name);
-        this.baseVariable = null;
-        this.context = context;
-        this.module = context.module;
-        this.syntheticNamespace = syntheticNamespace;
+    }
-    getBaseVariable() {
-        if (this.baseVariable)
-            return this.baseVariable;
-        let baseVariable = this.syntheticNamespace;
-        while (baseVariable instanceof ExportDefaultVariable ||
-            baseVariable instanceof SyntheticNamedExportVariable) {
-            if (baseVariable instanceof ExportDefaultVariable) {
-                const original = baseVariable.getOriginalVariable();
-                if (original === baseVariable)
-                    break;
-                baseVariable = original;
+            }
-            if (baseVariable instanceof SyntheticNamedExportVariable) {
-                baseVariable = baseVariable.syntheticNamespace;
+            }
+        }
-        return (this.baseVariable = baseVariable);
+    }
-    getBaseVariableName() {
-        return this.syntheticNamespace.getBaseVariableName();
+    }
-    getName(getPropertyAccess) {
-        return `${this.syntheticNamespace.getName(getPropertyAccess)}${getPropertyAccess(this.name)}`;
+    }
-    include() {
-        super.include();
-        this.context.includeVariableInModule(this.syntheticNamespace);
+    }
-    setRenderNames(baseName, name) {
-        super.setRenderNames(baseName, name);
+    }
+}
 …
+}
-function markModuleAndImpureDependenciesAsExecuted(baseModule) {
-    baseModule.isExecuted = true;
-    const modules = [baseModule];
-    const visitedModules = new Set();
-    for (const module of modules) {
-        for (const dependency of [...module.dependencies, ...module.implicitlyLoadedBefore]) {
-            if (!(dependency instanceof ExternalModule) &&
-                !dependency.isExecuted &&
-                (dependency.info.moduleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
-                !visitedModules.has(dependency.id)) {
-                dependency.isExecuted = true;
-                visitedModules.add(dependency.id);
-                modules.push(dependency);
+            }
+        }
+    }
+}
 const MISSING_EXPORT_SHIM_DESCRIPTION = {
     identifier: null,
 …
         this.dynamicImports = [];
         this.execIndex = Infinity;
+        this.hasTreeShakingPassStarted = false;
         this.implicitlyLoadedAfter = new Set();
         this.implicitlyLoadedBefore = new Set();
 …
             id,
             get implicitlyLoadedAfterOneOf() {
-                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(implicitlyLoadedAfter, getId).sort();
             },
             get implicitlyLoadedBefore() {
-                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(implicitlyLoadedBefore, getId).sort();
             },
             get importedIdResolutions() {
-                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(sourcesWithAttributes.keys(), source => module.resolvedIds[source]).filter(Boolean);
             },
 …
                 // We cannot use this.dependencies because this is needed before
                 // dependencies are populated
-                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(sourcesWithAttributes.keys(), source => module.resolvedIds[source]?.id).filter(Boolean);
             },
 …
+    }
     basename() {
         const base = path$2.basename(this.id);
         const extension = path$2.extname(this.id);
+        const base = path.basename(this.id);
+        const extension = path.extname(this.id);
         return makeLegal(extension ? base.slice(0, -extension.length) : base);
+    }
 …
+    }
     error(properties, pos) {
+        pos !== undefined && this.addLocationToLogProps(properties, pos);
+        if (pos !== undefined) {
+            this.addLocationToLogProps(properties, pos);
+        }
         return parseAst_js.error(properties);
+    }
 …
             addImport: this.addImport.bind(this),
             addImportMeta: this.addImportMeta.bind(this),
+            addImportSource: this.addImportSource.bind(this),
             code, // Only needed for debugging
             deoptimizationTracker: this.graph.deoptimizationTracker,
 …
             fileName, // Needed for warnings
             getExports: this.getExports.bind(this),
+            getImportedJsxFactoryVariable: this.getImportedJsxFactoryVariable.bind(this),
             getModuleExecIndex: () => this.execIndex,
             getModuleName: this.basename.bind(this),
 …
             // 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);
 …
             code: this.info.code,
             customTransformCache: this.customTransformCache,
-            // eslint-disable-next-line unicorn/prefer-spread
             dependencies: Array.from(this.dependencies, getId),
             id: this.id,
 …
                 start: specifier.start
             });
+        }
+    }
+    addImportSource(importSource) {
+        if (importSource && !this.sourcesWithAttributes.has(importSource)) {
+            this.sourcesWithAttributes.set(importSource, parseAst_js.EMPTY_OBJECT);
+        }
+    }
 …
+        }
+    }
+    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;
 …
     tryParse() {
         try {
             return parseAst_js.parseAst(this.info.code);
+            return parseAst_js.parseAst(this.info.code, { jsx: this.options.jsx !== false });
+        }
         catch (error_) {
 …
+}
 const copyNameToModulesMap = (searchedNamesAndModules) => searchedNamesAndModules &&
-    // eslint-disable-next-line unicorn/prefer-spread
     new Map(Array.from(searchedNamesAndModules, ([name, modules]) => [name, new Set(modules)]));
-function removeJsExtension(name) {
-    return name.endsWith('.js') ? name.slice(0, -3) : name;
+}
-function getCompleteAmdId(options, chunkId) {
-    if (options.autoId) {
-        return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
+    }
-    return options.id ?? '';
+}
-function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, mechanism = 'return ') {
-    const { _, getDirectReturnFunction, getFunctionIntro, getPropertyAccess, n, s } = snippets;
-    if (!namedExportsMode) {
-        return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess)};`;
+    }
-    let exportBlock = '';
-    if (namedExportsMode) {
-        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
-            if (!reexports) {
-                continue;
+            }
-            for (const specifier of reexports) {
-                if (specifier.reexported !== '*') {
-                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
-                    if (exportBlock)
-                        exportBlock += n;
-                    if (specifier.imported !== '*' && specifier.needsLiveBinding) {
-                        const [left, right] = getDirectReturnFunction([], {
-                            functionReturn: true,
-                            lineBreakIndent: null,
-                            name: null
-                        });
-                        exportBlock +=
-                            `Object.defineProperty(exports,${_}${JSON.stringify(specifier.reexported)},${_}{${n}` +
-                                `${t}enumerable:${_}true,${n}` +
-                                `${t}get:${_}${left}${importName}${right}${n}});`;
+                    }
-                    else if (specifier.reexported === '__proto__') {
-                        exportBlock +=
-                            `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
-                                `${t}enumerable:${_}true,${n}` +
-                                `${t}value:${_}${importName}${n}});`;
+                    }
-                    else {
-                        exportBlock += `exports${getPropertyAccess(specifier.reexported)}${_}=${_}${importName};`;
+                    }
+                }
+            }
+        }
+    }
-    for (const { exported, local } of exports) {
-        const lhs = `exports${getPropertyAccess(exported)}`;
-        const rhs = local;
-        if (lhs !== rhs) {
-            if (exportBlock)
-                exportBlock += n;
-            exportBlock +=
-                exported === '__proto__'
-                    ? `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
-                        `${t}enumerable:${_}true,${n}` +
-                        `${t}value:${_}${rhs}${n}});`
-                    : `${lhs}${_}=${_}${rhs};`;
+        }
+    }
-    if (namedExportsMode) {
-        for (const { name, reexports } of dependencies) {
-            if (!reexports) {
-                continue;
+            }
-            for (const specifier of reexports) {
-                if (specifier.reexported === '*') {
-                    if (exportBlock)
-                        exportBlock += n;
-                    if (!specifier.needsLiveBinding && reexportProtoFromExternal) {
-                        const protoString = "'__proto__'";
-                        exportBlock +=
-                            `Object.prototype.hasOwnProperty.call(${name},${_}${protoString})${_}&&${n}` +
-                                `${t}!Object.prototype.hasOwnProperty.call(exports,${_}${protoString})${_}&&${n}` +
-                                `${t}Object.defineProperty(exports,${_}${protoString},${_}{${n}` +
-                                `${t}${t}enumerable:${_}true,${n}` +
-                                `${t}${t}value:${_}${name}[${protoString}]${n}` +
-                                `${t}});${n}${n}`;
+                    }
-                    const copyPropertyIfNecessary = `{${n}${t}if${_}(k${_}!==${_}'default'${_}&&${_}!Object.prototype.hasOwnProperty.call(exports,${_}k))${_}${getDefineProperty(name, specifier.needsLiveBinding, t, snippets)}${s}${n}}`;
-                    exportBlock += `Object.keys(${name}).forEach(${getFunctionIntro(['k'], {
-                        isAsync: false,
-                        name: null
-                    })}${copyPropertyIfNecessary});`;
+                }
+            }
+        }
+    }
-    if (exportBlock) {
-        return `${n}${n}${exportBlock}`;
+    }
-    return '';
+}
-function getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess) {
-    if (exports.length > 0) {
-        return exports[0].local;
+    }
-    else {
-        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
-            if (reexports) {
-                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+            }
+        }
+    }
+}
-function getReexportedImportName(moduleVariableName, imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings, getPropertyAccess) {
-    if (imported === 'default') {
-        if (!isChunk) {
-            const moduleInterop = interop(moduleId);
-            const variableName = defaultInteropHelpersByInteropType[moduleInterop]
-                ? defaultVariableName
-                : moduleVariableName;
-            return isDefaultAProperty(moduleInterop, externalLiveBindings)
-                ? `${variableName}${getPropertyAccess('default')}`
-                : variableName;
+        }
-        return depNamedExportsMode
-            ? `${moduleVariableName}${getPropertyAccess('default')}`
-            : moduleVariableName;
+    }
-    if (imported === '*') {
-        return (isChunk ? !depNamedExportsMode : namespaceInteropHelpersByInteropType[interop(moduleId)])
-            ? namespaceVariableName
-            : moduleVariableName;
+    }
-    return `${moduleVariableName}${getPropertyAccess(imported)}`;
+}
-function getEsModuleValue(getObject) {
-    return getObject([['value', 'true']], {
-        lineBreakIndent: null
-    });
+}
-function getNamespaceMarkers(hasNamedExports, addEsModule, addNamespaceToStringTag, { _, getObject }) {
-    if (hasNamedExports) {
-        if (addEsModule) {
-            if (addNamespaceToStringTag) {
-                return `Object.defineProperties(exports,${_}${getObject([
-                    ['__esModule', getEsModuleValue(getObject)],
-                    [null, `[Symbol.toStringTag]:${_}${getToStringTagValue(getObject)}`]
-                ], {
-                    lineBreakIndent: null
-                })});`;
+            }
-            return `Object.defineProperty(exports,${_}'__esModule',${_}${getEsModuleValue(getObject)});`;
+        }
-        if (addNamespaceToStringTag) {
-            return `Object.defineProperty(exports,${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)});`;
+        }
+    }
-    return '';
+}
-const getDefineProperty = (name, needsLiveBinding, t, { _, getDirectReturnFunction, n }) => {
-    if (needsLiveBinding) {
-        const [left, right] = getDirectReturnFunction([], {
-            functionReturn: true,
-            lineBreakIndent: null,
-            name: null
-        });
-        return (`Object.defineProperty(exports,${_}k,${_}{${n}` +
-            `${t}${t}enumerable:${_}true,${n}` +
-            `${t}${t}get:${_}${left}${name}[k]${right}${n}${t}})`);
+    }
-    return `exports[k]${_}=${_}${name}[k]`;
-};
-function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, indent, snippets) {
-    const { _, cnst, n } = snippets;
-    const neededInteropHelpers = new Set();
-    const interopStatements = [];
-    const addInteropStatement = (helperVariableName, helper, dependencyVariableName) => {
-        neededInteropHelpers.add(helper);
-        interopStatements.push(`${cnst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`);
-    };
-    for (const { defaultVariableName, imports, importPath, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
-        if (isChunk) {
-            for (const { imported, reexported } of [
-                ...(imports || []),
-                ...(reexports || [])
-            ]) {
-                if (imported === '*' && reexported !== '*') {
-                    if (!namedExportsMode) {
-                        addInteropStatement(namespaceVariableName, INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE, name);
+                    }
-                    break;
+                }
+            }
+        }
-        else {
-            const moduleInterop = interop(importPath);
-            let hasDefault = false;
-            let hasNamespace = false;
-            for (const { imported, reexported } of [
-                ...(imports || []),
-                ...(reexports || [])
-            ]) {
-                let helper;
-                let variableName;
-                if (imported === 'default') {
-                    if (!hasDefault) {
-                        hasDefault = true;
-                        if (defaultVariableName !== namespaceVariableName) {
-                            variableName = defaultVariableName;
-                            helper = defaultInteropHelpersByInteropType[moduleInterop];
+                        }
+                    }
+                }
-                else if (imported === '*' && reexported !== '*' && !hasNamespace) {
-                    hasNamespace = true;
-                    helper = namespaceInteropHelpersByInteropType[moduleInterop];
-                    variableName = namespaceVariableName;
+                }
-                if (helper) {
-                    addInteropStatement(variableName, helper, name);
+                }
+            }
+        }
+    }
-    return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, indent, snippets, externalLiveBindings, freeze, symbols)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
+}
-function addJsExtension(name) {
-    return name.endsWith('.js') ? name : name + '.js';
+}
-// AMD resolution will only respect the AMD baseUrl if the .js extension is omitted.
-// The assumption is that this makes sense for all relative ids:
-// https://requirejs.org/docs/api.html#jsfiles
-function updateExtensionForRelativeAmdId(id, forceJsExtensionForImports) {
-    if (id[0] !== '.') {
-        return id;
+    }
-    return forceJsExtensionForImports ? addJsExtension(id) : removeJsExtension(id);
+}
-const builtinModules = [
-        "assert",
-        "assert/strict",
-        "async_hooks",
-        "buffer",
-        "child_process",
-        "cluster",
-        "console",
-        "constants",
-        "crypto",
-        "dgram",
-        "diagnostics_channel",
-        "dns",
-        "dns/promises",
-        "domain",
-        "events",
-        "fs",
-        "fs/promises",
-        "http",
-        "http2",
-        "https",
-        "inspector",
-        "inspector/promises",
-        "module",
-        "net",
-        "os",
-        "path",
-        "path/posix",
-        "path/win32",
-        "perf_hooks",
-        "process",
-        "punycode",
-        "querystring",
-        "readline",
-        "readline/promises",
-        "repl",
-        "stream",
-        "stream/consumers",
-        "stream/promises",
-        "stream/web",
-        "string_decoder",
-        "timers",
-        "timers/promises",
-        "tls",
-        "trace_events",
-        "tty",
-        "url",
-        "util",
-        "util/types",
-        "v8",
-        "vm",
-        "wasi",
-        "worker_threads",
-        "zlib"
-];
-const nodeBuiltins = new Set(builtinModules);
-function warnOnBuiltins(log, dependencies) {
-    const externalBuiltins = dependencies
-        .map(({ importPath }) => importPath)
-        .filter(importPath => nodeBuiltins.has(importPath) || importPath.startsWith('node:'));
-    if (externalBuiltins.length === 0)
-        return;
-    log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingNodeBuiltins(externalBuiltins));
+}
-function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, log, outro, snippets }, { amd, esModule, externalLiveBindings, freeze, generatedCode: { symbols }, interop, reexportProtoFromExternal, strict }) {
-    warnOnBuiltins(log, dependencies);
-    const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
-    const parameters = dependencies.map(m => m.name);
-    const { n, getNonArrowFunctionIntro, _ } = snippets;
-    if (namedExportsMode && hasExports) {
-        parameters.unshift(`exports`);
-        deps.unshift(`'exports'`);
+    }
-    if (accessedGlobals.has('require')) {
-        parameters.unshift('require');
-        deps.unshift(`'require'`);
+    }
-    if (accessedGlobals.has('module')) {
-        parameters.unshift('module');
-        deps.unshift(`'module'`);
+    }
-    const completeAmdId = getCompleteAmdId(amd, id);
-    const defineParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
-        (deps.length > 0 ? `[${deps.join(`,${_}`)}],${_}` : ``);
-    const useStrict = strict ? `${_}'use strict';` : '';
-    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
-    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
-    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
-    if (namespaceMarkers) {
-        namespaceMarkers = n + n + namespaceMarkers;
+    }
-    magicString
-        .append(`${exportBlock}${namespaceMarkers}${outro}`)
-        .indent(t)
-        // factory function should be wrapped by parentheses to avoid lazy parsing,
-        // cf. https://v8.dev/blog/preparser#pife
-        .prepend(`${amd.define}(${defineParameters}(${getNonArrowFunctionIntro(parameters, {
-        isAsync: false,
-        name: null
-    })}{${useStrict}${n}${n}`)
-        .append(`${n}${n}}));`);
+}
-function cjs(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets }, { compact, esModule, externalLiveBindings, freeze, interop, generatedCode: { symbols }, reexportProtoFromExternal, strict }) {
-    const { _, n } = snippets;
-    const useStrict = strict ? `'use strict';${n}${n}` : '';
-    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
-    if (namespaceMarkers) {
-        namespaceMarkers += n + n;
+    }
-    const importBlock = getImportBlock$1(dependencies, snippets, compact);
-    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
-    magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
-    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, `module.exports${_}=${_}`);
-    magicString.append(`${exportBlock}${outro}`);
+}
-function getImportBlock$1(dependencies, { _, cnst, n }, compact) {
-    let importBlock = '';
-    let definingVariable = false;
-    for (const { importPath, name, reexports, imports } of dependencies) {
-        if (!reexports && !imports) {
-            if (importBlock) {
-                importBlock += compact && !definingVariable ? ',' : `;${n}`;
+            }
-            definingVariable = false;
-            importBlock += `require('${importPath}')`;
+        }
-        else {
-            importBlock += compact && definingVariable ? ',' : `${importBlock ? `;${n}` : ''}${cnst} `;
-            definingVariable = true;
-            importBlock += `${name}${_}=${_}require('${importPath}')`;
+        }
+    }
-    if (importBlock) {
-        return `${importBlock};${n}${n}`;
+    }
-    return '';
+}
-function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencies, exports, snippets }, { externalLiveBindings, freeze, generatedCode: { symbols }, importAttributesKey }) {
-    const { n } = snippets;
-    const importBlock = getImportBlock(dependencies, importAttributesKey, snippets);
-    if (importBlock.length > 0)
-        intro += importBlock.join(n) + n + n;
-    intro += getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols);
-    if (intro)
-        magicString.prepend(intro);
-    const exportBlock = getExportBlock(exports, snippets);
-    if (exportBlock.length > 0)
-        magicString.append(n + n + exportBlock.join(n).trim());
-    if (outro)
-        magicString.append(outro);
-    magicString.trim();
+}
-function getImportBlock(dependencies, importAttributesKey, { _ }) {
-    const importBlock = [];
-    for (const { importPath, reexports, imports, name, attributes } of dependencies) {
-        const assertion = attributes ? `${_}${importAttributesKey}${_}${attributes}` : '';
-        const pathWithAssertion = `'${importPath}'${assertion};`;
-        if (!reexports && !imports) {
-            importBlock.push(`import${_}${pathWithAssertion}`);
-            continue;
+        }
-        if (imports) {
-            let defaultImport = null;
-            let starImport = null;
-            const importedNames = [];
-            for (const specifier of imports) {
-                if (specifier.imported === 'default') {
-                    defaultImport = specifier;
+                }
-                else if (specifier.imported === '*') {
-                    starImport = specifier;
+                }
-                else {
-                    importedNames.push(specifier);
+                }
+            }
-            if (starImport) {
-                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}${pathWithAssertion}`);
+            }
-            if (defaultImport && importedNames.length === 0) {
-                importBlock.push(`import ${defaultImport.local} from${_}${pathWithAssertion}`);
+            }
-            else if (importedNames.length > 0) {
-                importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
-                    .map(specifier => specifier.imported === specifier.local
-                    ? specifier.imported
-                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${specifier.local}`)
-                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
-        if (reexports) {
-            let starExport = null;
-            const namespaceReexports = [];
-            const namedReexports = [];
-            for (const specifier of reexports) {
-                if (specifier.reexported === '*') {
-                    starExport = specifier;
+                }
-                else if (specifier.imported === '*') {
-                    namespaceReexports.push(specifier);
+                }
-                else {
-                    namedReexports.push(specifier);
+                }
+            }
-            if (starExport) {
-                importBlock.push(`export${_}*${_}from${_}${pathWithAssertion}`);
+            }
-            if (namespaceReexports.length > 0) {
-                if (!imports ||
-                    !imports.some(specifier => specifier.imported === '*' && specifier.local === name)) {
-                    importBlock.push(`import${_}*${_}as ${name} from${_}${pathWithAssertion}`);
+                }
-                for (const specifier of namespaceReexports) {
-                    importBlock.push(`export${_}{${_}${name === specifier.reexported
-                        ? name
-                        : `${name} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`} };`);
+                }
+            }
-            if (namedReexports.length > 0) {
-                importBlock.push(`export${_}{${_}${namedReexports
-                    .map(specifier => specifier.imported === specifier.reexported
-                    ? stringifyIdentifierIfNeeded(specifier.imported)
-                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`)
-                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
+    }
-    return importBlock;
+}
-function getExportBlock(exports, { _, cnst }) {
-    const exportBlock = [];
-    const exportDeclaration = [];
-    for (const specifier of exports) {
-        if (specifier.expression) {
-            exportBlock.push(`${cnst} ${specifier.local}${_}=${_}${specifier.expression};`);
+        }
-        exportDeclaration.push(specifier.exported === specifier.local
-            ? specifier.local
-            : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`);
+    }
-    if (exportDeclaration.length > 0) {
-        exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
+    }
-    return exportBlock;
+}
-const keypath = (keypath, getPropertyAccess) => keypath.split('.').map(getPropertyAccess).join('');
-function setupNamespace(name, root, globals, { _, getPropertyAccess, s }, compact) {
-    const parts = name.split('.');
-    parts[0] = (typeof globals === 'function' ? globals(parts[0]) : globals[parts[0]]) || parts[0];
-    parts.pop();
-    let propertyPath = root;
-    return (parts
-        .map(part => {
-        propertyPath += getPropertyAccess(part);
-        return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}${s}`;
-    })
-        .join(compact ? ',' : '\n') + (compact && parts.length > 0 ? ';' : '\n'));
+}
-function assignToDeepVariable(deepName, root, globals, assignment, { _, getPropertyAccess }) {
-    const parts = deepName.split('.');
-    parts[0] = (typeof globals === 'function' ? globals(parts[0]) : globals[parts[0]]) || parts[0];
-    const last = parts.pop();
-    let propertyPath = root;
-    let deepAssignment = [
-        ...parts.map(part => {
-            propertyPath += getPropertyAccess(part);
-            return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}`;
-        }),
-        `${propertyPath}${getPropertyAccess(last)}`
-    ].join(`,${_}`) + `${_}=${_}${assignment}`;
-    if (parts.length > 0) {
-        deepAssignment = `(${deepAssignment})`;
+    }
-    return deepAssignment;
+}
-function trimEmptyImports(dependencies) {
-    let index = dependencies.length;
-    while (index--) {
-        const { imports, reexports } = dependencies[index];
-        if (imports || reexports) {
-            return dependencies.slice(0, index + 1);
+        }
+    }
-    return [];
+}
-function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, namedExportsMode, log, outro, snippets }, { compact, esModule, extend, freeze, externalLiveBindings, reexportProtoFromExternal, globals, interop, name, generatedCode: { symbols }, strict }) {
-    const { _, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
-    const isNamespaced = name && name.includes('.');
-    const useVariableAssignment = !extend && !isNamespaced;
-    if (name && useVariableAssignment && !isLegal(name)) {
-        return parseAst_js.error(parseAst_js.logIllegalIdentifierAsName(name));
+    }
-    warnOnBuiltins(log, dependencies);
-    const external = trimEmptyImports(dependencies);
-    const deps = external.map(dep => dep.globalName || 'null');
-    const parameters = external.map(m => m.name);
-    if (hasExports && !name) {
-        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingNameOptionForIifeExport());
+    }
-    if (namedExportsMode && hasExports) {
-        if (extend) {
-            deps.unshift(`this${keypath(name, getPropertyAccess)}${_}=${_}this${keypath(name, getPropertyAccess)}${_}||${_}{}`);
-            parameters.unshift('exports');
+        }
-        else {
-            deps.unshift('{}');
-            parameters.unshift('exports');
+        }
+    }
-    const useStrict = strict ? `${t}'use strict';${n}` : '';
-    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
-    magicString.prepend(`${intro}${interopBlock}`);
-    let wrapperIntro = `(${getNonArrowFunctionIntro(parameters, {
-        isAsync: false,
-        name: null
-    })}{${n}${useStrict}${n}`;
-    if (hasExports) {
-        if (name && !(extend && namedExportsMode)) {
-            wrapperIntro =
-                (useVariableAssignment ? `var ${name}` : `this${keypath(name, getPropertyAccess)}`) +
-                    `${_}=${_}${wrapperIntro}`;
+        }
-        if (isNamespaced) {
-            wrapperIntro = setupNamespace(name, 'this', globals, snippets, compact) + wrapperIntro;
+        }
+    }
-    let wrapperOutro = `${n}${n}})(${deps.join(`,${_}`)});`;
-    if (hasExports && !extend && namedExportsMode) {
-        wrapperOutro = `${n}${n}${t}return exports;${wrapperOutro}`;
+    }
-    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
-    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
-    if (namespaceMarkers) {
-        namespaceMarkers = n + n + namespaceMarkers;
+    }
-    magicString
-        .append(`${exportBlock}${namespaceMarkers}${outro}`)
-        .indent(t)
-        .prepend(wrapperIntro)
-        .append(wrapperOutro);
+}
-function system(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, snippets, outro, usesTopLevelAwait }, { externalLiveBindings, freeze, name, generatedCode: { symbols }, strict, systemNullSetters }) {
-    const { _, getFunctionIntro, getNonArrowFunctionIntro, n, s } = snippets;
-    const { importBindings, setters, starExcludes } = analyzeDependencies(dependencies, exports, t, snippets);
-    const registeredName = name ? `'${name}',${_}` : '';
-    const wrapperParameters = accessedGlobals.has('module')
-        ? ['exports', 'module']
-        : hasExports
-            ? ['exports']
-            : [];
-    // factory function should be wrapped by parentheses to avoid lazy parsing,
-    // cf. https://v8.dev/blog/preparser#pife
-    let wrapperStart = `System.register(${registeredName}[` +
-        dependencies.map(({ importPath }) => `'${importPath}'`).join(`,${_}`) +
-        `],${_}(${getNonArrowFunctionIntro(wrapperParameters, {
-            isAsync: false,
-            name: null
-        })}{${n}${t}${strict ? "'use strict';" : ''}` +
-        getStarExcludesBlock(starExcludes, t, snippets) +
-        getImportBindingsBlock(importBindings, t, snippets) +
-        `${n}${t}return${_}{${setters.length > 0
-            ? `${n}${t}${t}setters:${_}[${setters
-                .map(setter => setter
-                ? `${getFunctionIntro(['module'], {
-                    isAsync: false,
-                    name: null
-                })}{${n}${t}${t}${t}${setter}${n}${t}${t}}`
-                : systemNullSetters
-                    ? `null`
-                    : `${getFunctionIntro([], { isAsync: false, name: null })}{}`)
-                .join(`,${_}`)}],`
-            : ''}${n}`;
-    wrapperStart += `${t}${t}execute:${_}(${getNonArrowFunctionIntro([], {
-        isAsync: usesTopLevelAwait,
-        name: null
-    })}{${n}${n}`;
-    const wrapperEnd = `${t}${t}})${n}${t}}${s}${n}}));`;
-    magicString
-        .prepend(intro +
-        getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols) +
-        getHoistedExportsBlock(exports, t, snippets))
-        .append(`${outro}${n}${n}` +
-        getSyntheticExportsBlock(exports, t, snippets) +
-        getMissingExportsBlock(exports, t, snippets))
-        .indent(`${t}${t}${t}`)
-        .append(wrapperEnd)
-        .prepend(wrapperStart);
+}
-function analyzeDependencies(dependencies, exports, t, { _, cnst, getObject, getPropertyAccess, n }) {
-    const importBindings = [];
-    const setters = [];
-    let starExcludes = null;
-    for (const { imports, reexports } of dependencies) {
-        const setter = [];
-        if (imports) {
-            for (const specifier of imports) {
-                importBindings.push(specifier.local);
-                if (specifier.imported === '*') {
-                    setter.push(`${specifier.local}${_}=${_}module;`);
+                }
-                else {
-                    setter.push(`${specifier.local}${_}=${_}module${getPropertyAccess(specifier.imported)};`);
+                }
+            }
+        }
-        if (reexports) {
-            const reexportedNames = [];
-            let hasStarReexport = false;
-            for (const { imported, reexported } of reexports) {
-                if (reexported === '*') {
-                    hasStarReexport = true;
+                }
-                else {
-                    reexportedNames.push([
-                        reexported,
-                        imported === '*' ? 'module' : `module${getPropertyAccess(imported)}`
-                    ]);
+                }
+            }
-            if (reexportedNames.length > 1 || hasStarReexport) {
-                if (hasStarReexport) {
-                    if (!starExcludes) {
-                        starExcludes = getStarExcludes({ dependencies, exports });
+                    }
-                    reexportedNames.unshift([null, `__proto__:${_}null`]);
-                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
-                    setter.push(`${cnst} setter${_}=${_}${exportMapping};`, `for${_}(${cnst} name in module)${_}{`, `${t}if${_}(!_starExcludes[name])${_}setter[name]${_}=${_}module[name];`, '}', 'exports(setter);');
+                }
-                else {
-                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
-                    setter.push(`exports(${exportMapping});`);
+                }
+            }
-            else {
-                const [key, value] = reexportedNames[0];
-                setter.push(`exports(${JSON.stringify(key)},${_}${value});`);
+            }
+        }
-        setters.push(setter.join(`${n}${t}${t}${t}`));
+    }
-    return { importBindings, setters, starExcludes };
+}
-const getStarExcludes = ({ dependencies, exports }) => {
-    const starExcludes = new Set(exports.map(expt => expt.exported));
-    starExcludes.add('default');
-    for (const { reexports } of dependencies) {
-        if (reexports) {
-            for (const reexport of reexports) {
-                if (reexport.reexported !== '*')
-                    starExcludes.add(reexport.reexported);
+            }
+        }
+    }
-    return starExcludes;
-};
-const getStarExcludesBlock = (starExcludes, t, { _, cnst, getObject, n }) => {
-    if (starExcludes) {
-        const fields = [...starExcludes].map(property => [
-            property,
-            '1'
-        ]);
-        fields.unshift([null, `__proto__:${_}null`]);
-        return `${n}${t}${cnst} _starExcludes${_}=${_}${getObject(fields, {
-            lineBreakIndent: { base: t, t }
-        })};`;
+    }
-    return '';
-};
-const getImportBindingsBlock = (importBindings, t, { _, n }) => (importBindings.length > 0 ? `${n}${t}var ${importBindings.join(`,${_}`)};` : '');
-const getHoistedExportsBlock = (exports, t, snippets) => getExportsBlock(exports.filter(expt => expt.hoisted).map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
-function getExportsBlock(exports, t, { _, n }) {
-    if (exports.length === 0) {
-        return '';
+    }
-    if (exports.length === 1) {
-        return `exports(${JSON.stringify(exports[0].name)},${_}${exports[0].value});${n}${n}`;
+    }
-    return (`exports({${n}` +
-        exports
-            .map(({ name, value }) => `${t}${stringifyObjectKeyIfNeeded(name)}:${_}${value}`)
-            .join(`,${n}`) +
-        `${n}});${n}${n}`);
+}
-const getSyntheticExportsBlock = (exports, t, snippets) => getExportsBlock(exports
-    .filter(expt => expt.expression)
-    .map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
-const getMissingExportsBlock = (exports, t, snippets) => getExportsBlock(exports
-    .filter(expt => expt.local === MISSING_EXPORT_SHIM_VARIABLE)
-    .map(expt => ({ name: expt.exported, value: MISSING_EXPORT_SHIM_VARIABLE })), t, snippets);
-function globalProperty(name, globalVariable, getPropertyAccess) {
-    if (!name)
-        return 'null';
-    return `${globalVariable}${keypath(name, getPropertyAccess)}`;
+}
-function safeAccess(name, globalVariable, { _, getPropertyAccess }) {
-    let propertyPath = globalVariable;
-    return name
-        .split('.')
-        .map(part => (propertyPath += getPropertyAccess(part)))
-        .join(`${_}&&${_}`);
+}
-function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, log, outro, snippets }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, generatedCode: { symbols }, globals, noConflict, reexportProtoFromExternal, strict }) {
-    const { _, cnst, getFunctionIntro, getNonArrowFunctionIntro, getPropertyAccess, n, s } = snippets;
-    const factoryVariable = compact ? 'f' : 'factory';
-    const globalVariable = compact ? 'g' : 'global';
-    if (hasExports && !name) {
-        return parseAst_js.error(parseAst_js.logMissingNameOptionForUmdExport());
+    }
-    warnOnBuiltins(log, dependencies);
-    const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
-    const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
-    const trimmedImports = trimEmptyImports(dependencies);
-    const globalDeps = trimmedImports.map(module => globalProperty(module.globalName, globalVariable, getPropertyAccess));
-    const factoryParameters = trimmedImports.map(m => m.name);
-    if (namedExportsMode && (hasExports || noConflict)) {
-        amdDeps.unshift(`'exports'`);
-        cjsDeps.unshift(`exports`);
-        globalDeps.unshift(assignToDeepVariable(name, globalVariable, globals, `${extend ? `${globalProperty(name, globalVariable, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets));
-        factoryParameters.unshift('exports');
+    }
-    const completeAmdId = getCompleteAmdId(amd, id);
-    const amdParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
-        (amdDeps.length > 0 ? `[${amdDeps.join(`,${_}`)}],${_}` : ``);
-    const define = amd.define;
-    const cjsExport = !namedExportsMode && hasExports ? `module.exports${_}=${_}` : ``;
-    const useStrict = strict ? `${_}'use strict';${n}` : ``;
-    let iifeExport;
-    if (noConflict) {
-        const noConflictExportsVariable = compact ? 'e' : 'exports';
-        let factory;
-        if (!namedExportsMode && hasExports) {
-            factory = `${cnst} ${noConflictExportsVariable}${_}=${_}${assignToDeepVariable(name, globalVariable, globals, `${factoryVariable}(${globalDeps.join(`,${_}`)})`, snippets)};`;
+        }
-        else {
-            const module = globalDeps.shift();
-            factory =
-                `${cnst} ${noConflictExportsVariable}${_}=${_}${module};${n}` +
-                    `${t}${t}${factoryVariable}(${[noConflictExportsVariable, ...globalDeps].join(`,${_}`)});`;
+        }
-        iifeExport =
-            `(${getFunctionIntro([], { isAsync: false, name: null })}{${n}` +
-                `${t}${t}${cnst} current${_}=${_}${safeAccess(name, globalVariable, snippets)};${n}` +
-                `${t}${t}${factory}${n}` +
-                `${t}${t}${noConflictExportsVariable}.noConflict${_}=${_}${getFunctionIntro([], {
-                    isAsync: false,
-                    name: null
-                })}{${_}` +
-                `${globalProperty(name, globalVariable, getPropertyAccess)}${_}=${_}current;${_}return ${noConflictExportsVariable}${s}${_}};${n}` +
-                `${t}})()`;
+    }
-    else {
-        iifeExport = `${factoryVariable}(${globalDeps.join(`,${_}`)})`;
-        if (!namedExportsMode && hasExports) {
-            iifeExport = assignToDeepVariable(name, globalVariable, globals, iifeExport, snippets);
+        }
+    }
-    const iifeNeedsGlobal = hasExports || (noConflict && namedExportsMode) || globalDeps.length > 0;
-    const wrapperParameters = [factoryVariable];
-    if (iifeNeedsGlobal) {
-        wrapperParameters.unshift(globalVariable);
+    }
-    const globalArgument = iifeNeedsGlobal ? `this,${_}` : '';
-    const iifeStart = iifeNeedsGlobal
-        ? `(${globalVariable}${_}=${_}typeof globalThis${_}!==${_}'undefined'${_}?${_}globalThis${_}:${_}${globalVariable}${_}||${_}self,${_}`
-        : '';
-    const iifeEnd = iifeNeedsGlobal ? ')' : '';
-    const cjsIntro = iifeNeedsGlobal
-        ? `${t}typeof exports${_}===${_}'object'${_}&&${_}typeof module${_}!==${_}'undefined'${_}?` +
-            `${_}${cjsExport}${factoryVariable}(${cjsDeps.join(`,${_}`)})${_}:${n}`
-        : '';
-    const wrapperIntro = `(${getNonArrowFunctionIntro(wrapperParameters, { isAsync: false, name: null })}{${n}` +
-        cjsIntro +
-        `${t}typeof ${define}${_}===${_}'function'${_}&&${_}${define}.amd${_}?${_}${define}(${amdParameters}${factoryVariable})${_}:${n}` +
-        `${t}${iifeStart}${iifeExport}${iifeEnd};${n}` +
-        // factory function should be wrapped by parentheses to avoid lazy parsing,
-        // cf. https://v8.dev/blog/preparser#pife
-        `})(${globalArgument}(${getNonArrowFunctionIntro(factoryParameters, {
-            isAsync: false,
-            name: null
-        })}{${useStrict}${n}`;
-    const wrapperOutro = n + n + '}));';
-    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
-    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
-    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
-    if (namespaceMarkers) {
-        namespaceMarkers = n + n + namespaceMarkers;
+    }
-    magicString
-        .append(`${exportBlock}${namespaceMarkers}${outro}`)
-        .trim()
-        .indent(t)
-        .append(wrapperOutro)
-        .prepend(wrapperIntro);
+}
-const finalisers = { amd, cjs, es, iife, system, umd };
 const concatSeparator = (out, next) => (next ? `${out}\n${next}` : out);
 …
+        }
         for (const module of entryModules) {
-            // eslint-disable-next-line unicorn/prefer-spread
             const requiredFacades = Array.from(new Set(module.chunkNames.filter(({ isUserDefined }) => isUserDefined).map(({ name }) => name)),
             // mapping must run after Set 'name' dedupe
 …
                 requiredFacades.push({});
+            }
-            // eslint-disable-next-line unicorn/prefer-spread
             requiredFacades.push(...Array.from(module.chunkFileNames, fileName => ({ fileName })));
             if (requiredFacades.length === 0) {
 …
         const { chunkFileNames, entryFileNames, file, format, preserveModules } = this.outputOptions;
         if (file) {
             fileName = path$2.basename(file);
+            fileName = path.basename(file);
+        }
         else if (this.fileName === null) {
 …
             dynamicImports: this.getDynamicDependencies().map(resolveFileName),
             fileName: this.getFileName(),
-            // eslint-disable-next-line unicorn/prefer-spread
             implicitlyLoadedBefore: Array.from(this.implicitlyLoadedBefore, resolveFileName),
             importedBindings: getImportedBindingsPerDependency(this.getRenderedDependencies(), resolveFileName),
-            // eslint-disable-next-line unicorn/prefer-spread
             imports: Array.from(this.dependencies, resolveFileName),
             modules: this.renderedModules,
 …
+                }
                 if (format === 'es') {
+                    renderedDependency.reexports = reexports.filter(
+                    // eslint-disable-next-line unicorn/prefer-array-some
+                    ({ reexported }) => !renderedExports.find(({ exported }) => exported === reexported));
+                    renderedDependency.reexports = reexports.filter(({ reexported }) => !renderedExports.find(({ exported }) => exported === reexported));
+                }
+            }
 …
         if (format === 'es' || format === 'cjs') {
             const shebang = facadeModule !== null && facadeModule.info.isEntry && facadeModule.shebang;
+            shebang && magicString.prepend(`#!${shebang}\n`);
+            if (shebang) {
+                magicString.prepend(`#!${shebang}\n`);
+            }
+        }
         if (footer)
 …
         const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
         const sanitizedId = sanitizeFileName(parseAst_js.normalize(module.id.split(QUERY_HASH_REGEX, 1)[0]));
         const extensionName = path$2.extname(sanitizedId);
+        const extensionName = path.extname(sanitizedId);
         const idWithoutExtension = NON_ASSET_EXTENSIONS.has(extensionName)
             ? sanitizedId.slice(0, -extensionName.length)
             : sanitizedId;
         if (parseAst_js.isAbsolute(idWithoutExtension)) {
+            return preserveModulesRoot && path$2.resolve(idWithoutExtension).startsWith(preserveModulesRoot)
+                ? idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[/\\]/, '')
+                : parseAst_js.relative(this.inputBase, idWithoutExtension);
+            if (preserveModulesRoot && path.resolve(idWithoutExtension).startsWith(preserveModulesRoot)) {
+                return idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[/\\]/, '');
+            }
+            else {
+                // handle edge case in Windows
+                if (this.inputBase === '/' && !idWithoutExtension.startsWith('/')) {
+                    return parseAst_js.relative(this.inputBase, idWithoutExtension.replace(/^[a-zA-Z]:[/\\]/, '/'));
+                }
+                return parseAst_js.relative(this.inputBase, idWithoutExtension);
+            }
+        }
         else {
             return `_virtual/${path$2.basename(idWithoutExtension)}`;
+            return (this.outputOptions.virtualDirname.replace(/\/$/, '') + '/' + path.basename(idWithoutExtension));
+        }
+    }
 …
                 if (!renderOptions.accessedDocumentCurrentScript &&
                     formatsMaybeAccessDocumentCurrentScript.includes(format)) {
-                    // eslint-disable-next-line unicorn/consistent-destructuring
                     this.accessedGlobalsByScope.get(module.scope)?.delete(DOCUMENT_CURRENT_SCRIPT);
+                }
 …
         if (hoistedSource)
             magicString.prepend(hoistedSource + n + n);
-        // eslint-disable-next-line unicorn/consistent-destructuring
         if (this.needsExportsShim) {
             magicString.prepend(`${n}${cnst} ${MISSING_EXPORT_SHIM_VARIABLE}${_}=${_}void 0;${n}${n}`);
 …
+}
 function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
-    const chunkDefinitions = [];
     const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
     const manualChunkModulesByAlias = Object.create(null);
 …
         addStaticDependenciesToManualChunk(entry, (manualChunkModulesByAlias[alias] ||= []), modulesInManualChunks);
+    }
+    for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
+        chunkDefinitions.push({ alias, modules });
+    const manualChunks = Object.entries(manualChunkModulesByAlias);
+    const chunkDefinitions = new Array(manualChunks.length);
+    let index = 0;
+    for (const [alias, modules] of manualChunks) {
+        chunkDefinitions[index++] = { alias, modules };
+    }
     return { chunkDefinitions, modulesInManualChunks };
 …
     const dynamicEntryModules = new Set();
     const dependentEntriesByModule = new Map();
-    const dynamicImportModulesByEntry = [];
     const allEntriesSet = new Set(entries);
+    const dynamicImportModulesByEntry = new Array(allEntriesSet.size);
     let entryIndex = 0;
     for (const currentEntry of allEntriesSet) {
         const dynamicImportsForCurrentEntry = new Set();
         dynamicImportModulesByEntry.push(dynamicImportsForCurrentEntry);
+        dynamicImportModulesByEntry[entryIndex] = dynamicImportsForCurrentEntry;
         const modulesToHandle = new Set([currentEntry]);
         for (const module of modulesToHandle) {
 …
+        }
+    }
+    const dynamicImportsByEntry = [];
+    const dynamicImportsByEntry = new Array(dynamicImportModulesByEntry.length);
+    let index = 0;
     for (const dynamicImportModules of dynamicImportModulesByEntry) {
         const dynamicImports = new Set();
 …
             dynamicImports.add(entryIndexByModule.get(dynamicEntry));
+        }
         dynamicImportsByEntry.push(dynamicImports);
+        dynamicImportsByEntry[index++] = dynamicImports;
+    }
     return { dynamicEntries, dynamicImportsByEntry };
 …
     const chunksBySignature = Object.create(null);
     const chunkByModule = new Map();
     const sizeByAtom = [];
+    const sizeByAtom = new Array(chunkAtoms.length);
     let sideEffectAtoms = 0n;
     let atomMask = 1n;
+    let index = 0;
     for (const { dependentEntries, modules } of chunkAtoms) {
         let chunkSignature = 0n;
 …
             sideEffectAtoms |= atomMask;
+        }
         sizeByAtom.push(atomSize);
+        sizeByAtom[index++] = atomSize;
         chunk.containedAtoms |= atomMask;
         chunk.modules.push(...modules);
 …
         return chunks; // the actual modules
+    }
     minChunkSize > 1 &&
+    if (minChunkSize > 1) {
         log('info', parseAst_js.logOptimizeChunkStatus(chunks.length, chunkPartition.small.size, 'Initially'));
+    }
     mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom);
     minChunkSize > 1 &&
+    if (minChunkSize > 1) {
         log('info', parseAst_js.logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, 'After merging chunks'));
+    }
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 …
         return '/';
     if (files.length === 1)
         return path$2.dirname(files[0]);
+        return path.dirname(files[0]);
     const commonSegments = files.slice(1).reduce((commonSegments, file) => {
         const pathSegments = file.split(/\/+|\\+/);
 …
         const sources = originalSourcemap.sources;
         const sourcesContent = originalSourcemap.sourcesContent || [];
         const directory = path$2.dirname(id) || '.';
+        const directory = path.dirname(id) || '.';
         const sourceRoot = originalSourcemap.sourceRoot || '.';
         const baseSources = sources.map((source, index) => new Source(path$2.resolve(directory, sourceRoot, source), sourcesContent[index]));
+        const baseSources = sources.map((source, index) => new Source(path.resolve(directory, sourceRoot, source), sourcesContent[index]));
         source = new Link(originalSourcemap, baseSources);
+    }
 …
     let { sources, sourcesContent, names, mappings } = source.traceMappings();
     if (file) {
         const directory = path$2.dirname(file);
         sources = sources.map((source) => path$2.relative(directory, source));
         file = path$2.basename(file);
+        const directory = path.dirname(file);
+        sources = sources.map((source) => path.relative(directory, source));
+        file = path.basename(file);
+    }
     sourcesContent = (excludeContent ? null : sourcesContent);
 …
     const getHash = hasherByType[outputOptions.hashCharacters];
     const chunkGraph = getChunkGraph(chunks);
     const { initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log);
     const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle, getHash);
+    const { hashDependenciesByPlaceholder, initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, placeholders, renderedChunksByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log);
+    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, placeholders, bundle, getHash);
     addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
     timeEnd('transform chunks', 2);
 …
         let resultingFile;
         if (file)
             resultingFile = path$2.resolve(sourcemapFile || file);
+            resultingFile = path.resolve(sourcemapFile || file);
         else if (dir)
             resultingFile = path$2.resolve(dir, fileName);
+            resultingFile = path.resolve(dir, fileName);
         else
             resultingFile = path$2.resolve(fileName);
+            resultingFile = path.resolve(fileName);
         const decodedMap = magicString.generateDecodedMap({});
         map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, log);
 …
         initialHashesByPlaceholder,
         nonHashedChunksWithPlaceholders,
+        placeholders,
         renderedChunksByPlaceholder
     };
+}
 function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle, getHash) {
+function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, placeholders, bundle, getHash) {
     const hashesByPlaceholder = new Map(initialHashesByPlaceholder);
+    for (const [placeholder, { fileName }] of renderedChunksByPlaceholder) {
+    for (const placeholder of placeholders) {
+        const { fileName } = renderedChunksByPlaceholder.get(placeholder);
         let contentToHash = '';
         const hashDependencyPlaceholders = new Set([placeholder]);
 …
         let finalSourcemapFileName = null;
         if (map) {
+            if (options.sourcemapDebugIds) {
+                updatedCode += calculateDebugIdAndGetComment(updatedCode, map);
+            }
             finalSourcemapFileName = sourcemapFileName
                 ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
 …
         let finalSourcemapFileName = null;
         if (map) {
+            if (options.sourcemapDebugIds) {
+                updatedCode += calculateDebugIdAndGetComment(updatedCode, map);
+            }
             finalSourcemapFileName = sourcemapFileName
                 ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
 …
+    }
     else {
         const sourcemapFileName = path$2.basename(fileName);
+        const sourcemapFileName = path.basename(fileName);
         url = sourcemapBaseUrl
             ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
 …
+    }
     return sourcemap === 'hidden' ? '' : `//# ${SOURCEMAPPING_URL}=${url}\n`;
+}
+function calculateDebugIdAndGetComment(code, map) {
+    const hash = hasherByType.hex(code);
+    const debugId = [
+        hash.slice(0, 8),
+        hash.slice(8, 12),
+        '4' + hash.slice(12, 15),
+        ((parseInt(hash.slice(15, 16), 16) & 3) | 8).toString(16) + hash.slice(17, 20),
+        hash.slice(20, 32)
+    ].join('-');
+    map.debugId = debugId;
+    return '//# debugId=' + debugId + '\n';
+}
 …
+    }
     assignManualChunks(getManualChunk) {
-        // eslint-disable-next-line unicorn/prefer-module
         const manualChunkAliasesWithEntry = [];
         const manualChunksApi = {
 …
                 if ('code' in file) {
                     try {
                         parseAst_js.parseAst(file.code);
+                        parseAst_js.parseAst(file.code, { jsx: this.inputOptions.jsx !== false });
+                    }
                     catch (error_) {
 …
         const inputBase = commondir(getAbsoluteEntryModulePaths(includedModules, preserveModules));
         const externalChunkByModule = getExternalChunkByModule(this.graph.modulesById, this.outputOptions, inputBase);
+        const chunks = [];
+        const chunkByModule = new Map();
+        for (const { alias, modules } of inlineDynamicImports
+        const executableModule = inlineDynamicImports
             ? [{ alias: null, modules: includedModules }]
             : preserveModules
                 ? includedModules.map(module => ({ alias: null, modules: [module] }))
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, this.inputOptions.onLog)) {
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, this.inputOptions.onLog);
+        const chunks = new Array(executableModule.length);
+        const chunkByModule = new Map();
+        let index = 0;
+        for (const { alias, modules } of executableModule) {
             sortByExecutionOrder(modules);
             const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
             chunks.push(chunk);
+            chunks[index++] = chunk;
+        }
         for (const chunk of chunks) {
 …
+}
+class GlobalScope extends Scope {
+    constructor() {
+        super();
+        this.parent = null;
+        this.variables.set('undefined', new UndefinedVariable());
+    }
+    findVariable(name) {
+        let variable = this.variables.get(name);
+        if (!variable) {
+            variable = new GlobalVariable(name);
+            this.variables.set(name, variable);
+        }
+        return variable;
+    }
+}
 function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes) {
     let skipped = null;
 …
     // resolve call and require no special handing on our part.
     // See https://nodejs.org/api/path.html#path_path_resolve_paths
     return addJsExtensionIfNecessary(importer ? path$2.resolve(path$2.dirname(importer), source) : path$2.resolve(source), preserveSymlinks);
+    return addJsExtensionIfNecessary(importer ? path.resolve(path.dirname(importer), source) : path.resolve(source), preserveSymlinks);
+}
 async function addJsExtensionIfNecessary(file, preserveSymlinks) {
 …
         if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
             // check case
             const name = path$2.basename(file);
             const files = await promises.readdir(path$2.dirname(file));
+            const name = path.basename(file);
+            const files = await promises.readdir(path.dirname(file));
             if (files.includes(name))
                 return file;
 …
+    }
     getResolveStaticDependencyPromises(module) {
-        // eslint-disable-next-line unicorn/prefer-spread
         return Array.from(module.sourcesWithAttributes, async ([source, attributes]) => [
             source,
 …
     return parseAst_js.isRelative(source)
         ? importer
             ? path$2.resolve(importer, '..', source)
             : path$2.resolve(source)
+            ? path.resolve(importer, '..', source)
+            : path.resolve(source)
         : source;
+}
 …
     const [resolveStaticDependencyPromises, resolveDynamicImportPromises] = await loadPromise;
     return Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]);
+}
-class GlobalScope extends Scope {
-    constructor() {
-        super();
-        this.parent = null;
-        this.variables.set('undefined', new UndefinedVariable());
+    }
-    findVariable(name) {
-        let variable = this.variables.get(name);
-        if (!variable) {
-            variable = new GlobalVariable(name);
-            this.variables.set(name, variable);
+        }
-        return variable;
+    }
+}
 …
                 for (const module of this.modules) {
                     if (module.isExecuted) {
+                        module.hasTreeShakingPassStarted = true;
                         if (module.info.moduleSideEffects === 'no-treeshake') {
                             module.includeAllInBundle();
 …
         external: getIdMatcher(config.external),
         input: getInput(config),
+        jsx: getJsx(config),
         logLevel,
         makeAbsoluteExternalsRelative: config.makeAbsoluteExternalsRelative ?? 'ifRelativeSource',
 …
     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;
 …
         const contextByModuleId = Object.create(null);
         for (const [key, moduleContext] of Object.entries(configModuleContext)) {
             contextByModuleId[path$2.resolve(key)] = moduleContext;
+            contextByModuleId[path.resolve(key)] = moduleContext;
+        }
         return id => contextByModuleId[id] ?? context;
 …
         sourcemap: config.sourcemap || false,
         sourcemapBaseUrl: getSourcemapBaseUrl(config),
+        sourcemapDebugIds: config.sourcemapDebugIds || false,
         sourcemapExcludeSources: config.sourcemapExcludeSources || false,
         sourcemapFile: config.sourcemapFile,
 …
         strict: config.strict ?? true,
         systemNullSetters: config.systemNullSetters ?? true,
+        validate: config.validate || false
+        validate: config.validate || false,
+        virtualDirname: config.virtualDirname || '_virtual'
     };
     warnUnknownOptions(config, Object.keys(outputOptions), 'output options', inputOptions.onLog);
 …
         return undefined;
+    }
     return path$2.resolve(preserveModulesRoot);
+    return path.resolve(preserveModulesRoot);
 };
 const getAmd = (config) => {
 …
     return () => configAddon || '';
 };
-// eslint-disable-next-line unicorn/prevent-abbreviations
 const getDir = (config, file) => {
     const { dir } = config;
 …
 const validateInterop = (interop) => {
     if (!ALLOWED_INTEROP_TYPES.has(interop)) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.interop', parseAst_js.URL_OUTPUT_INTEROP,
+        // eslint-disable-next-line unicorn/prefer-spread
+        `use one of ${Array.from(ALLOWED_INTEROP_TYPES, value => JSON.stringify(value)).join(', ')}`, interop));
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.interop', parseAst_js.URL_OUTPUT_INTEROP, `use one of ${Array.from(ALLOWED_INTEROP_TYPES, value => JSON.stringify(value)).join(', ')}`, interop));
+    }
     return interop;
 …
 };
+// @ts-expect-error TS2540: the polyfill of `asyncDispose`.
+Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
 function rollup(rawInputOptions) {
     return rollupInternal(rawInputOptions, null);
 …
         },
         closed: false,
+        async [Symbol.asyncDispose]() {
+            await this.close();
+        },
         async generate(rawOutputOptions) {
             if (result.closed)
 …
+}
 async function writeOutputFile(outputFile, outputOptions) {
     const fileName = path$2.resolve(outputOptions.dir || path$2.dirname(outputOptions.file), outputFile.fileName);
+    const fileName = path.resolve(outputOptions.dir || path.dirname(outputOptions.file), outputFile.fileName);
     // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
     await promises.mkdir(path$2.dirname(fileName), { recursive: true });
+    await promises.mkdir(path.dirname(fileName), { recursive: true });
     return promises.writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
+}
 …
 exports.ensureArray = ensureArray$1;
 exports.getAugmentedNamespace = getAugmentedNamespace;
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
 exports.getNewArray = getNewArray;
 exports.getOrCreate = getOrCreate;
 …
 exports.mergeOptions = mergeOptions;
 exports.normalizePluginOption = normalizePluginOption;
-exports.picomatch = picomatch;
 exports.rollup = rollup;
 exports.rollupInternal = rollupInternal;

Note: See TracChangeset for help on using the changeset viewer.

Download in other formats: