@rollup/wasm-node 4.11.0 → 4.12.1

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

@@ -1,22 +1,22 @@
 /*
   @license
-	Rollup.js v4.11.0
-	Thu, 15 Feb 2024 06:09:01 GMT - commit 90ad652b745c5fe7167d92b4ad671cc387577a99
+	Rollup.js v4.12.1
+	Wed, 06 Mar 2024 06:02:59 GMT - commit f44dac3170a671b0978afa3af43818617904f544
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
-import { normalize, getImportPath, LOGLEVEL_WARN, logUnusedExternalImports, ANNOTATION_KEY, INVALID_ANNOTATION_KEY, logInvalidAnnotation, logRedeclarationError, logDuplicateArgumentNameError, logIllegalImportReassignment, logModuleLevelDirective, logConstVariableReassignError, logMissingExport, logCannotCallNamespace, logEval, LOGLEVEL_INFO, logFirstSideEffect, locate, logThisIsUndefined, logImportAttributeIsInvalid, logImportOptionsAreInvalid, error, logSyntheticNamedExportsNeedNamespaceExport, logMissingEntryExport, logInvalidFormatForTopLevelAwait, logDuplicateExportError, logInvalidSourcemapForError, augmentCodeLocation, logInconsistentImportAttributes, logNamespaceConflict, logAmbiguousExternalNamespaces, logShimmedExport, parseAst, logModuleParseError, parseAstAsync, logCircularReexport, logMissingNodeBuiltins, logIllegalIdentifierAsName, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, logAddonNotGenerated, logIncompatibleExportOptionValue, logMixedExport, logFailedValidation, isPathFragment, logCyclicCrossChunkReexport, getAliasName, logUnexpectedNamedImport, isAbsolute as isAbsolute$1, relative as relative$1, logUnexpectedNamespaceReexport, logEmptyChunk, logMissingGlobalName, logOptimizeChunkStatus, logSourcemapBroken, logConflictingSourcemapSources, logChunkInvalid, logInvalidOption, URL_OUTPUT_FORMAT, URL_OUTPUT_DIR, URL_OUTPUT_SOURCEMAPFILE, URL_OUTPUT_AMD_ID, logCannotAssignModuleToChunk, logAnonymousPluginCache, logDuplicatePluginName, LOGLEVEL_ERROR, logLevelPriority, relativeId, LOGLEVEL_DEBUG, logUnknownOption, printQuotedStringList, logInvalidSetAssetSourceCall, logPluginError, logNoTransformMapOrAstWithoutCode, logBadLoader, logExternalModulesCannotBeTransformedToModules, logInternalIdCannotBeExternal, isRelative, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logExternalSyntheticExports, logUnresolvedEntry, logUnresolvedImplicitDependant, logExternalModulesCannotBeIncludedInManualChunks, logEntryCannotBeExternal, logImplicitDependantCannotBeExternal, logNoAssetSourceSet, logFileReferenceIdNotFoundForFilename, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logInvalidRollupPhaseForChunkEmission, logFileNameConflict, logAssetNotFinalisedForFileName, logChunkNotGeneratedForFileName, logInvalidLogPosition, logInputHookInOutputPlugin, logInvalidFunctionPluginHook, logInvalidAddonPluginHook, logImplicitDependantIsNotIncluded, logCircularDependency, URL_TREESHAKE_MODULESIDEEFFECTS, URL_TREESHAKE, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_PRESERVEENTRYSIGNATURES, URL_OUTPUT_AMD_BASEPATH, logInvalidExportOptionValue, warnDeprecation, URL_OUTPUT_INTEROP, URL_OUTPUT_MANUALCHUNKS, isValidUrl, addTrailingSlashIfMissed, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_GENERATEDCODE, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, logAlreadyClosed, logMissingFileOrDirOption, logCannotEmitFromOptionsHook, URL_WATCH } from './parseAst.js';
+import { normalize, getImportPath, LOGLEVEL_WARN, logUnusedExternalImports, ANNOTATION_KEY, INVALID_ANNOTATION_KEY, Program as Program$1, logRedeclarationError, CatchClause as CatchClause$1, logDuplicateArgumentNameError, CallExpression as CallExpression$1, logIllegalImportReassignment, logModuleLevelDirective, ReturnStatement as ReturnStatement$1, Property as Property$1, logConstVariableReassignError, ExpressionStatement as ExpressionStatement$1, ArrowFunctionExpression as ArrowFunctionExpression$1, logMissingExport, logCannotCallNamespace, logEval, BlockStatement as BlockStatement$1, getRollupError, logParseError, logModuleParseError, error, LOGLEVEL_INFO, logFirstSideEffect, locate, logInvalidAnnotation, Identifier as Identifier$1, logThisIsUndefined, getReadStringFunction, convertString, convertAnnotations, FIXED_STRINGS, convertNode as convertNode$1, logImportAttributeIsInvalid, logImportOptionsAreInvalid, logSyntheticNamedExportsNeedNamespaceExport, logMissingEntryExport, logInvalidFormatForTopLevelAwait, logDuplicateExportError, logInvalidSourcemapForError, augmentCodeLocation, logInconsistentImportAttributes, logNamespaceConflict, logAmbiguousExternalNamespaces, logShimmedExport, parseAst, logCircularReexport, TemplateLiteral as TemplateLiteral$1, Literal as Literal$1, logMissingNodeBuiltins, logIllegalIdentifierAsName, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, logAddonNotGenerated, logIncompatibleExportOptionValue, logMixedExport, logFailedValidation, isPathFragment, logCyclicCrossChunkReexport, getAliasName, logUnexpectedNamedImport, isAbsolute as isAbsolute$1, relative as relative$1, logUnexpectedNamespaceReexport, logEmptyChunk, logMissingGlobalName, logOptimizeChunkStatus, logSourcemapBroken, logConflictingSourcemapSources, logChunkInvalid, logInvalidOption, URL_OUTPUT_FORMAT, URL_OUTPUT_DIR, URL_OUTPUT_SOURCEMAPFILE, URL_OUTPUT_AMD_ID, logCannotAssignModuleToChunk, logAnonymousPluginCache, logDuplicatePluginName, LOGLEVEL_ERROR, logLevelPriority, relativeId, LOGLEVEL_DEBUG, logUnknownOption, printQuotedStringList, logInvalidSetAssetSourceCall, logPluginError, logNoTransformMapOrAstWithoutCode, logBadLoader, logExternalModulesCannotBeTransformedToModules, logInternalIdCannotBeExternal, isRelative, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logExternalSyntheticExports, logUnresolvedEntry, logUnresolvedImplicitDependant, logExternalModulesCannotBeIncludedInManualChunks, logEntryCannotBeExternal, logImplicitDependantCannotBeExternal, logNoAssetSourceSet, logFileReferenceIdNotFoundForFilename, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logInvalidRollupPhaseForChunkEmission, logFileNameConflict, logAssetNotFinalisedForFileName, logChunkNotGeneratedForFileName, logInvalidLogPosition, logInputHookInOutputPlugin, logInvalidFunctionPluginHook, logInvalidAddonPluginHook, logImplicitDependantIsNotIncluded, logCircularDependency, URL_TREESHAKE_MODULESIDEEFFECTS, URL_TREESHAKE, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_PRESERVEENTRYSIGNATURES, URL_OUTPUT_AMD_BASEPATH, logInvalidExportOptionValue, warnDeprecation, URL_OUTPUT_INTEROP, URL_OUTPUT_MANUALCHUNKS, isValidUrl, addTrailingSlashIfMissed, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_GENERATEDCODE, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, logAlreadyClosed, logMissingFileOrDirOption, logCannotEmitFromOptionsHook, URL_WATCH } from './parseAst.js';
 import { relative, dirname, basename, extname, resolve as resolve$1 } from 'node:path';
 import require$$0$1, { win32, posix, isAbsolute, resolve } from 'path';
+import { parseAsync, xxhashBase64Url, xxhashBase36, xxhashBase16 } from '../../native.js';
 import process$1, { env as env$1 } from 'node:process';
 import { performance } from 'node:perf_hooks';
-import { xxhashBase64Url, xxhashBase36, xxhashBase16 } from '../../native.js';
 import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import * as tty from 'tty';
 
-var version = "4.11.0";
+var version = "4.12.1";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -4617,13 +4617,83 @@ function getMemberReturnExpressionWhenCalled(members, memberName) {
     return [members[memberName].returns, false];
 }
 
-const keys = {
+// This file is generated by scripts/generate-ast-converters.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: ['id', 'superClass', 'body'],
+    ClassExpression: ['id', 'superClass', 'body'],
+    ConditionalExpression: ['test', 'consequent', 'alternate'],
+    ContinueStatement: ['label'],
+    DebuggerStatement: [],
+    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: [],
-    Program: ['body']
+    LogicalExpression: ['left', 'right'],
+    MemberExpression: ['object', 'property'],
+    MetaProperty: ['meta', 'property'],
+    MethodDefinition: ['key', 'value'],
+    NewExpression: ['callee', 'arguments'],
+    ObjectExpression: ['properties'],
+    ObjectPattern: ['properties'],
+    PanicError: [],
+    ParseError: [],
+    PrivateIdentifier: [],
+    Program: ['body'],
+    Property: ['key', 'value'],
+    PropertyDefinition: ['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']
 };
-function createKeysForNode(esTreeNode) {
-    return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
-}
 
 const INCLUDE_PARAMETERS = 'variables';
 class NodeBase extends ExpressionEntity {
@@ -4639,22 +4709,11 @@ class NodeBase extends ExpressionEntity {
     set deoptimized(value) {
         this.flags = setFlag(this.flags, 2 /* Flag.deoptimized */, value);
     }
