@rollup/wasm-node 4.11.0 → 4.12.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @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
 
@@ -14,8 +14,8 @@ const process$1 = require('node:process');
 const tty = require('tty');
 const node_path = require('node:path');
 const require$$0$1 = require('path');
-const node_perf_hooks = require('node:perf_hooks');
 const native_js = require('../native.js');
+const node_perf_hooks = require('node:perf_hooks');
 const promises = require('node:fs/promises');
 
 function _interopNamespaceDefault(e) {
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.11.0";
+var version = "4.12.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -6069,13 +6069,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 {
@@ -6091,22 +6161,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) { }
     /**
@@ -6114,7 +6173,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) {
@@ -6136,7 +6195,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;
@@ -6159,7 +6218,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;
@@ -6180,8 +6239,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
@@ -6191,20 +6253,10 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (key.charCodeAt(0) === 95 /* _ */) {
                 if (key === parseAst_js.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 === parseAst_js.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(parseAst_js.LOGLEVEL_WARN, parseAst_js.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) {
@@ -6215,13 +6267,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) {
@@ -6231,7 +6287,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;
@@ -6258,7 +6314,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;
@@ -6274,6 +6330,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) {
@@ -7026,16 +7085,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);
@@ -7141,7 +7190,7 @@ class LocalVariable extends Variable {
                     // We do not want to properly include parents in case they are part of a dead branch
                     // in which case .include() might pull in more dead code
                     node.included = true;
-                    if (node.type === Program$1)
+                    if (node.type === parseAst_js.Program)
                         break;
                     node = node.parent;
                 }
@@ -7180,7 +7229,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();
@@ -7305,7 +7354,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;
             }
@@ -7416,14 +7465,14 @@ 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) {
+                    existingVariable.declarations[0].parent.type === parseAst_js.CatchClause) {
                     // If this is a var with the same name as the catch scope parameter,
                     // the assignment actually goes to the parameter and the var is
                     // hoisted without assignment. Locally, it is shadowed by the
@@ -7440,7 +7489,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;
                 }
@@ -7470,10 +7519,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;
             }
@@ -8692,7 +8739,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.
@@ -8700,18 +8747,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;
             }
@@ -8744,7 +8791,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
@@ -8831,7 +8878,7 @@ class Identifier extends NodeBase {
             }
             // In strict mode, any variable named "eval" must be the actual "eval" function
             if (name === 'eval' &&
-                renderedParentType === CallExpression$1 &&
+                renderedParentType === parseAst_js.CallExpression &&
                 isCalleeOfRenderedParent) {
                 code.appendRight(this.start, '0, ');
             }
@@ -9019,12 +9066,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;
                 }