-    constructor(esTreeNode, parent, parentScope, keepEsTreeNode = false) {
+    constructor(parent, parentScope) {
         super();
-        // Nodes can opt-in to keep the AST if needed during the build pipeline.
-        // Avoid true when possible as large AST takes up memory.
-        if (keepEsTreeNode) {
-            this.esTreeNode = esTreeNode;
-        }
-        const { type } = esTreeNode;
-        keys[type] ||= createKeysForNode(esTreeNode);
         this.parent = parent;
         this.scope = parentScope;
         this.createScope(parentScope);
-        this.parseNode(esTreeNode);
-        this.initialise();
-        this.scope.context.magicString.addSourcemapLocation(this.start);
-        this.scope.context.magicString.addSourcemapLocation(this.end);
     }
     addExportedVariables(_variables, _exportNamesByVariable) { }
     /**
@@ -4662,7 +4721,7 @@ class NodeBase extends ExpressionEntity {
      * that require the scopes to be populated with variables.
      */
     bind() {
-        for (const key of keys[this.type]) {
+        for (const key of childNodeKeys[this.type]) {
             const value = this[key];
             if (Array.isArray(value)) {
                 for (const child of value) {
@@ -4684,7 +4743,7 @@ class NodeBase extends ExpressionEntity {
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        for (const key of keys[this.type]) {
+        for (const key of childNodeKeys[this.type]) {
             const value = this[key];
             if (value === null)
                 continue;
@@ -4707,7 +4766,7 @@ class NodeBase extends ExpressionEntity {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         this.included = true;
-        for (const key of keys[this.type]) {
+        for (const key of childNodeKeys[this.type]) {
             const value = this[key];
             if (value === null)
                 continue;
@@ -4728,8 +4787,11 @@ class NodeBase extends ExpressionEntity {
      * Override to perform special initialisation steps after the scope is
      * initialised
      */
-    initialise() { }
-    parseNode(esTreeNode, keepEsTreeNodeKeys) {
+    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
@@ -4739,20 +4801,10 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (key.charCodeAt(0) === 95 /* _ */) {
                 if (key === ANNOTATION_KEY) {
-                    const annotations = value;
-                    this.annotations = annotations;
-                    if (this.scope.context.options.treeshake.annotations) {
-                        this.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
-                        this.annotationPure = annotations.some(comment => comment.type === 'pure');
-                    }
+                    this.annotations = value;
                 }
                 else if (key === INVALID_ANNOTATION_KEY) {
-                    for (const { start, end, type } of value) {
-                        this.scope.context.magicString.remove(start, end);
-                        if (type === 'pure' || type === 'noSideEffects') {
-                            this.scope.context.log(LOGLEVEL_WARN, logInvalidAnnotation(this.scope.context.code.slice(start, end), this.scope.context.module.id, type), start);
-                        }
-                    }
+                    this.invalidAnnotations = value;
                 }
             }
             else if (typeof value !== 'object' || value === null) {
@@ -4763,13 +4815,17 @@ class NodeBase extends ExpressionEntity {
                 for (const child of value) {
                     this[key].push(child === null
                         ? null
-                        : new (this.scope.context.getNodeConstructor(child.type))(child, this, this.scope, keepEsTreeNodeKeys?.includes(key)));
+                        : new (this.scope.context.getNodeConstructor(child.type))(this, this.scope).parseNode(child));
                 }
             }
             else {
-                this[key] = new (this.scope.context.getNodeConstructor(value.type))(value, this, this.scope, keepEsTreeNodeKeys?.includes(key));
+                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) {
@@ -4779,7 +4835,7 @@ class NodeBase extends ExpressionEntity {
         }
     }
     render(code, options) {
-        for (const key of keys[this.type]) {
+        for (const key of childNodeKeys[this.type]) {
             const value = this[key];
             if (value === null)
                 continue;
@@ -4806,7 +4862,7 @@ class NodeBase extends ExpressionEntity {
      */
     applyDeoptimizations() {
         this.deoptimized = true;
-        for (const key of keys[this.type]) {
+        for (const key of childNodeKeys[this.type]) {
             const value = this[key];
             if (value === null)
                 continue;
@@ -4822,6 +4878,9 @@ class NodeBase extends ExpressionEntity {
         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) {
@@ -5574,16 +5633,6 @@ class ArrayPattern extends NodeBase {
     }
 }
 
-const ArrowFunctionExpression$1 = 'ArrowFunctionExpression';
-const BlockStatement$1 = 'BlockStatement';
-const CallExpression$1 = 'CallExpression';
-const CatchClause$1 = 'CatchClause';
-const ExpressionStatement$1 = 'ExpressionStatement';
-const Identifier$1 = 'Identifier';
-const Program$1 = 'Program';
-const Property$1 = 'Property';
-const ReturnStatement$1 = 'ReturnStatement';
-
 class LocalVariable extends Variable {
     constructor(name, declarator, init, context, kind) {
         super(name);
@@ -5728,7 +5777,7 @@ 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" /* VariableKind.parameter */);
+        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
         this.deoptimizationInteractions = [];
         this.deoptimizations = new PathTracker();
         this.deoptimizedFields = new Set();
@@ -5865,7 +5914,7 @@ class Scope {
         const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
         if (existingVariable) {
             const existingKind = existingVariable.kind;
-            if (kind === "var" /* VariableKind.var */ && existingKind === "var" /* VariableKind.var */) {
+            if (kind === 'var' && existingKind === 'var') {
                 existingVariable.addDeclaration(identifier, init);
                 return existingVariable;
             }
@@ -5976,12 +6025,12 @@ class CatchBodyScope extends ChildScope {
         this.parent = parent;
     }
     addDeclaration(identifier, context, init, kind) {
-        if (kind === "var" /* VariableKind.var */) {
+        if (kind === 'var') {
             const name = identifier.name;
             const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
             if (existingVariable) {
                 const existingKind = existingVariable.kind;
-                if (existingKind === "parameter" /* VariableKind.parameter */ &&
+                if (existingKind === 'parameter' &&
                     // If this is a destructured parameter, it is forbidden to redeclare
                     existingVariable.declarations[0].parent.type === CatchClause$1) {
                     // If this is a var with the same name as the catch scope parameter,
@@ -6000,7 +6049,7 @@ class CatchBodyScope extends ChildScope {
                     this.addHoistedVariable(name, declaredVariable);
                     return declaredVariable;
                 }
-                if (existingKind === "var" /* VariableKind.var */) {
+                if (existingKind === 'var') {
                     existingVariable.addDeclaration(identifier, init);
                     return existingVariable;
                 }
@@ -6030,10 +6079,8 @@ class FunctionBodyScope extends ChildScope {
         const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
         if (existingVariable) {
             const existingKind = existingVariable.kind;
-            if ((kind === "var" /* VariableKind.var */ || kind === "function" /* VariableKind.function */) &&
-                (existingKind === "var" /* VariableKind.var */ ||
-                    existingKind === "function" /* VariableKind.function */ ||
-                    existingKind === "parameter" /* VariableKind.parameter */)) {
+            if ((kind === 'var' || kind === 'function') &&
+                (existingKind === 'var' || existingKind === 'function' || existingKind === 'parameter')) {
                 existingVariable.addDeclaration(identifier, init);
                 return existingVariable;
             }
@@ -7254,7 +7301,7 @@ class Identifier extends NodeBase {
         let variable;
         const { treeshake } = this.scope.context.options;
         switch (kind) {
-            case "var" /* VariableKind.var */: {
+            case 'var': {
                 variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
                 if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
                     // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
@@ -7262,18 +7309,18 @@ class Identifier extends NodeBase {
                 }
                 break;
             }
-            case "function" /* VariableKind.function */: {
+            case 'function': {
                 // in strict mode, functions are only hoisted within a scope but not across block scopes
                 variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
                 break;
             }
-            case "let" /* VariableKind.let */:
-            case "const" /* VariableKind.const */:
-            case "class" /* VariableKind.class */: {
+            case 'let':
+            case 'const':
+            case 'class': {
                 variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
                 break;
             }
-            case "parameter" /* VariableKind.parameter */: {
+            case 'parameter': {
                 variable = this.scope.addParameterDeclaration(this);
                 break;
             }
@@ -7306,7 +7353,7 @@ class Identifier extends NodeBase {
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        if (this.isPossibleTDZ() && this.variable.kind !== "var" /* VariableKind.var */) {
+        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
             return true;
         }
         return (this.scope.context.options.treeshake
@@ -7581,12 +7628,12 @@ class BlockScope extends ChildScope {
         super(parent, parent.context);
     }
     addDeclaration(identifier, context, init, kind) {
-        if (kind === "var" /* VariableKind.var */) {
+        if (kind === 'var') {
             const name = identifier.name;
             const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
             if (existingVariable) {
-                if (existingVariable.kind === "var" /* VariableKind.var */ ||
-                    (kind === "var" /* VariableKind.var */ && existingVariable.kind === "parameter" /* VariableKind.parameter */)) {
+                if (existingVariable.kind === 'var' ||
+                    (kind === 'var' && existingVariable.kind === 'parameter')) {
                     existingVariable.addDeclaration(identifier, init);
                     return existingVariable;
                 }
@@ -7606,6 +7653,7 @@ class BlockScope extends ChildScope {
 
 class ExpressionStatement extends NodeBase {
     initialise() {
+        super.initialise();
         if (this.directive &&
             this.directive !== 'use strict' &&
             this.parent.type === Program$1) {
@@ -7679,6 +7727,7 @@ class BlockStatement extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         const firstBodyStatement = this.body[0];
         this.deoptimizeBody =
             firstBodyStatement instanceof ExpressionStatement &&
@@ -7742,6 +7791,12 @@ class FunctionBase extends NodeBase {
     set deoptimizedReturn(value) {
         this.flags = setFlag(this.flags, 512 /* Flag.deoptimizedReturn */, value);
     }
+    get generator() {
+        return isFlagSet(this.flags, 4194304 /* Flag.generator */);
+    }
+    set generator(value) {
+        this.flags = setFlag(this.flags, 4194304 /* Flag.generator */, value);
+    }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         if (interaction.type === INTERACTION_CALLED) {
             const { parameters } = this.scope;
@@ -7838,12 +7893,17 @@ class FunctionBase extends NodeBase {
         this.scope.includeCallArguments(context, parameters);
     }
     initialise() {
+        super.initialise();
         if (this.body instanceof BlockStatement) {
             this.body.addImplicitReturnExpressionToScope();
         }
         else {
             this.scope.addReturnExpression(this.body);
         }
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationNoSideEffects = this.annotations.some(comment => comment.type === 'noSideEffects');
+        }
     }
     parseNode(esTreeNode) {
         const { body, params } = esTreeNode;
@@ -7854,11 +7914,11 @@ class FunctionBase extends NodeBase {
         // so that the scope already knows all parameters and can detect conflicts
         // when parsing the body.
         for (const parameter of params) {
-            parameters.push(new (context.getNodeConstructor(parameter.type))(parameter, this, scope, false));
+            parameters.push(new (context.getNodeConstructor(parameter.type))(this, scope).parseNode(parameter));
         }
-        scope.addParameterVariables(parameters.map(parameter => parameter.declare("parameter" /* VariableKind.parameter */, UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
-        this.body = new (context.getNodeConstructor(body.type))(body, this, bodyScope);
-        super.parseNode(esTreeNode);
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        this.body = new (context.getNodeConstructor(body.type))(this, bodyScope).parseNode(body);
+        return super.parseNode(esTreeNode);
     }
     addArgumentToBeDeoptimized(_argument) { }
     applyDeoptimizations() { }
@@ -7870,6 +7930,12 @@ class ArrowFunctionExpression extends FunctionBase {
         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);
     }
@@ -8028,6 +8094,7 @@ class AssignmentExpression extends NodeBase {
         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') {
@@ -8122,7 +8189,7 @@ class AssignmentPattern extends NodeBase {
 
 class ArgumentsVariable extends LocalVariable {
     constructor(context) {
-        super('arguments', null, UNKNOWN_EXPRESSION, context, "other" /* VariableKind.other */);
+        super('arguments', null, UNKNOWN_EXPRESSION, context, 'other');
         this.deoptimizedArguments = [];
     }
     addArgumentToBeDeoptimized(argument) {
@@ -8245,7 +8312,7 @@ class FunctionNode extends FunctionBase {
     }
     initialise() {
         super.initialise();
-        this.id?.declare("function" /* VariableKind.function */, this);
+        this.id?.declare('function', this);
     }
     addArgumentToBeDeoptimized(argument) {
         this.scope.argumentsVariable.addArgumentToBeDeoptimized(argument);
@@ -8442,12 +8509,13 @@ class Literal extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         this.members = getLiteralMembersForValue(this.value);
     }
     parseNode(esTreeNode) {
         this.value = esTreeNode.value;
         this.regex = esTreeNode.regex;
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
     render(code) {
         if (typeof this.value === 'string') {
@@ -8665,6 +8733,7 @@ class MemberExpression extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         this.propertyKey = getResolvablePropertyKey(this);
         this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
     }
@@ -8944,6 +9013,13 @@ class CallExpression extends CallExpressionBase {
         }
         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');
+        }
+    }
     isSkippedAsOptional(origin) {
         return (this.callee.isSkippedAsOptional?.(origin) ||
             (this.optional &&
@@ -8978,11 +9054,11 @@ class CatchClause extends NodeBase {
         const { body, param, type } = esTreeNode;
         this.type = type;
         if (param) {
-            this.param = new (this.scope.context.getNodeConstructor(param.type))(param, this, this.scope);
-            this.param.declare("parameter" /* VariableKind.parameter */, UNKNOWN_EXPRESSION);
+            this.param = new (this.scope.context.getNodeConstructor(param.type))(this, this.scope).parseNode(param);
+            this.param.declare('parameter', UNKNOWN_EXPRESSION);
         }
-        this.body = new BlockStatement(body, this, this.scope.bodyScope);
-        super.parseNode(esTreeNode);
+        this.body = new BlockStatement(this, this.scope.bodyScope).parseNode(body);
+        return super.parseNode(esTreeNode);
     }
 }
 CatchClause.prototype.preventChildBlockScope = true;
@@ -9009,7 +9085,7 @@ 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" /* VariableKind.other */)));
+        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));
     }
@@ -9032,9 +9108,9 @@ class ClassBody extends NodeBase {
     parseNode(esTreeNode) {
         const body = (this.body = []);
         for (const definition of esTreeNode.body) {
-            body.push(new (this.scope.context.getNodeConstructor(definition.type))(definition, this, definition.static ? this.scope : this.scope.instanceScope));
+            body.push(new (this.scope.context.getNodeConstructor(definition.type))(this, definition.static ? this.scope : this.scope.instanceScope).parseNode(definition));
         }
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
     applyDeoptimizations() { }
 }
@@ -9193,7 +9269,8 @@ class ClassNode extends NodeBase {
         }
     }
     initialise() {
-        this.id?.declare("class" /* VariableKind.class */, this);
+        super.initialise();
+        this.id?.declare('class', this);
         for (const method of this.body.body) {
             if (method instanceof MethodDefinition && method.kind === 'constructor') {
                 this.classConstructor = method;
@@ -9263,9 +9340,9 @@ class ClassDeclaration extends ClassNode {
     }
     parseNode(esTreeNode) {
         if (esTreeNode.id !== null) {
-            this.id = new Identifier(esTreeNode.id, this, this.scope.parent);
+            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
         }
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
     render(code, options) {
         const { exportNamesByVariable, format, snippets: { _, getPropertyAccess } } = options;
@@ -9505,6 +9582,12 @@ class ContinueStatement extends NodeBase {
     }
 }
 
+class DebuggerStatement extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+}
+
 function hasLoopBodyEffects(context, body) {
     const { brokenFlow, hasBreak, hasContinue, ignore } = context;
     const { breaks, continues } = ignore;
@@ -9555,6 +9638,7 @@ class ExportAllDeclaration extends NodeBase {
         return false;
     }
     initialise() {
+        super.initialise();
         this.scope.context.addExport(this);
     }
     render(code, _options, nodeRenderOptions) {
@@ -9573,9 +9657,9 @@ class FunctionDeclaration extends FunctionNode {
     }
     parseNode(esTreeNode) {
         if (esTreeNode.id !== null) {
-            this.id = new Identifier(esTreeNode.id, this, this.scope.parent);
+            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
         }
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
 }
 
@@ -9600,6 +9684,7 @@ class ExportDefaultDeclaration extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         const declaration = this.declaration;
         this.declarationName =
             (declaration.id && declaration.id.name) || this.declaration.name;
@@ -9683,6 +9768,7 @@ class ExportNamedDeclaration extends NodeBase {
         return !!this.declaration?.hasEffects(context);
     }
     initialise() {
+        super.initialise();
         this.scope.context.addExport(this);
     }
     removeAnnotations(code) {
@@ -9728,6 +9814,7 @@ class ForInStatement extends NodeBase {
         includeLoopBody(context, body, includeChildrenRecursively);
     }
     initialise() {
+        super.initialise();
         this.left.setAssignedValue(UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -9772,6 +9859,7 @@ class ForOfStatement extends NodeBase {
         includeLoopBody(context, body, includeChildrenRecursively);
     }
     initialise() {
+        super.initialise();
         this.left.setAssignedValue(UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -9824,9 +9912,9 @@ class FunctionExpression extends FunctionNode {
     }
     parseNode(esTreeNode) {
         if (esTreeNode.id !== null) {
-            this.id = new Identifier(esTreeNode.id, this, this.idScope);
+            this.id = new Identifier(this, this.idScope).parseNode(esTreeNode.id);
         }
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
     render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
@@ -9893,13 +9981,11 @@ class IfStatement extends NodeBase {
         }
     }
     parseNode(esTreeNode) {
-        this.consequentScope = new TrackingScope(this.scope);
-        this.consequent = new (this.scope.context.getNodeConstructor(esTreeNode.consequent.type))(esTreeNode.consequent, this, this.consequentScope);
+        this.consequent = new (this.scope.context.getNodeConstructor(esTreeNode.consequent.type))(this, (this.consequentScope = new TrackingScope(this.scope))).parseNode(esTreeNode.consequent);
         if (esTreeNode.alternate) {
-            this.alternateScope = new TrackingScope(this.scope);
-            this.alternate = new (this.scope.context.getNodeConstructor(esTreeNode.alternate.type))(esTreeNode.alternate, this, this.alternateScope);
+            this.alternate = new (this.scope.context.getNodeConstructor(esTreeNode.alternate.type))(this, (this.alternateScope = new TrackingScope(this.scope))).parseNode(esTreeNode.alternate);
         }
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
     render(code, options) {
         const { snippets: { getPropertyAccess } } = options;
@@ -10025,6 +10111,7 @@ class ImportDeclaration extends NodeBase {
         return false;
     }
     initialise() {
+        super.initialise();
         this.scope.context.addImport(this);
     }
     render(code, _options, nodeRenderOptions) {
@@ -10415,11 +10502,12 @@ class ImportExpression extends NodeBase {
         this.source.include(context, includeChildrenRecursively);
     }
     initialise() {
+        super.initialise();
         this.scope.context.addDynamicImport(this);
     }
     parseNode(esTreeNode) {
-        // Keep the source AST to be used by renderDynamicImport
-        super.parseNode(esTreeNode, ['source']);
+        this.sourceAstNode = esTreeNode.source;
+        return super.parseNode(esTreeNode);
     }
     render(code, options) {
         const { snippets: { _, getDirectReturnFunction, getObject, getPropertyAccess } } = options;
@@ -10896,18 +10984,18 @@ const getGenericImportMetaMechanism = (getUrl) => (property, { chunkId }) => {
             : 'undefined';
 };
 const getFileUrlFromFullPath = (path) => `require('u' + 'rl').pathToFileURL(${path}).href`;
-const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${path}'`);
+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('${relativePath}'), document.baseURI`);
+        return getResolveUrl(`require.toUrl('${escapeId(relativePath)}'), document.baseURI`);
     },
     cjs: relativePath => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath)})`,
-    es: relativePath => getResolveUrl(`'${relativePath}', import.meta.url`),
+    es: relativePath => getResolveUrl(`'${escapeId(relativePath)}', import.meta.url`),
     iife: relativePath => getRelativeUrlFromDocument(relativePath),
-    system: relativePath => getResolveUrl(`'${relativePath}', module.meta.url`),
+    system: relativePath => getResolveUrl(`'${escapeId(relativePath)}', module.meta.url`),
     umd: relativePath => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath, true)})`
 };
 const importMetaMechanisms = {
@@ -10952,11 +11040,16 @@ class NewExpression extends NodeBase {
         this.callee.includeCallArguments(context, this.arguments);
     }
     initialise() {
+        super.initialise();
         this.interaction = {
             args: [null, ...this.arguments],
             type: INTERACTION_CALLED,
             withNew: true
         };
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
+        }
     }
     render(code, options) {
         this.callee.render(code, options);
@@ -11042,6 +11135,29 @@ class ObjectExpression extends NodeBase {
     }
 }
 
+class PanicError extends NodeBase {
+    initialise() {
+        const id = this.scope.context.module.id;
+        // This simulates the current nested error structure. We could also just
+        // replace it with a flat error.
+        const parseError = getRollupError(logParseError(this.message));
+        const moduleParseError = logModuleParseError(parseError, id);
+        return error(moduleParseError);
+    }
+}
+
+class ParseError extends NodeBase {
+    initialise() {
+        const pos = this.start;
+        const id = this.scope.context.module.id;
+        // This simulates the current nested error structure. We could also just
+        // replace it with a flat error.
+        const parseError = getRollupError(logParseError(this.message, pos));
+        const moduleParseError = logModuleParseError(parseError, id);
+        this.scope.context.error(moduleParseError, pos);
+    }
+}
+
 class PrivateIdentifier extends NodeBase {
 }
 
@@ -11080,6 +11196,16 @@ class Program extends NodeBase {
             }
         }
     }
+    initialise() {
+        super.initialise();
+        if (this.invalidAnnotations)
+            for (const { start, end, type } of this.invalidAnnotations) {
+                this.scope.context.magicString.remove(start, end);
+                if (type === 'pure' || type === 'noSideEffects') {
+                    this.scope.context.log(LOGLEVEL_WARN, logInvalidAnnotation(this.scope.context.code.slice(start, end), this.scope.context.module.id, type), start);
+                }
+            }
+    }
     render(code, options) {
         let start = this.start;
         if (code.original.startsWith('#!')) {
@@ -11198,6 +11324,7 @@ class ReturnStatement extends NodeBase {
         context.brokenFlow = true;
     }
     initialise() {
+        super.initialise();
         this.scope.addReturnExpression(this.argument || UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -11419,6 +11546,7 @@ class SwitchStatement extends NodeBase {
         context.hasBreak = hasBreak;
     }
     initialise() {
+        super.initialise();
         for (let caseIndex = 0; caseIndex < this.cases.length; caseIndex++) {
             if (this.cases[caseIndex].test === null) {
                 this.defaultCase = caseIndex;
@@ -11428,8 +11556,8 @@ class SwitchStatement extends NodeBase {
         this.defaultCase = null;
     }
     parseNode(esTreeNode) {
-        this.discriminant = new (this.scope.context.getNodeConstructor(esTreeNode.discriminant.type))(esTreeNode.discriminant, this, this.parentScope);
-        super.parseNode(esTreeNode);
+        this.discriminant = new (this.scope.context.getNodeConstructor(esTreeNode.discriminant.type))(this, this.parentScope).parseNode(esTreeNode.discriminant);
+        return super.parseNode(esTreeNode);
     }
     render(code, options) {
         this.discriminant.render(code, options);
@@ -11482,6 +11610,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
         }
     }
     initialise() {
+        super.initialise();
         this.args = [UNKNOWN_EXPRESSION, ...this.quasi.expressions];
         this.interaction = {
             args: [
@@ -11527,7 +11656,7 @@ class TemplateElement extends NodeBase {
     }
     parseNode(esTreeNode) {
         this.value = esTreeNode.value;
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
     render() { }
 }
@@ -11572,7 +11701,7 @@ class UndefinedVariable extends Variable {
 
 class ExportDefaultVariable extends LocalVariable {
     constructor(name, exportDefaultDeclaration, context) {
-        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, "other" /* VariableKind.other */);
+        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, 'other');
         this.hasId = false;
         this.originalId = null;
         this.originalVariable = null;
@@ -11643,7 +11772,7 @@ class ExportDefaultVariable extends LocalVariable {
 class ModuleScope extends ChildScope {
     constructor(parent, context) {
         super(parent, context);
-        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, context, "other" /* VariableKind.other */));
+        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, context, 'other'));
     }
     addDeclaration(identifier, context, init, kind) {
         if (this.context.module.importDescriptions.has(identifier.name)) {
@@ -11701,6 +11830,7 @@ class ThisExpression extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         this.alias =
             this.scope.findLexicalBoundary() instanceof ModuleScope
                 ? this.scope.context.moduleContext
@@ -11817,15 +11947,6 @@ class UnaryExpression extends NodeBase {
     }
 }
 
-class UnknownNode extends NodeBase {
-    hasEffects() {
-        return true;
-    }
-    include(context) {
-        super.include(context, true);
-    }
-}
-
 class UpdateExpression extends NodeBase {
     hasEffects(context) {
         if (!this.deoptimized)
@@ -11842,6 +11963,7 @@ class UpdateExpression extends NodeBase {
         this.argument.includeAsAssignmentTarget(context, includeChildrenRecursively, true);
     }
     initialise() {
+        super.initialise();
         this.argument.setAssignedValue(UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -11921,6 +12043,7 @@ class VariableDeclaration extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         for (const declarator of this.declarations) {
             declarator.declareDeclarator(this.kind);
         }
@@ -12086,6 +12209,711 @@ class YieldExpression extends NodeBase {
     }
 }
 
+// This file is generated by scripts/generate-ast-converters.js.
+// Do not edit this file directly.
+function convertProgram(buffer, parent, parentScope) {
+    return convertNode(parent, parentScope, 0, new Uint32Array(buffer.buffer), getReadStringFunction(buffer));
+}
+const nodeTypeStrings = [
+    'PanicError',
+    'ParseError',
+    'ArrayExpression',
+    'ArrayPattern',
+    'ArrowFunctionExpression',
+    'AssignmentExpression',
+    'AssignmentPattern',
+    'AwaitExpression',
+    'BinaryExpression',
+    'BlockStatement',
+    'BreakStatement',
+    'CallExpression',
+    'CatchClause',
+    'ChainExpression',
+    'ClassBody',
+    'ClassDeclaration',
+    'ClassExpression',
+    'ConditionalExpression',
+    'ContinueStatement',
+    'DebuggerStatement',
+    'ExpressionStatement',
+    'DoWhileStatement',
+    'EmptyStatement',
+    'ExportAllDeclaration',
+    'ExportDefaultDeclaration',
+    'ExportNamedDeclaration',
+    'ExportSpecifier',
+    'ExpressionStatement',
+    'ForInStatement',
+    'ForOfStatement',
+    'ForStatement',
+    'FunctionDeclaration',
+    'FunctionExpression',
+    'Identifier',
+    'IfStatement',
+    'ImportAttribute',
+    'ImportDeclaration',
+    'ImportDefaultSpecifier',
+    'ImportExpression',
+    'ImportNamespaceSpecifier',
+    'ImportSpecifier',
+    'LabeledStatement',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'LogicalExpression',
+    'MemberExpression',
+    'MetaProperty',
+    'MethodDefinition',
+    'NewExpression',
+    'ObjectExpression',
+    'ObjectPattern',
+    'PrivateIdentifier',
+    'Program',
+    'Property',
+    'PropertyDefinition',
+    'RestElement',
+    'ReturnStatement',
+    'SequenceExpression',
+    'SpreadElement',
+    'StaticBlock',
+    'Super',
+    'SwitchCase',
+    'SwitchStatement',
+    'TaggedTemplateExpression',
+    'TemplateElement',
+    'TemplateLiteral',
+    'ThisExpression',
+    'ThrowStatement',
+    'TryStatement',
+    'UnaryExpression',
+    'UpdateExpression',
+    'VariableDeclaration',
+    'VariableDeclarator',
+    'WhileStatement',
+    'YieldExpression'
+];
+const nodeConstructors$1 = [
+    PanicError,
+    ParseError,
+    ArrayExpression,
+    ArrayPattern,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    AssignmentPattern,
+    AwaitExpression,
+    BinaryExpression,
+    BlockStatement,
+    BreakStatement,
+    CallExpression,
+    CatchClause,
+    ChainExpression,
+    ClassBody,
+    ClassDeclaration,
+    ClassExpression,
+    ConditionalExpression,
+    ContinueStatement,
+    DebuggerStatement,
+    ExpressionStatement,
+    DoWhileStatement,
+    EmptyStatement,
+    ExportAllDeclaration,
+    ExportDefaultDeclaration,
+    ExportNamedDeclaration,
+    ExportSpecifier,
+    ExpressionStatement,
+    ForInStatement,
+    ForOfStatement,
+    ForStatement,
+    FunctionDeclaration,
+    FunctionExpression,
+    Identifier,
+    IfStatement,
+    ImportAttribute,
+    ImportDeclaration,
+    ImportDefaultSpecifier,
+    ImportExpression,
+    ImportNamespaceSpecifier,
+    ImportSpecifier,
+    LabeledStatement,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    MetaProperty,
+    MethodDefinition,
+    NewExpression,
+    ObjectExpression,
+    ObjectPattern,
+    PrivateIdentifier,
+    Program,
+    Property,
+    PropertyDefinition,
+    RestElement,
+    ReturnStatement,
+    SequenceExpression,
+    SpreadElement,
+    StaticBlock,
+    Super,
+    SwitchCase,
+    SwitchStatement,
+    TaggedTemplateExpression,
+    TemplateElement,
+    TemplateLiteral,
+    ThisExpression,
+    ThrowStatement,
+    TryStatement,
+    UnaryExpression,
+    UpdateExpression,
+    VariableDeclaration,
+    VariableDeclarator,
+    WhileStatement,
+    YieldExpression
+];
+const bufferParsers = [
+    function panicError(node, position, buffer, readString) {
+        node.message = convertString(position, buffer, readString);
+    },
+    function parseError(node, position, buffer, readString) {
+        node.message = convertString(position, buffer, readString);
+    },
+    function arrayExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.elements = convertNodeList(node, scope, position, buffer, readString);
+    },
+    function arrayPattern(node, position, buffer, readString) {
+        const { scope } = node;
+        node.elements = convertNodeList(node, scope, position, buffer, readString);
+    },
+    function arrowFunctionExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.expression = (flags & 2) === 2;
+        node.generator = (flags & 4) === 4;
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 1], buffer, readString));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 2], buffer, readString);
+        const annotations = (node.annotations = convertAnnotations(position + 3, buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+    },
+    function assignmentExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.right = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.left = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function assignmentPattern(node, position, buffer, readString) {
+        const { scope } = node;
+        node.right = convertNode(node, scope, buffer[position], buffer, readString);
+        node.left = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function awaitExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, position, buffer, readString);
+    },
+    function binaryExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.right = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.left = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function blockStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, position, buffer, readString);
+    },
+    function breakStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        const labelPosition = buffer[position];
+        node.label =
+            labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer, readString);
+    },
+    function callExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.optional = (flags & 1) === 1;
+        node.callee = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.arguments = convertNodeList(node, scope, buffer[position + 2], buffer, readString);
+        node.annotations = convertAnnotations(position + 3, buffer);
+    },
+    function catchClause(node, position, buffer, readString) {
+        const { scope } = node;
+        const parameterPosition = buffer[position];
+        const parameter = (node.param =
+            parameterPosition === 0
+                ? null
+                : convertNode(node, scope, parameterPosition, buffer, readString));
+        parameter?.declare('parameter', UNKNOWN_EXPRESSION);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 1], buffer, readString);
+    },
+    function chainExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, position, buffer, readString);
+    },
+    function classBody(node, position, buffer, readString) {
+        const { scope } = node;
+        const length = buffer[position];
+        const body = (node.body = []);
+        for (let index = 0; index < length; index++) {
+            const nodePosition = buffer[position + 1 + index];
+            body.push(convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer, readString));
+        }
+    },
+    function classDeclaration(node, position, buffer, readString) {
+        const { scope } = node;
+        const idPosition = buffer[position];
+        node.id =
+            idPosition === 0
+                ? null
+                : convertNode(node, scope.parent, idPosition, buffer, readString);
+        const superClassPosition = buffer[position + 1];
+        node.superClass =
+            superClassPosition === 0
+                ? null
+                : convertNode(node, scope, superClassPosition, buffer, readString);
+        node.body = convertNode(node, scope, buffer[position + 2], buffer, readString);
+    },
+    function classExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const idPosition = buffer[position];
+        node.id = idPosition === 0 ? null : convertNode(node, scope, idPosition, buffer, readString);
+        const superClassPosition = buffer[position + 1];
+        node.superClass =
+            superClassPosition === 0
+                ? null
+                : convertNode(node, scope, superClassPosition, buffer, readString);
+        node.body = convertNode(node, scope, buffer[position + 2], buffer, readString);
+    },
+    function conditionalExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.consequent = convertNode(node, scope, buffer[position], buffer, readString);
+        node.alternate = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.test = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function continueStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        const labelPosition = buffer[position];
+        node.label =
+            labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer, readString);
+    },
+    function debuggerStatement() { },
+    function directive(node, position, buffer, readString) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer, readString);
+        node.directive = convertString(position + 1, buffer, readString);
+    },
+    function doWhileStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.test = convertNode(node, scope, buffer[position], buffer, readString);
+        node.body = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function emptyStatement() { },
+    function exportAllDeclaration(node, position, buffer, readString) {
+        const { scope } = node;
+        const exportedPosition = buffer[position];
+        node.exported =
+            exportedPosition === 0
+                ? null
+                : convertNode(node, scope, exportedPosition, buffer, readString);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer, readString);
+    },
+    function exportDefaultDeclaration(node, position, buffer, readString) {
+        const { scope } = node;
+        node.declaration = convertNode(node, scope, position, buffer, readString);
+    },
+    function exportNamedDeclaration(node, position, buffer, readString) {
+        const { scope } = node;
+        const sourcePosition = buffer[position];
+        node.source =
+            sourcePosition === 0 ? null : convertNode(node, scope, sourcePosition, buffer, readString);
+        node.attributes = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+        const declarationPosition = buffer[position + 2];
+        node.declaration =
+            declarationPosition === 0
+                ? null
+                : convertNode(node, scope, declarationPosition, buffer, readString);
+        node.specifiers = convertNodeList(node, scope, position + 3, buffer, readString);
+    },
+    function exportSpecifier(node, position, buffer, readString) {
+        const { scope } = node;
+        const exportedPosition = buffer[position];
+        node.local = convertNode(node, scope, position + 1, buffer, readString);
+        node.exported =
+            exportedPosition === 0
+                ? node.local
+                : convertNode(node, scope, exportedPosition, buffer, readString);
+    },
+    function expressionStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, position, buffer, readString);
+    },
+    function forInStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.right = convertNode(node, scope, buffer[position], buffer, readString);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.left = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function forOfStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.await = (flags & 1) === 1;
+        node.right = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.body = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.left = convertNode(node, scope, position + 3, buffer, readString);
+    },
+    function forStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        const initPosition = buffer[position];
+        node.init =
+            initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer, readString);
+        const testPosition = buffer[position + 1];
+        node.test =
+            testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer, readString);
+        const updatePosition = buffer[position + 2];
+        node.update =
+            updatePosition === 0 ? null : convertNode(node, scope, updatePosition, buffer, readString);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer, readString);
+    },
+    function functionDeclaration(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.generator = (flags & 2) === 2;
+        const idPosition = buffer[position + 1];
+        node.id =
+            idPosition === 0
+                ? null
+                : convertNode(node, scope.parent, idPosition, buffer, readString);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer, readString));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 3], buffer, readString);
+        const annotations = (node.annotations = convertAnnotations(position + 4, buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+    },
+    function functionExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.generator = (flags & 2) === 2;
+        const idPosition = buffer[position + 1];
+        node.id =
+            idPosition === 0 ? null : convertNode(node, node.idScope, idPosition, buffer, readString);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer, readString));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 3], buffer, readString);
+        const annotations = (node.annotations = convertAnnotations(position + 4, buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+    },
+    function identifier(node, position, buffer, readString) {
+        node.name = convertString(position, buffer, readString);
+    },
+    function ifStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.consequent = convertNode(node, (node.consequentScope = new TrackingScope(scope)), buffer[position], buffer, readString);
+        const alternatePosition = buffer[position + 1];
+        node.alternate =
+            alternatePosition === 0
+                ? null
+                : convertNode(node, (node.alternateScope = new TrackingScope(scope)), alternatePosition, buffer, readString);
+        node.test = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function importAttribute(node, position, buffer, readString) {
+        const { scope } = node;
+        node.value = convertNode(node, scope, buffer[position], buffer, readString);
+        node.key = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function importDeclaration(node, position, buffer, readString) {
+        const { scope } = node;
+        node.source = convertNode(node, scope, buffer[position], buffer, readString);
+        node.attributes = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+        node.specifiers = convertNodeList(node, scope, position + 2, buffer, readString);
+    },
+    function importDefaultSpecifier(node, position, buffer, readString) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, position, buffer, readString);
+    },
+    function importExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const optionsPosition = buffer[position];
+        node.options =
+            optionsPosition === 0 ? null : convertNode(node, scope, optionsPosition, buffer, readString);
+        node.source = convertNode(node, scope, position + 1, buffer, readString);
+        node.sourceAstNode = convertNode$1(position + 1, buffer, readString);
+    },
+    function importNamespaceSpecifier(node, position, buffer, readString) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, position, buffer, readString);
+    },
+    function importSpecifier(node, position, buffer, readString) {
+        const { scope } = node;
+        const importedPosition = buffer[position];
+        node.local = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.imported =
+            importedPosition === 0
+                ? node.local
+                : convertNode(node, scope, importedPosition, buffer, readString);
+    },
+    function labeledStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.body = convertNode(node, scope, buffer[position], buffer, readString);
+        node.label = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function literalBigInt(node, position, buffer, readString) {
+        node.raw = convertString(buffer[position], buffer, readString);
+        const bigint = (node.bigint = convertString(position + 1, buffer, readString));
+        node.value = BigInt(bigint);
+    },
+    function literalBoolean(node, position, buffer) {
+        const flags = buffer[position];
+        const value = (node.value = (flags & 1) === 1);
+        node.raw = value ? 'true' : 'false';
+    },
+    function literalNull(node) {
+        node.value = null;
+    },
+    function literalNumber(node, position, buffer, readString) {
+        const rawPosition = buffer[position];
+        node.raw = rawPosition === 0 ? undefined : convertString(rawPosition, buffer, readString);
+        node.value = new DataView(buffer.buffer).getFloat64((position + 1) << 2, true);
+    },
+    function literalRegExp(node, position, buffer, readString) {
+        const pattern = convertString(buffer[position], buffer, readString);
+        const flags = convertString(position + 1, buffer, readString);
+        node.raw = `/${pattern}/${flags}`;
+        node.regex = { flags, pattern };
+        node.value = new RegExp(pattern, flags);
+    },
+    function literalString(node, position, buffer, readString) {
+        const rawPosition = buffer[position];
+        node.raw = rawPosition === 0 ? undefined : convertString(rawPosition, buffer, readString);
+        node.value = convertString(position + 1, buffer, readString);
+    },
+    function logicalExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.right = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.left = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function memberExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.computed = (flags & 1) === 1;
+        node.optional = (flags & 2) === 2;
+        node.property = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.object = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function metaProperty(node, position, buffer, readString) {
+        const { scope } = node;
+        node.property = convertNode(node, scope, buffer[position], buffer, readString);
+        node.meta = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function methodDefinition(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.static = (flags & 1) === 1;
+        node.computed = (flags & 2) === 2;
+        node.value = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.kind = FIXED_STRINGS[buffer[position + 2]];
+        node.key = convertNode(node, scope, position + 3, buffer, readString);
+    },
+    function newExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.callee = convertNode(node, scope, buffer[position], buffer, readString);
+        node.arguments = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+        node.annotations = convertAnnotations(position + 2, buffer);
+    },
+    function objectExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.properties = convertNodeList(node, scope, position, buffer, readString);
+    },
+    function objectPattern(node, position, buffer, readString) {
+        const { scope } = node;
+        node.properties = convertNodeList(node, scope, position, buffer, readString);
+    },
+    function privateIdentifier(node, position, buffer, readString) {
+        node.name = convertString(position, buffer, readString);
+    },
+    function program(node, position, buffer, readString) {
+        const { scope } = node;
+        node.invalidAnnotations = convertAnnotations(buffer[position], buffer);
+        node.body = convertNodeList(node, scope, position + 1, buffer, readString);
+    },
+    function property(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.method = (flags & 1) === 1;
+        node.shorthand = (flags & 2) === 2;
+        node.computed = (flags & 4) === 4;
+        const keyPosition = buffer[position + 1];
+        node.value = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.kind = FIXED_STRINGS[buffer[position + 3]];
+        node.key =
+            keyPosition === 0 ? node.value : convertNode(node, scope, keyPosition, buffer, readString);
+    },
+    function propertyDefinition(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.static = (flags & 1) === 1;
+        node.computed = (flags & 2) === 2;
+        const valuePosition = buffer[position + 1];
+        node.value =
+            valuePosition === 0 ? null : convertNode(node, scope, valuePosition, buffer, readString);
+        node.key = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function restElement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, position, buffer, readString);
+    },
+    function returnStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        const argumentPosition = buffer[position];
+        node.argument =
+            argumentPosition === 0
+                ? null
+                : convertNode(node, scope, argumentPosition, buffer, readString);
+    },
+    function sequenceExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.expressions = convertNodeList(node, scope, position, buffer, readString);
+    },
+    function spreadElement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, position, buffer, readString);
+    },
+    function staticBlock(node, position, buffer, readString) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, position, buffer, readString);
+    },
+    function superElement() { },
+    function switchCase(node, position, buffer, readString) {
+        const { scope } = node;
+        const testPosition = buffer[position];
+        node.test =
+            testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer, readString);
+        node.consequent = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+    },
+    function switchStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.cases = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.discriminant = convertNode(node, node.parentScope, position + 1, buffer, readString);
+    },
+    function taggedTemplateExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.quasi = convertNode(node, scope, buffer[position], buffer, readString);
+        node.tag = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function templateElement(node, position, buffer, readString) {
+        const flags = buffer[position];
+        node.tail = (flags & 1) === 1;
+        const cookedPosition = buffer[position + 1];
+        const cooked = cookedPosition === 0 ? undefined : convertString(cookedPosition, buffer, readString);
+        const raw = convertString(position + 2, buffer, readString);
+        node.value = { cooked, raw };
+    },
+    function templateLiteral(node, position, buffer, readString) {
+        const { scope } = node;
+        node.expressions = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.quasis = convertNodeList(node, scope, position + 1, buffer, readString);
+    },
+    function thisExpression() { },
+    function throwStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, position, buffer, readString);
+    },
+    function tryStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        const handlerPosition = buffer[position];
+        node.handler =
+            handlerPosition === 0 ? null : convertNode(node, scope, handlerPosition, buffer, readString);
+        const finalizerPosition = buffer[position + 1];
+        node.finalizer =
+            finalizerPosition === 0
+                ? null
+                : convertNode(node, scope, finalizerPosition, buffer, readString);
+        node.block = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function unaryExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.argument = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function updateExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.prefix = (flags & 1) === 1;
+        node.operator = FIXED_STRINGS[buffer[position + 1]];
+        node.argument = convertNode(node, scope, position + 2, buffer, readString);
+    },
+    function variableDeclaration(node, position, buffer, readString) {
+        const { scope } = node;
+        node.kind = FIXED_STRINGS[buffer[position]];
+        node.declarations = convertNodeList(node, scope, position + 1, buffer, readString);
+    },
+    function variableDeclarator(node, position, buffer, readString) {
+        const { scope } = node;
+        const initPosition = buffer[position];
+        node.init =
+            initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer, readString);
+        node.id = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function whileStatement(node, position, buffer, readString) {
+        const { scope } = node;
+        node.body = convertNode(node, scope, buffer[position], buffer, readString);
+        node.test = convertNode(node, scope, position + 1, buffer, readString);
+    },
+    function yieldExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.delegate = (flags & 1) === 1;
+        const argumentPosition = buffer[position + 1];
+        node.argument =
+            argumentPosition === 0
+                ? null
+                : convertNode(node, scope, argumentPosition, buffer, readString);
+    }
+];
+function convertNode(parent, parentScope, position, buffer, readString) {
+    const nodeType = buffer[position];
+    const NodeConstructor = nodeConstructors$1[nodeType];
+    /* istanbul ignore if: This should never be executed but is a safeguard against faulty buffers */
+    if (!NodeConstructor) {
+        console.trace();
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+    const node = new NodeConstructor(parent, parentScope);
+    node.type = nodeTypeStrings[nodeType];
+    node.start = buffer[position + 1];
+    node.end = buffer[position + 2];
+    bufferParsers[nodeType](node, position + 3, buffer, readString);
+    node.initialise();
+    return node;
+}
+function convertNodeList(parent, parentScope, position, buffer, readString) {
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        const nodePosition = buffer[position++];
+        list.push(nodePosition ? convertNode(parent, parentScope, nodePosition, buffer, readString) : null);
+    }
+    return list;
+}
+
+class UnknownNode extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+    include(context) {
+        super.include(context, true);
+    }
+}
+
 const nodeConstructors = {
     ArrayExpression,
     ArrayPattern,
@@ -12133,6 +12961,8 @@ const nodeConstructors = {
     NewExpression,
     ObjectExpression,
     ObjectPattern,
+    PanicError,
+    ParseError,
     PrivateIdentifier,
     Program,
     Property,
@@ -12487,7 +13317,9 @@ function getAttributesFromImportExpression(node) {
 }
 const getPropertyKey = (property) => {
     const key = property.key;
-    return (key && !property.computed && (key.name || key.value));
+    return (key &&
+        !property.computed &&
+        (key.name || key.value));
 };
 function getAttributesFromImportExportDeclaration(attributes) {
     return attributes?.length
@@ -13135,11 +13967,11 @@ class Module {
         return { source, usesTopLevelAwait };
     }
     async setSource({ ast, code, customTransformCache, originalCode, originalSourcemap, resolvedIds, sourcemapChain, transformDependencies, transformFiles, ...moduleOptions }) {
+        timeStart('generate ast', 3);
         if (code.startsWith('#!')) {
             const shebangEndPosition = code.indexOf('\n');
             this.shebang = code.slice(2, shebangEndPosition);
         }
-        timeStart('generate ast', 3);
         this.info.code = code;
         this.originalCode = originalCode;
         // We need to call decodedSourcemap on the input in case they were hydrated from json in the cache and don't
@@ -13155,9 +13987,6 @@ class Module {
         this.transformDependencies = transformDependencies;
         this.customTransformCache = customTransformCache;
         this.updateOptions(moduleOptions);
-        const moduleAst = ast ?? (await this.tryParseAsync());
-        timeEnd('generate ast', 3);
-        timeStart('analyze ast', 3);
         this.resolvedIds = resolvedIds ?? Object.create(null);
         // By default, `id` is the file name. Custom resolvers and loaders
         // can change that, but it makes sense to use it for the source file name
@@ -13197,13 +14026,17 @@ class Module {
         };
         this.scope = new ModuleScope(this.graph.scope, this.astContext);
         this.namespace = new NamespaceVariable(this.astContext);
-        this.ast = new Program(moduleAst, { context: this.astContext, type: 'Module' }, this.scope);
-        // Assign AST directly if has existing one as there's no way to drop it from memory.
-        // If cache is enabled, also assign directly as otherwise it takes more CPU and memory to re-compute.
-        if (ast || this.options.cache !== false) {
-            this.info.ast = moduleAst;
+        const programParent = { context: this.astContext, type: 'Module' };
+        if (ast) {
+            this.ast = new nodeConstructors[ast.type](programParent, this.scope).parseNode(ast);
+            this.info.ast = ast;
         }
         else {
+            // Measuring asynchronous code does not provide reasonable results
+            timeEnd('generate ast', 3);
+            const astBuffer = await parseAsync(code, false);
+            timeStart('generate ast', 3);
+            this.ast = convertProgram(astBuffer, programParent, this.scope);
             // Make lazy and apply LRU cache to not hog the memory
             Object.defineProperty(this.info, 'ast', {
                 get: () => {
@@ -13212,13 +14045,23 @@ class Module {
                     }
                     else {
                         const parsedAst = this.tryParse();
+                        // If the cache is not disabled, we need to keep the AST in memory
+                        // until the end when the cache is generated
+                        if (this.options.cache !== false) {
+                            Object.defineProperty(this.info, 'ast', {
+                                value: parsedAst
+                            });
+                            return parsedAst;
+                        }
+                        // Otherwise, we keep it in a small LRU cache to not hog too much
+                        // memory but allow the same AST to be requested several times.
                         this.graph.astLru.set(fileName, parsedAst);
                         return parsedAst;
                     }
                 }
             });
         }
-        timeEnd('analyze ast', 3);
+        timeEnd('generate ast', 3);
     }
     toJSON() {
         return {
@@ -13271,13 +14114,15 @@ class Module {
         }
     }
     addDynamicImport(node) {
-        let argument = node.source;
-        if (argument instanceof TemplateLiteral) {
-            if (argument.quasis.length === 1 && argument.quasis[0].value.cooked) {
+        let argument = node.sourceAstNode;
+        if (argument.type === TemplateLiteral$1) {
+            if (argument.quasis.length === 1 &&
+                typeof argument.quasis[0].value.cooked === 'string') {
                 argument = argument.quasis[0].value.cooked;
             }
         }
-        else if (argument instanceof Literal && typeof argument.value === 'string') {
+        else if (argument.type === Literal$1 &&
+            typeof argument.value === 'string') {
             argument = argument.value;
         }
         this.dynamicImports.push({ argument, id: null, node, resolution: null });
@@ -13572,14 +14417,6 @@ class Module {
             return this.error(logModuleParseError(error_, this.id), error_.pos);
         }
     }
-    async tryParseAsync() {
-        try {
-            return await parseAstAsync(this.info.code);
-        }
-        catch (error_) {
-            return this.error(logModuleParseError(error_, this.id), error_.pos);
-        }
-    }
 }
 // if there is a cyclic import in the reexport chain, we should not
 // import from the original module but from the cyclic module to not
@@ -15921,13 +16758,10 @@ function* concatLazy(iterables) {
  *
  * One non-trivial optimization we can apply is that dynamic entries are
  * different from static entries in so far as when a dynamic import occurs,
- * some
- * modules are already in memory. If some of these modules are also
- * dependencies
- * of the dynamic entry, then it does not make sense to create a separate chunk
- * for them. Instead, the dynamic import target can load them from the
- * importing
- * chunk.
+ * some modules are already in memory. If some of these modules are also
+ * dependencies of the dynamic entry, then it does not make sense to create a
+ * separate chunk for them. Instead, the dynamic import target can load them
+ * from the importing chunk.
  *
  * With regard to chunking, if B is implicitly loaded after A, then this can be
  * handled the same way as if there was a dynamic import A => B.
@@ -15936,8 +16770,7 @@ function* concatLazy(iterables) {
  * Assume A -> B (A imports B), A => C (A dynamically imports C) and C -> B.
  * Then the initial algorithm would assign A into the A chunk, C into the C
  * chunk and B into the AC chunk, i.e. the chunk with the dependent entry
- * points
- * A and C.
+ * points A and C.
  * However we know that C can only be loaded from A, so A and its dependency B
  * must already be in memory when C is loaded. So it is enough to create only
  * two chunks A containing [AB] and C containing [C].
@@ -15952,15 +16785,13 @@ function* concatLazy(iterables) {
  * A => D,
  * D -> B, D -> C
  * So without dynamic import optimization, the dependent entry points are
- * A: XY, B: DXY, C: DX, D: D, X: X, Y: Y,
- * so we would for now create six chunks.
+ * A: XY, B: DXY, C: DX, D: D, X: X, Y: Y, so we would for now create six
+ * chunks.
  *
  * Now D is loaded only after A is loaded. But A is loaded if either X is
- * loaded
- * or Y is loaded. So the modules that are already in memory when D is loaded
- * are the intersection of all modules that X depends on with all modules that
- * Y
- * depends on, which in this case are the modules A and B.
+ * loaded or Y is loaded. So the modules that are already in memory when D is
+ * loaded are the intersection of all modules that X depends on with all
+ * modules that Y depends on, which in this case are the modules A and B.
  * We could also say they are all modules that have both X and Y as dependent
  * entry points.
  *
@@ -15969,8 +16800,7 @@ function* concatLazy(iterables) {
  * same chunk.
  *
  * Now let us extend this to the most general case where we have several
- * dynamic
- * importers for one dynamic entry point.
+ * dynamic importers for one dynamic entry point.
  *
  * In the most general form, it works like this:
  * For each dynamic entry point, we have a number of dynamic importers, which
@@ -15983,9 +16813,8 @@ function* concatLazy(iterables) {
  * each dynamic importer.
  *
  * Assuming that A => D and B => D and A has dependent entry points XY and B
- * has
- * dependent entry points YZ, then the modules guaranteed to be in memory are
- * all modules that have at least XYZ as dependent entry points.
+ * has dependent entry points YZ, then the modules guaranteed to be in memory
+ * are all modules that have at least XYZ as dependent entry points.
  * We call XYZ the *dynamically dependent entry points* of D.
  *
  * Now there is one last case to consider: If one of the dynamically dependent
@@ -16012,7 +16841,7 @@ function* concatLazy(iterables) {
  *
  * For efficient operations, we assign each entry a numerical index and
  * represent Sets of Chunks as BigInt values where each chunk corresponds to a
- * bit index. Then thw last two maps can be represented as arrays of BigInt
+ * bit index. Then the last two maps can be represented as arrays of BigInt
  * values.
  *
  * Then we iterate through each dynamic entry. We set the already loaded modules
@@ -17831,7 +18660,6 @@ class ModuleLoader {
                 ? source
                 : error(logBadLoader(id));
         const code = sourceDescription.code;
-        /* eslint-disable-next-line unicorn/number-literal-case */
         if (code.charCodeAt(0) === 65279) {
             sourceDescription.code = code.slice(1);
         }
@@ -18015,9 +18843,7 @@ class ModuleLoader {
     }
     getResolveDynamicImportPromises(module) {
         return module.dynamicImports.map(async (dynamicImport) => {
-            const resolvedId = await this.resolveDynamicImport(module, typeof dynamicImport.argument === 'string'
-                ? dynamicImport.argument
-                : dynamicImport.argument.esTreeNode, module.id, getAttributesFromImportExpression(dynamicImport.node));
+            const resolvedId = await this.resolveDynamicImport(module, dynamicImport.argument, module.id, getAttributesFromImportExpression(dynamicImport.node));
             if (resolvedId && typeof resolvedId === 'object') {
                 dynamicImport.id = resolvedId.id;
             }