@@ -9044,9 +9091,10 @@ class BlockScope extends ChildScope {
 
 class ExpressionStatement extends NodeBase {
     initialise() {
+        super.initialise();
         if (this.directive &&
             this.directive !== 'use strict' &&
-            this.parent.type === Program$1) {
+            this.parent.type === parseAst_js.Program) {
             this.scope.context.log(parseAst_js.LOGLEVEL_WARN, 
             // This is necessary, because either way (deleting or not) can lead to errors.
             parseAst_js.logModuleLevelDirective(this.directive, this.scope.context.module.id), this.start);
@@ -9063,7 +9111,7 @@ class ExpressionStatement extends NodeBase {
     }
     shouldBeIncluded(context) {
         if (this.directive && this.directive !== 'use strict')
-            return this.parent.type !== Program$1;
+            return this.parent.type !== parseAst_js.Program;
         return super.shouldBeIncluded(context);
     }
     applyDeoptimizations() { }
@@ -9084,7 +9132,7 @@ class BlockStatement extends NodeBase {
     }
     addImplicitReturnExpressionToScope() {
         const lastStatement = this.body[this.body.length - 1];
-        if (!lastStatement || lastStatement.type !== ReturnStatement$1) {
+        if (!lastStatement || lastStatement.type !== parseAst_js.ReturnStatement) {
             this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
         }
     }
@@ -9117,6 +9165,7 @@ class BlockStatement extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         const firstBodyStatement = this.body[0];
         this.deoptimizeBody =
             firstBodyStatement instanceof ExpressionStatement &&
@@ -9180,6 +9229,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;
@@ -9276,12 +9331,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;
@@ -9292,11 +9352,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() { }
@@ -9308,6 +9368,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);
     }
@@ -9401,7 +9467,7 @@ function renderSystemExportSequenceBeforeExpression(exportedVariable, expression
 class ObjectPattern extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         for (const property of this.properties) {
-            if (property.type === Property$1) {
+            if (property.type === parseAst_js.Property) {
                 property.value.addExportedVariables(variables, exportNamesByVariable);
             }
             else {
@@ -9466,6 +9532,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') {
@@ -9500,7 +9567,7 @@ class AssignmentExpression extends NodeBase {
                         renderSystemExportExpression(variable, start, end, code, options);
                     }
                     else {
-                        renderSystemExportSequenceAfterExpression(variable, start, end, parent.type !== ExpressionStatement$1, code, options);
+                        renderSystemExportSequenceAfterExpression(variable, start, end, parent.type !== parseAst_js.ExpressionStatement, code, options);
                     }
                     return;
                 }
@@ -9509,15 +9576,15 @@ class AssignmentExpression extends NodeBase {
                 const systemPatternExports = [];
                 left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
                 if (systemPatternExports.length > 0) {
-                    renderSystemExportFunction(systemPatternExports, start, end, renderedSurroundingElement === ExpressionStatement$1, code, options);
+                    renderSystemExportFunction(systemPatternExports, start, end, renderedSurroundingElement === parseAst_js.ExpressionStatement, code, options);
                     return;
                 }
             }
         }
         if (left.included &&
             left instanceof ObjectPattern &&
-            (renderedSurroundingElement === ExpressionStatement$1 ||
-                renderedSurroundingElement === ArrowFunctionExpression$1)) {
+            (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
+                renderedSurroundingElement === parseAst_js.ArrowFunctionExpression)) {
             code.appendRight(start, '(');
             code.prependLeft(end, ')');
         }
@@ -9560,7 +9627,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) {
@@ -9683,7 +9750,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);
@@ -9880,12 +9947,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') {
@@ -10103,6 +10171,7 @@ class MemberExpression extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         this.propertyKey = getResolvablePropertyKey(this);
         this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
     }
@@ -10382,6 +10451,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 &&
@@ -10416,11 +10492,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;
@@ -10447,7 +10523,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));
     }
@@ -10470,9 +10546,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() { }
 }
@@ -10631,7 +10707,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;
@@ -10701,9 +10778,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;
@@ -10743,7 +10820,7 @@ class ClassDeclaration extends ClassNode {
 class ClassExpression extends ClassNode {
     render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
-        if (renderedSurroundingElement === ExpressionStatement$1) {
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
@@ -10943,6 +11020,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;
@@ -10993,6 +11076,7 @@ class ExportAllDeclaration extends NodeBase {
         return false;
     }
     initialise() {
+        super.initialise();
         this.scope.context.addExport(this);
     }
     render(code, _options, nodeRenderOptions) {
@@ -11011,9 +11095,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);
     }
 }
 
@@ -11038,6 +11122,7 @@ class ExportDefaultDeclaration extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         const declaration = this.declaration;
         this.declarationName =
             (declaration.id && declaration.id.name) || this.declaration.name;
@@ -11071,7 +11156,7 @@ class ExportDefaultDeclaration extends NodeBase {
         else {
             code.remove(this.start, declarationStart);
             this.declaration.render(code, options, {
-                renderedSurroundingElement: ExpressionStatement$1
+                renderedSurroundingElement: parseAst_js.ExpressionStatement
             });
             if (code.original[this.end - 1] !== ';') {
                 code.appendLeft(this.end, ';');
@@ -11121,6 +11206,7 @@ class ExportNamedDeclaration extends NodeBase {
         return !!this.declaration?.hasEffects(context);
     }
     initialise() {
+        super.initialise();
         this.scope.context.addExport(this);
     }
     removeAnnotations(code) {
@@ -11166,6 +11252,7 @@ class ForInStatement extends NodeBase {
         includeLoopBody(context, body, includeChildrenRecursively);
     }
     initialise() {
+        super.initialise();
         this.left.setAssignedValue(UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -11210,6 +11297,7 @@ class ForOfStatement extends NodeBase {
         includeLoopBody(context, body, includeChildrenRecursively);
     }
     initialise() {
+        super.initialise();
         this.left.setAssignedValue(UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -11262,13 +11350,13 @@ 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);
-        if (renderedSurroundingElement === ExpressionStatement$1) {
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
@@ -11331,13 +11419,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;
@@ -11431,7 +11517,7 @@ class IfStatement extends NodeBase {
             .join(', ');
         if (hoistedVariables) {
             const parentType = this.parent.type;
-            const needsBraces = parentType !== Program$1 && parentType !== BlockStatement$1;
+            const needsBraces = parentType !== parseAst_js.Program && parentType !== parseAst_js.BlockStatement;
             code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVariables}; `);
             if (needsBraces) {
                 code.appendLeft(this.end, ` }`);
@@ -11463,6 +11549,7 @@ class ImportDeclaration extends NodeBase {
         return false;
     }
     initialise() {
+        super.initialise();
         this.scope.context.addImport(this);
     }
     render(code, _options, nodeRenderOptions) {
@@ -11733,7 +11820,7 @@ class VariableDeclarator extends NodeBase {
                     code.appendLeft(init.start + 5, ` ${id.name}`);
                 }
             }
-            init.render(code, options, renderId ? BLANK : { renderedSurroundingElement: ExpressionStatement$1 });
+            init.render(code, options, renderId ? BLANK : { renderedSurroundingElement: parseAst_js.ExpressionStatement });
         }
         else if (id instanceof Identifier &&
             isReassignedExportsMember(id.variable, exportNamesByVariable)) {
@@ -11853,11 +11940,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;
@@ -12334,18 +12422,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 = {
@@ -12390,11 +12478,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);
@@ -12432,8 +12525,8 @@ class ObjectExpression extends NodeBase {
     }
     render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
-        if (renderedSurroundingElement === ExpressionStatement$1 ||
-            renderedSurroundingElement === ArrowFunctionExpression$1) {
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
+            renderedSurroundingElement === parseAst_js.ArrowFunctionExpression) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
@@ -12480,6 +12573,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 = parseAst_js.getRollupError(parseAst_js.logParseError(this.message));
+        const moduleParseError = parseAst_js.logModuleParseError(parseError, id);
+        return parseAst_js.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 = parseAst_js.getRollupError(parseAst_js.logParseError(this.message, pos));
+        const moduleParseError = parseAst_js.logModuleParseError(parseError, id);
+        this.scope.context.error(moduleParseError, pos);
+    }
+}
+
 class PrivateIdentifier extends NodeBase {
 }
 
@@ -12518,6 +12634,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(parseAst_js.LOGLEVEL_WARN, parseAst_js.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('#!')) {
@@ -12636,6 +12762,7 @@ class ReturnStatement extends NodeBase {
         context.brokenFlow = true;
     }
     initialise() {
+        super.initialise();
         this.scope.addReturnExpression(this.argument || UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -12857,6 +12984,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;
@@ -12866,8 +12994,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);
@@ -12880,7 +13008,7 @@ class SwitchStatement extends NodeBase {
 class TaggedTemplateExpression extends CallExpressionBase {
     bind() {
         super.bind();
-        if (this.tag.type === Identifier$1) {
+        if (this.tag.type === parseAst_js.Identifier) {
             const name = this.tag.name;
             const variable = this.scope.findVariable(name);
             if (variable.isNamespace) {
@@ -12920,6 +13048,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
         }
     }
     initialise() {
+        super.initialise();
         this.args = [UNKNOWN_EXPRESSION, ...this.quasi.expressions];
         this.interaction = {
             args: [
@@ -12965,7 +13094,7 @@ class TemplateElement extends NodeBase {
     }
     parseNode(esTreeNode) {
         this.value = esTreeNode.value;
-        super.parseNode(esTreeNode);
+        return super.parseNode(esTreeNode);
     }
     render() { }
 }
@@ -13010,7 +13139,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;
@@ -13081,7 +13210,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)) {
@@ -13139,6 +13268,7 @@ class ThisExpression extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         this.alias =
             this.scope.findLexicalBoundary() instanceof ModuleScope
                 ? this.scope.context.moduleContext
@@ -13255,15 +13385,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)
@@ -13280,6 +13401,7 @@ class UpdateExpression extends NodeBase {
         this.argument.includeAsAssignmentTarget(context, includeChildrenRecursively, true);
     }
     initialise() {
+        super.initialise();
         this.argument.setAssignedValue(UNKNOWN_EXPRESSION);
     }
     render(code, options) {
@@ -13294,12 +13416,12 @@ class UpdateExpression extends NodeBase {
                         renderSystemExportExpression(variable, this.start, this.end, code, options);
                     }
                     else {
-                        renderSystemExportSequenceAfterExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options);
+                        renderSystemExportSequenceAfterExpression(variable, this.start, this.end, this.parent.type !== parseAst_js.ExpressionStatement, code, options);
                     }
                 }
                 else {
                     const operator = this.operator[0];
-                    renderSystemExportSequenceBeforeExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options, `${_}${operator}${_}1`);
+                    renderSystemExportSequenceBeforeExpression(variable, this.start, this.end, this.parent.type !== parseAst_js.ExpressionStatement, code, options, `${_}${operator}${_}1`);
                 }
             }
         }
@@ -13319,7 +13441,7 @@ function areAllDeclarationsIncludedAndNotExported(declarations, exportNamesByVar
     for (const declarator of declarations) {
         if (!declarator.id.included)
             return false;
-        if (declarator.id.type === Identifier$1) {
+        if (declarator.id.type === parseAst_js.Identifier) {
             if (exportNamesByVariable.has(declarator.id.variable))
                 return false;
         }
@@ -13359,6 +13481,7 @@ class VariableDeclaration extends NodeBase {
         }
     }
     initialise() {
+        super.initialise();
         for (const declarator of this.declarations) {
             declarator.declareDeclarator(this.kind);
         }
@@ -13524,6 +13647,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), parseAst_js.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 = parseAst_js.convertString(position, buffer, readString);
+    },
+    function parseError(node, position, buffer, readString) {
+        node.message = parseAst_js.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 = parseAst_js.convertAnnotations(position + 3, buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+    },
+    function assignmentExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.operator = parseAst_js.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 = parseAst_js.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 = parseAst_js.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 = parseAst_js.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 = parseAst_js.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 = parseAst_js.convertAnnotations(position + 4, buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+    },
+    function identifier(node, position, buffer, readString) {
+        node.name = parseAst_js.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 = parseAst_js.convertNode(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 = parseAst_js.convertString(buffer[position], buffer, readString);
+        const bigint = (node.bigint = parseAst_js.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 : parseAst_js.convertString(rawPosition, buffer, readString);
+        node.value = new DataView(buffer.buffer).getFloat64((position + 1) << 2, true);
+    },
+    function literalRegExp(node, position, buffer, readString) {
+        const pattern = parseAst_js.convertString(buffer[position], buffer, readString);
+        const flags = parseAst_js.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 : parseAst_js.convertString(rawPosition, buffer, readString);
+        node.value = parseAst_js.convertString(position + 1, buffer, readString);
+    },
+    function logicalExpression(node, position, buffer, readString) {
+        const { scope } = node;
+        node.operator = parseAst_js.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 = parseAst_js.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 = parseAst_js.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 = parseAst_js.convertString(position, buffer, readString);
+    },
+    function program(node, position, buffer, readString) {
+        const { scope } = node;
+        node.invalidAnnotations = parseAst_js.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 = parseAst_js.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 : parseAst_js.convertString(cookedPosition, buffer, readString);
+        const raw = parseAst_js.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 = parseAst_js.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 = parseAst_js.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 = parseAst_js.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,
@@ -13571,6 +14399,8 @@ const nodeConstructors = {
     NewExpression,
     ObjectExpression,
     ObjectPattern,
+    PanicError,
+    ParseError,
     PrivateIdentifier,
     Program,
     Property,
@@ -13918,7 +14748,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
@@ -14566,11 +15398,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
@@ -14586,9 +15418,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
@@ -14628,13 +15457,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 native_js.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: () => {
@@ -14643,13 +15476,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 {
@@ -14702,13 +15545,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 === parseAst_js.TemplateLiteral) {
+            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 === parseAst_js.Literal &&
+            typeof argument.value === 'string') {
             argument = argument.value;
         }
         this.dynamicImports.push({ argument, id: null, node, resolution: null });
@@ -15003,14 +15848,6 @@ class Module {
             return this.error(parseAst_js.logModuleParseError(error_, this.id), error_.pos);
         }
     }
-    async tryParseAsync() {
-        try {
-            return await parseAst_js.parseAstAsync(this.info.code);
-        }
-        catch (error_) {
-            return this.error(parseAst_js.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
@@ -17247,13 +18084,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.
@@ -17262,8 +18096,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].
@@ -17278,15 +18111,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.
  *
@@ -17295,8 +18126,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
@@ -17309,9 +18139,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
@@ -17338,7 +18167,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
@@ -18907,7 +19736,6 @@ class ModuleLoader {
                 ? source
                 : parseAst_js.error(parseAst_js.logBadLoader(id));
         const code = sourceDescription.code;
-        /* eslint-disable-next-line unicorn/number-literal-case */
         if (code.charCodeAt(0) === 65279) {
             sourceDescription.code = code.slice(1);
         }
@@ -19091,9 +19919,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;
             }