@rollup/wasm-node 4.13.2 → 4.14.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.13.2
-	Thu, 28 Mar 2024 14:13:03 GMT - commit b379a592234416a2084918b0eea4c81865a1579f
+	Rollup.js v4.14.1
+	Sun, 07 Apr 2024 07:35:08 GMT - commit 0b665c31833525c923c0fc20f43ebfca748c6670
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.13.2";
+var version = "4.14.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -613,15 +613,6 @@ function getCacheForUncacheablePlugin(pluginName) {
     };
 }
 
-const BLANK = Object.freeze(Object.create(null));
-const EMPTY_OBJECT = Object.freeze({});
-const EMPTY_ARRAY = Object.freeze([]);
-const EMPTY_SET = Object.freeze(new (class extends Set {
-    add() {
-        throw new Error('Cannot add to empty set');
-    }
-})());
-
 const doNothing = () => { };
 
 async function asyncFlatten(array) {
@@ -693,7 +684,7 @@ const treeshakePresets = {
     recommended: {
         annotations: true,
         correctVarValueBeforeDeclaration: false,
-        manualPureFunctions: EMPTY_ARRAY,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
         moduleSideEffects: () => true,
         propertyReadSideEffects: true,
         tryCatchDeoptimization: true,
@@ -702,7 +693,7 @@ const treeshakePresets = {
     safest: {
         annotations: true,
         correctVarValueBeforeDeclaration: true,
-        manualPureFunctions: EMPTY_ARRAY,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
         moduleSideEffects: () => true,
         propertyReadSideEffects: true,
         tryCatchDeoptimization: true,
@@ -711,7 +702,7 @@ const treeshakePresets = {
     smallest: {
         annotations: true,
         correctVarValueBeforeDeclaration: false,
-        manualPureFunctions: EMPTY_ARRAY,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
         moduleSideEffects: () => false,
         propertyReadSideEffects: false,
         tryCatchDeoptimization: false,
@@ -825,9 +816,9 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
             watchMode: graph.watchMode
         },
         parse: parseAst_js.parseAst,
-        resolve(source, importer, { attributes, custom, isEntry, skipSelf } = BLANK) {
+        resolve(source, importer, { attributes, custom, isEntry, skipSelf } = parseAst_js.BLANK) {
             skipSelf ??= true;
-            return graph.moduleLoader.resolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, skipSelf ? [{ importer, plugin, source }] : null);
+            return graph.moduleLoader.resolveId(source, importer, custom, isEntry, attributes || parseAst_js.EMPTY_OBJECT, skipSelf ? [{ importer, plugin, source }] : null);
         },
         setAssetSource: fileEmitter.setAssetSource,
         warn: getLogHandler(parseAst_js.LOGLEVEL_WARN, 'PLUGIN_WARNING', onLog, plugin.name, logLevel)
@@ -1088,7 +1079,7 @@ function noReturn() { }
 function getLogger(plugins, onLog, watchMode, logLevel) {
     plugins = getSortedValidatedPlugins('onLog', plugins);
     const minimalPriority = parseAst_js.logLevelPriority[logLevel];
-    const logger = (level, log, skipped = EMPTY_SET) => {
+    const logger = (level, log, skipped = parseAst_js.EMPTY_SET) => {
         parseAst_js.augmentLogMessage(log);
         const logPriority = parseAst_js.logLevelPriority[level];
         if (logPriority < minimalPriority) {
@@ -1479,6 +1470,19 @@ function handleError(error, recover = false) {
     if (error.stack) {
         outputLines.push(dim(error.stack?.replace(`${nameSection}${error.message}\n`, '')));
     }
+    // ES2022: Error.prototype.cause is optional
+    if (error.cause) {
+        let cause = error.cause;
+        const causeErrorLines = [];
+        let indent = '';
+        while (cause) {
+            indent += '  ';
+            const message = cause.stack || cause;
+            causeErrorLines.push(...`[cause] ${message}`.split('\n').map(line => indent + line));
+            cause = cause.cause;
+        }
+        outputLines.push(dim(causeErrorLines.join('\n')));
+    }
     outputLines.push('', '');
     stderr(outputLines.join('\n'));
     if (!recover)
@@ -2816,21 +2820,29 @@ class MagicString {
 		if (searchValue.global) {
 			const matches = matchAll(searchValue, this.original);
 			matches.forEach((match) => {
-				if (match.index != null)
+				if (match.index != null) {
+					const replacement = getReplacement(match, this.original);
+					if (replacement !== match[0]) {
+						this.overwrite(
+							match.index,
+							match.index + match[0].length,
+							replacement
+						);
+					}
+				}
+			});
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) {
 					this.overwrite(
 						match.index,
 						match.index + match[0].length,
-						getReplacement(match, this.original),
+						replacement
 					);
-			});
-		} else {
-			const match = this.original.match(searchValue);
-			if (match && match.index != null)
-				this.overwrite(
-					match.index,
-					match.index + match[0].length,
-					getReplacement(match, this.original),
-				);
+				}
+			}
 		}
 		return this;
 	}
@@ -2862,7 +2874,9 @@ class MagicString {
 			index !== -1;
 			index = original.indexOf(string, index + stringLength)
 		) {
-			this.overwrite(index, index + stringLength, replacement);
+			const previous = original.slice(index, index + stringLength);
+			if (previous !== replacement)
+				this.overwrite(index, index + stringLength, replacement);
 		}
 
 		return this;
@@ -3588,8 +3602,8 @@ class ExternalModule {
             ast: null,
             attributes,
             code: null,
-            dynamicallyImportedIdResolutions: EMPTY_ARRAY,
-            dynamicallyImportedIds: EMPTY_ARRAY,
+            dynamicallyImportedIdResolutions: parseAst_js.EMPTY_ARRAY,
+            dynamicallyImportedIds: parseAst_js.EMPTY_ARRAY,
             get dynamicImporters() {
                 return dynamicImporters.sort();
             },
@@ -3597,10 +3611,10 @@ class ExternalModule {
             exports: null,
             hasDefaultExport: null,
             id,
-            implicitlyLoadedAfterOneOf: EMPTY_ARRAY,
-            implicitlyLoadedBefore: EMPTY_ARRAY,
-            importedIdResolutions: EMPTY_ARRAY,
-            importedIds: EMPTY_ARRAY,
+            implicitlyLoadedAfterOneOf: parseAst_js.EMPTY_ARRAY,
+            implicitlyLoadedBefore: parseAst_js.EMPTY_ARRAY,
+            importedIdResolutions: parseAst_js.EMPTY_ARRAY,
+            importedIds: parseAst_js.EMPTY_ARRAY,
             get importers() {
                 return importers.sort();
             },
@@ -7134,7 +7148,7 @@ class LocalVariable extends Variable {
         if (path.length === 0) {
             this.isReassigned = true;
             const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
-            this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
             for (const expression of expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
@@ -7233,7 +7247,7 @@ class LocalVariable extends Variable {
 }
 
 const MAX_TRACKED_INTERACTIONS = 20;
-const NO_INTERACTIONS = EMPTY_ARRAY;
+const NO_INTERACTIONS = parseAst_js.EMPTY_ARRAY;
 const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
 const EMPTY_PATH_TRACKER = new PathTracker();
 const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
@@ -8712,13 +8726,7 @@ class GlobalVariable extends Variable {
     }
 }
 
-const tdzVariableKinds = {
-    __proto__: null,
-    class: true,
-    const: true,
-    let: true,
-    var: true
-};
+const tdzVariableKinds = new Set(['class', 'const', 'let', 'var', 'using', 'await using']);
 class Identifier extends NodeBase {
     constructor() {
         super(...arguments);
@@ -8764,6 +8772,8 @@ class Identifier extends NodeBase {
             }
             case 'let':
             case 'const':
+            case 'using':
+            case 'await using':
             case 'class': {
                 variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
                 break;
@@ -8846,7 +8856,7 @@ class Identifier extends NodeBase {
             return cachedTdzAccess;
         if (!(this.variable instanceof LocalVariable &&
             this.variable.kind &&
-            this.variable.kind in tdzVariableKinds &&
+            tdzVariableKinds.has(this.variable.kind) &&
             // we ignore possible TDZs due to circular module dependencies as
             // otherwise we get many false positives
             this.variable.module === this.scope.context.module)) {
@@ -8874,7 +8884,7 @@ class Identifier extends NodeBase {
     markDeclarationReached() {
         this.variable.initReached = true;
     }
-    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = BLANK) {
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = parseAst_js.BLANK) {
         if (this.variable) {
             const name = this.variable.getName(getPropertyAccess, useOriginalName);
             if (name !== this.name) {
@@ -9355,15 +9365,12 @@ class FunctionBase extends NodeBase {
     }
     parseNode(esTreeNode) {
         const { body, params } = esTreeNode;
-        const parameters = (this.params = []);
         const { scope } = this;
         const { bodyScope, context } = scope;
         // We need to ensure that parameters are declared before the body is parsed
         // 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))(this, scope).parseNode(parameter));
-        }
+        const parameters = (this.params = params.map((parameter) => new (context.getNodeConstructor(parameter.type))(this, scope).parseNode(parameter)));
         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);
@@ -9551,7 +9558,7 @@ class AssignmentExpression extends NodeBase {
         }
         this.left.setAssignedValue(this.right);
     }
-    render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
+    render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
         const { left, right, start, end, parent } = this;
         if (left.included) {
             left.render(code, options);
@@ -9623,7 +9630,7 @@ class AssignmentPattern extends NodeBase {
     markDeclarationReached() {
         this.left.markDeclarationReached();
     }
-    render(code, options, { isShorthandProperty } = BLANK) {
+    render(code, options, { isShorthandProperty } = parseAst_js.BLANK) {
         this.left.render(code, options, { isShorthandProperty });
         this.right.render(code, options);
     }
@@ -9860,7 +9867,7 @@ class BinaryExpression extends NodeBase {
     removeAnnotations(code) {
         this.left.removeAnnotations(code);
     }
-    render(code, options, { renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
         this.left.render(code, options, { renderedSurroundingElement });
         this.right.render(code, options);
     }
@@ -10081,7 +10088,7 @@ class MemberExpression extends NodeBase {
     }
     deoptimizeCache() {
         const { expressionsToBeDeoptimized, object } = this;
-        this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+        this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
         this.propertyKey = UnknownKey;
         object.deoptimizePath(UNKNOWN_PATH);
         for (const expression of expressionsToBeDeoptimized) {
@@ -10192,7 +10199,7 @@ class MemberExpression extends NodeBase {
                 (this.optional &&
                     this.object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null)));
     }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = parseAst_js.BLANK) {
         if (this.variable || this.isUndefined) {
             const { snippets: { getPropertyAccess } } = options;
             let replacement = this.variable ? this.variable.getName(getPropertyAccess) : 'undefined';
@@ -10338,8 +10345,8 @@ class CallExpressionBase extends NodeBase {
         if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
             this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
             const { deoptimizableDependentExpressions, expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = EMPTY_SET;
-            this.deoptimizableDependentExpressions = EMPTY_ARRAY;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_SET;
+            this.deoptimizableDependentExpressions = parseAst_js.EMPTY_ARRAY;
             for (const expression of deoptimizableDependentExpressions) {
                 expression.deoptimizeCache();
             }
@@ -10473,7 +10480,7 @@ class CallExpression extends CallExpressionBase {
             (this.optional &&
                 this.callee.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null));
     }
-    render(code, options, { renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
         this.callee.render(code, options, {
             isCalleeOfRenderedParent: true,
             renderedSurroundingElement
@@ -10828,7 +10835,7 @@ class ClassDeclaration extends ClassNode {
 }
 
 class ClassExpression extends ClassNode {
-    render(code, options, { renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
         super.render(code, options);
         if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
             code.appendRight(this.start, '(');
@@ -10884,7 +10891,7 @@ class ConditionalExpression extends NodeBase {
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
             const { expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
             for (const expression of expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
@@ -10962,7 +10969,7 @@ class ConditionalExpression extends NodeBase {
     removeAnnotations(code) {
         this.test.removeAnnotations(code);
     }
-    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
         const usedBranch = this.getUsedBranch();
         if (this.test.included) {
             this.test.render(code, options, { renderedSurroundingElement });
@@ -11364,7 +11371,7 @@ class FunctionExpression extends FunctionNode {
         }
         return super.parseNode(esTreeNode);
     }
-    render(code, options, { renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
         super.render(code, options);
         if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
             code.appendRight(this.start, '(');
@@ -11785,7 +11792,8 @@ function isReassignedExportsMember(variable, exportNamesByVariable) {
 }
 
 class VariableDeclarator extends NodeBase {
-    declareDeclarator(kind) {
+    declareDeclarator(kind, isUsingDeclaration) {
+        this.isUsingDeclaration = isUsingDeclaration;
         this.id.declare(kind, this.init || UNDEFINED_EXPRESSION);
     }
     deoptimizePath(path) {
@@ -11796,7 +11804,7 @@ class VariableDeclarator extends NodeBase {
             this.applyDeoptimizations();
         const initEffect = this.init?.hasEffects(context);
         this.id.markDeclarationReached();
-        return initEffect || this.id.hasEffects(context);
+        return initEffect || this.id.hasEffects(context) || this.isUsingDeclaration;
     }
     include(context, includeChildrenRecursively) {
         const { deoptimized, id, init } = this;
@@ -11815,7 +11823,7 @@ class VariableDeclarator extends NodeBase {
     render(code, options) {
         const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
         const { end, id, init, start } = this;
-        const renderId = id.included;
+        const renderId = id.included || this.isUsingDeclaration;
         if (renderId) {
             id.render(code, options);
         }
@@ -11830,7 +11838,7 @@ class VariableDeclarator extends NodeBase {
                     code.appendLeft(init.start + 5, ` ${id.name}`);
                 }
             }
-            init.render(code, options, renderId ? BLANK : { renderedSurroundingElement: parseAst_js.ExpressionStatement });
+            init.render(code, options, renderId ? parseAst_js.BLANK : { renderedSurroundingElement: parseAst_js.ExpressionStatement });
         }
         else if (id instanceof Identifier &&
             isReassignedExportsMember(id.variable, exportNamesByVariable)) {
@@ -11879,13 +11887,13 @@ class ImportExpression extends NodeBase {
         const parent1 = this.parent;
         // Side-effect only: import('bar')
         if (parent1 instanceof ExpressionStatement) {
-            return EMPTY_ARRAY;
+            return parseAst_js.EMPTY_ARRAY;
         }
         if (parent1 instanceof AwaitExpression) {
             const parent2 = parent1.parent;
             // Side-effect only: await import('bar')
             if (parent2 instanceof ExpressionStatement) {
-                return EMPTY_ARRAY;
+                return parseAst_js.EMPTY_ARRAY;
             }
             // Case 1: const { foo } = await import('bar')
             if (parent2 instanceof VariableDeclarator) {
@@ -11914,13 +11922,13 @@ class ImportExpression extends NodeBase {
             // side-effect only, when only chaining .catch or .finally
             if (callExpression.parent instanceof ExpressionStatement &&
                 ['catch', 'finally'].includes(memberName)) {
-                return EMPTY_ARRAY;
+                return parseAst_js.EMPTY_ARRAY;
             }
             if (memberName !== 'then')
                 return;
             // Side-effect only: import('bar').then()
             if (callExpression.arguments.length === 0) {
-                return EMPTY_ARRAY;
+                return parseAst_js.EMPTY_ARRAY;
             }
             const argument = callExpression.arguments[0];
             if (callExpression.arguments.length !== 1 ||
@@ -11929,7 +11937,7 @@ class ImportExpression extends NodeBase {
             }
             // Side-effect only: import('bar').then(() => {})
             if (argument.params.length === 0) {
-                return EMPTY_ARRAY;
+                return parseAst_js.EMPTY_ARRAY;
             }
             const declaration = argument.params[0];
             if (argument.params.length === 1 && declaration instanceof ObjectPattern) {
@@ -12203,7 +12211,7 @@ class LogicalExpression extends NodeBase {
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
             const { scope: { context }, expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
             for (const expression of expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
@@ -12275,7 +12283,7 @@ class LogicalExpression extends NodeBase {
     removeAnnotations(code) {
         this.left.removeAnnotations(code);
     }
-    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
         if (!this.left.included || !this.right.included) {
             const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
             if (this.right.included) {
@@ -12533,7 +12541,7 @@ class ObjectExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    render(code, options, { renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
         super.render(code, options);
         if (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
             renderedSurroundingElement === parseAst_js.ArrowFunctionExpression) {
@@ -12818,7 +12826,7 @@ class SequenceExpression extends NodeBase {
     removeAnnotations(code) {
         this.expressions[0].removeAnnotations(code);
     }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = parseAst_js.BLANK) {
         let includedNodes = 0;
         let lastSeparatorPos = null;
         const lastNode = this.expressions[this.expressions.length - 1];
@@ -13473,7 +13481,7 @@ class VariableDeclaration extends NodeBase {
     hasEffectsOnInteractionAtPath() {
         return false;
     }
-    include(context, includeChildrenRecursively, { asSingleStatement } = BLANK) {
+    include(context, includeChildrenRecursively, { asSingleStatement } = parseAst_js.BLANK) {
         this.included = true;
         for (const declarator of this.declarations) {
             if (includeChildrenRecursively || declarator.shouldBeIncluded(context))
@@ -13492,15 +13500,17 @@ class VariableDeclaration extends NodeBase {
     }
     initialise() {
         super.initialise();
+        this.isUsingDeclaration = this.kind === 'await using' || this.kind === 'using';
         for (const declarator of this.declarations) {
-            declarator.declareDeclarator(this.kind);
+            declarator.declareDeclarator(this.kind, this.isUsingDeclaration);
         }
     }
     removeAnnotations(code) {
         this.declarations[0].removeAnnotations(code);
     }
-    render(code, options, nodeRenderOptions = BLANK) {
-        if (areAllDeclarationsIncludedAndNotExported(this.declarations, options.exportNamesByVariable)) {
+    render(code, options, nodeRenderOptions = parseAst_js.BLANK) {
+        if (this.isUsingDeclaration ||
+            areAllDeclarationsIncludedAndNotExported(this.declarations, options.exportNamesByVariable)) {
             for (const declarator of this.declarations) {
                 declarator.render(code, options);
             }
@@ -13826,18 +13836,18 @@ const nodeConstructors$1 = [
 ];
 const bufferParsers = [
     function panicError(node, position, buffer, readString) {
-        node.message = parseAst_js.convertString(position, buffer, readString);
+        node.message = parseAst_js.convertString(buffer[position], buffer, readString);
     },
     function parseError(node, position, buffer, readString) {
-        node.message = parseAst_js.convertString(position, buffer, readString);
+        node.message = parseAst_js.convertString(buffer[position], buffer, readString);
     },
     function arrayExpression(node, position, buffer, readString) {
         const { scope } = node;
-        node.elements = convertNodeList(node, scope, position, buffer, readString);
+        node.elements = convertNodeList(node, scope, buffer[position], buffer, readString);
     },
     function arrayPattern(node, position, buffer, readString) {
         const { scope } = node;
-        node.elements = convertNodeList(node, scope, position, buffer, readString);
+        node.elements = convertNodeList(node, scope, buffer[position], buffer, readString);
     },
     function arrowFunctionExpression(node, position, buffer, readString) {
         const { scope } = node;
@@ -13845,36 +13855,36 @@ const bufferParsers = [
         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));
+        const annotations = (node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer));
         node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        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);
     },
     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);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.right = convertNode(node, scope, buffer[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);
+        node.left = convertNode(node, scope, buffer[position], buffer, readString);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer, readString);
     },
     function awaitExpression(node, position, buffer, readString) {
         const { scope } = node;
-        node.argument = convertNode(node, scope, position, buffer, readString);
+        node.argument = convertNode(node, scope, buffer[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);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer, readString);
     },
     function blockStatement(node, position, buffer, readString) {
         const { scope } = node;
-        node.body = convertNodeList(node, scope, position, buffer, readString);
+        node.body = convertNodeList(node, scope, buffer[position], buffer, readString);
     },
     function breakStatement(node, position, buffer, readString) {
         const { scope } = node;
@@ -13886,9 +13896,9 @@ const bufferParsers = [
         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);
+        node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer);
+        node.callee = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.arguments = convertNodeList(node, scope, buffer[position + 3], buffer, readString);
     },
     function catchClause(node, position, buffer, readString) {
         const { scope } = node;
@@ -13902,15 +13912,18 @@ const bufferParsers = [
     },
     function chainExpression(node, position, buffer, readString) {
         const { scope } = node;
-        node.expression = convertNode(node, scope, position, buffer, readString);
+        node.expression = convertNode(node, scope, buffer[position], buffer, readString);
     },
     function classBody(node, position, buffer, readString) {
         const { scope } = node;
-        const length = buffer[position];
+        const bodyPosition = 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));
+        if (bodyPosition) {
+            const length = buffer[bodyPosition];
+            for (let index = 0; index < length; index++) {
+                const nodePosition = buffer[bodyPosition + 1 + index];
+                body.push(convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer, readString));
+            }
         }
     },
     function classDeclaration(node, position, buffer, readString) {
@@ -13940,9 +13953,9 @@ const bufferParsers = [
     },
     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);
+        node.test = convertNode(node, scope, buffer[position], buffer, readString);
+        node.consequent = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.alternate = convertNode(node, scope, buffer[position + 2], buffer, readString);
     },
     function continueStatement(node, position, buffer, readString) {
         const { scope } = node;
@@ -13953,13 +13966,13 @@ const bufferParsers = [
     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);
+        node.directive = parseAst_js.convertString(buffer[position], buffer, readString);
+        node.expression = convertNode(node, scope, buffer[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);
+        node.body = convertNode(node, scope, buffer[position], buffer, readString);
+        node.test = convertNode(node, scope, buffer[position + 1], buffer, readString);
     },
     function emptyStatement() { },
     function exportAllDeclaration(node, position, buffer, readString) {
@@ -13974,25 +13987,25 @@ const bufferParsers = [
     },
     function exportDefaultDeclaration(node, position, buffer, readString) {
         const { scope } = node;
-        node.declaration = convertNode(node, scope, position, buffer, readString);
+        node.declaration = convertNode(node, scope, buffer[position], buffer, readString);
     },
     function exportNamedDeclaration(node, position, buffer, readString) {
         const { scope } = node;
-        const sourcePosition = buffer[position];
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer, readString);
+        const sourcePosition = buffer[position + 1];
         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.attributes = convertNodeList(node, scope, buffer[position + 2], buffer, readString);
+        const declarationPosition = buffer[position + 3];
         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.local = convertNode(node, scope, buffer[position], buffer, readString);
+        const exportedPosition = buffer[position + 1];
         node.exported =
             exportedPosition === 0
                 ? node.local
@@ -14000,21 +14013,21 @@ const bufferParsers = [
     },
     function expressionStatement(node, position, buffer, readString) {
         const { scope } = node;
-        node.expression = convertNode(node, scope, position, buffer, readString);
+        node.expression = convertNode(node, scope, buffer[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);
+        node.left = convertNode(node, scope, buffer[position], buffer, readString);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.body = convertNode(node, scope, buffer[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);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer, readString);
     },
     function forStatement(node, position, buffer, readString) {
         const { scope } = node;
@@ -14034,70 +14047,70 @@ const bufferParsers = [
         const flags = buffer[position];
         node.async = (flags & 1) === 1;
         node.generator = (flags & 2) === 2;
-        const idPosition = buffer[position + 1];
+        const annotations = (node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const idPosition = buffer[position + 2];
         node.id =
             idPosition === 0
                 ? null
                 : convertNode(node, scope.parent, idPosition, buffer, readString);
-        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer, readString));
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], 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');
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer, readString);
     },
     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];
+        const annotations = (node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const idPosition = buffer[position + 2];
         node.id =
             idPosition === 0 ? null : convertNode(node, node.idScope, idPosition, buffer, readString);
-        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer, readString));
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], 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');
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer, readString);
     },
     function identifier(node, position, buffer, readString) {
-        node.name = parseAst_js.convertString(position, buffer, readString);
+        node.name = parseAst_js.convertString(buffer[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.test = convertNode(node, scope, buffer[position], buffer, readString);
+        node.consequent = convertNode(node, (node.consequentScope = new TrackingScope(scope)), buffer[position + 1], buffer, readString);
+        const alternatePosition = buffer[position + 2];
         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);
+        node.key = convertNode(node, scope, buffer[position], buffer, readString);
+        node.value = convertNode(node, scope, buffer[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);
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer, readString);
     },
     function importDefaultSpecifier(node, position, buffer, readString) {
         const { scope } = node;
-        node.local = convertNode(node, scope, position, buffer, readString);
+        node.local = convertNode(node, scope, buffer[position], buffer, readString);
     },
     function importExpression(node, position, buffer, readString) {
         const { scope } = node;
-        const optionsPosition = buffer[position];
+        node.source = convertNode(node, scope, buffer[position], buffer, readString);
+        node.sourceAstNode = parseAst_js.convertNode(buffer[position], buffer, readString);
+        const optionsPosition = buffer[position + 1];
         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);
+        node.local = convertNode(node, scope, buffer[position], buffer, readString);
     },
     function importSpecifier(node, position, buffer, readString) {
         const { scope } = node;
@@ -14110,12 +14123,12 @@ const bufferParsers = [
     },
     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);
+        node.label = convertNode(node, scope, buffer[position], buffer, readString);
+        node.body = convertNode(node, scope, buffer[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));
+        const bigint = (node.bigint = parseAst_js.convertString(buffer[position], buffer, readString));
+        node.raw = parseAst_js.convertString(buffer[position + 1], buffer, readString);
         node.value = BigInt(bigint);
     },
     function literalBoolean(node, position, buffer) {
@@ -14132,66 +14145,66 @@ const bufferParsers = [
         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);
+        const flags = parseAst_js.convertString(buffer[position], buffer, readString);
+        const pattern = parseAst_js.convertString(buffer[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.value = parseAst_js.convertString(buffer[position], buffer, readString);
+        const rawPosition = buffer[position + 1];
         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);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.right = convertNode(node, scope, buffer[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);
+        node.object = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.property = convertNode(node, scope, buffer[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);
+        node.meta = convertNode(node, scope, buffer[position], buffer, readString);
+        node.property = convertNode(node, scope, buffer[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);
+        node.key = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.value = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.kind = parseAst_js.FIXED_STRINGS[buffer[position + 3]];
     },
     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);
+        node.annotations = parseAst_js.convertAnnotations(buffer[position], buffer);
+        node.callee = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.arguments = convertNodeList(node, scope, buffer[position + 2], buffer, readString);
     },
     function objectExpression(node, position, buffer, readString) {
         const { scope } = node;
-        node.properties = convertNodeList(node, scope, position, buffer, readString);
+        node.properties = convertNodeList(node, scope, buffer[position], buffer, readString);
     },
     function objectPattern(node, position, buffer, readString) {
         const { scope } = node;
-        node.properties = convertNodeList(node, scope, position, buffer, readString);
+        node.properties = convertNodeList(node, scope, buffer[position], buffer, readString);
     },
     function privateIdentifier(node, position, buffer, readString) {
-        node.name = parseAst_js.convertString(position, buffer, readString);
+        node.name = parseAst_js.convertString(buffer[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);
+        node.body = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.invalidAnnotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer);
     },
     function property(node, position, buffer, readString) {
         const { scope } = node;
@@ -14210,14 +14223,14 @@ const bufferParsers = [
         const flags = buffer[position];
         node.static = (flags & 1) === 1;
         node.computed = (flags & 2) === 2;
-        const valuePosition = buffer[position + 1];
+        node.key = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        const valuePosition = buffer[position + 2];
         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);
+        node.argument = convertNode(node, scope, buffer[position], buffer, readString);
     },
     function returnStatement(node, position, buffer, readString) {
         const { scope } = node;
@@ -14229,15 +14242,15 @@ const bufferParsers = [
     },
     function sequenceExpression(node, position, buffer, readString) {
         const { scope } = node;
-        node.expressions = convertNodeList(node, scope, position, buffer, readString);
+        node.expressions = convertNodeList(node, scope, buffer[position], buffer, readString);
     },
     function spreadElement(node, position, buffer, readString) {
         const { scope } = node;
-        node.argument = convertNode(node, scope, position, buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position], buffer, readString);
     },
     function staticBlock(node, position, buffer, readString) {
         const { scope } = node;
-        node.body = convertNodeList(node, scope, position, buffer, readString);
+        node.body = convertNodeList(node, scope, buffer[position], buffer, readString);
     },
     function superElement() { },
     function switchCase(node, position, buffer, readString) {
@@ -14249,72 +14262,72 @@ const bufferParsers = [
     },
     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);
+        node.discriminant = convertNode(node, node.parentScope, buffer[position], buffer, readString);
+        node.cases = convertNodeList(node, scope, buffer[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);
+        node.tag = convertNode(node, scope, buffer[position], buffer, readString);
+        node.quasi = convertNode(node, scope, buffer[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);
+        const raw = parseAst_js.convertString(buffer[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);
+        node.quasis = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.expressions = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
     },
     function thisExpression() { },
     function throwStatement(node, position, buffer, readString) {
         const { scope } = node;
-        node.argument = convertNode(node, scope, position, buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position], buffer, readString);
     },
     function tryStatement(node, position, buffer, readString) {
         const { scope } = node;
-        const handlerPosition = buffer[position];
+        node.block = convertNode(node, scope, buffer[position], buffer, readString);
+        const handlerPosition = buffer[position + 1];
         node.handler =
             handlerPosition === 0 ? null : convertNode(node, scope, handlerPosition, buffer, readString);
-        const finalizerPosition = buffer[position + 1];
+        const finalizerPosition = buffer[position + 2];
         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);
+        node.argument = convertNode(node, scope, buffer[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);
+        node.argument = convertNode(node, scope, buffer[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);
+        node.declarations = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
     },
     function variableDeclarator(node, position, buffer, readString) {
         const { scope } = node;
-        const initPosition = buffer[position];
+        node.id = convertNode(node, scope, buffer[position], buffer, readString);
+        const initPosition = buffer[position + 1];
         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);
+        node.test = convertNode(node, scope, buffer[position], buffer, readString);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer, readString);
     },
     function yieldExpression(node, position, buffer, readString) {
         const { scope } = node;
@@ -14344,6 +14357,8 @@ function convertNode(parent, parentScope, position, buffer, readString) {
     return node;
 }
 function convertNodeList(parent, parentScope, position, buffer, readString) {
+    if (position === 0)
+        return parseAst_js.EMPTY_ARRAY;
     const length = buffer[position++];
     const list = [];
     for (let index = 0; index < length; index++) {
@@ -14730,15 +14745,15 @@ function getAttributesFromImportExpression(node) {
         if (options) {
             context.module.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logImportAttributeIsInvalid(context.module.id), start);
         }
-        return EMPTY_OBJECT;
+        return parseAst_js.EMPTY_OBJECT;
     }
     const assertProperty = options.properties.find((property) => ATTRIBUTE_KEYWORDS.has(getPropertyKey(property)))?.value;
     if (!assertProperty) {
-        return EMPTY_OBJECT;
+        return parseAst_js.EMPTY_OBJECT;
     }
     if (!(assertProperty instanceof ObjectExpression)) {
         context.module.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logImportOptionsAreInvalid(context.module.id), start);
-        return EMPTY_OBJECT;
+        return parseAst_js.EMPTY_OBJECT;
     }
     const assertFields = assertProperty.properties
         .map(property => {
@@ -14754,7 +14769,7 @@ function getAttributesFromImportExpression(node) {
     if (assertFields.length > 0) {
         return Object.fromEntries(assertFields);
     }
-    return EMPTY_OBJECT;
+    return parseAst_js.EMPTY_OBJECT;
 }
 const getPropertyKey = (property) => {
     const key = property.key;
@@ -14765,7 +14780,7 @@ const getPropertyKey = (property) => {
 function getAttributesFromImportExportDeclaration(attributes) {
     return attributes?.length
         ? Object.fromEntries(attributes.map(assertion => [getPropertyKey(assertion), assertion.value.value]))
-        : EMPTY_OBJECT;
+        : parseAst_js.EMPTY_OBJECT;
 }
 function doAttributesDiffer(assertionA, assertionB) {
     const keysA = Object.keys(assertionA);
@@ -15253,7 +15268,7 @@ class Module {
         }
         return this.syntheticNamespace;
     }
-    getVariableForExportName(name, { importerForSideEffects, isExportAllSearch, onlyExplicit, searchedNamesAndModules } = EMPTY_OBJECT) {
+    getVariableForExportName(name, { importerForSideEffects, isExportAllSearch, onlyExplicit, searchedNamesAndModules } = parseAst_js.EMPTY_OBJECT) {
         if (name[0] === '*') {
             if (name.length === 1) {
                 // export * from './other'
@@ -15539,7 +15554,7 @@ class Module {
             transformFiles: this.transformFiles
         };
     }
-    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules } = EMPTY_OBJECT) {
+    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules } = parseAst_js.EMPTY_OBJECT) {
         const localVariable = this.scope.variables.get(name);
         if (localVariable) {
             return localVariable;
@@ -19459,9 +19474,9 @@ function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolve
         }
         replaceContext = (pluginContext, plugin) => ({
             ...pluginContext,
-            resolve: (source, importer, { attributes, custom, isEntry, skipSelf } = BLANK) => {
+            resolve: (source, importer, { attributes, custom, isEntry, skipSelf } = parseAst_js.BLANK) => {
                 skipSelf ??= true;
-                return moduleLoaderResolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, skipSelf ? [...skip, { importer, plugin, source }] : skip);
+                return moduleLoaderResolveId(source, importer, custom, isEntry, attributes || parseAst_js.EMPTY_OBJECT, skipSelf ? [...skip, { importer, plugin, source }] : skip);
             }
         });
     }
@@ -19710,7 +19725,7 @@ class ModuleLoader {
         return module;
     }
     async preloadModule(resolvedId) {
-        const module = await this.fetchModule(this.getResolvedIdWithDefaults(resolvedId, EMPTY_OBJECT), undefined, false, resolvedId.resolveDependencies ? RESOLVE_DEPENDENCIES : true);
+        const module = await this.fetchModule(this.getResolvedIdWithDefaults(resolvedId, parseAst_js.EMPTY_OBJECT), undefined, false, resolvedId.resolveDependencies ? RESOLVE_DEPENDENCIES : true);
         return module.info;
     }
     addEntryWithImplicitDependants(unresolvedModule, implicitlyLoadedAfter) {
@@ -19957,7 +19972,7 @@ class ModuleLoader {
             source,
             (module.resolvedIds[source] =
                 module.resolvedIds[source] ||
-                    this.handleInvalidResolvedId(await this.resolveId(source, module.id, EMPTY_OBJECT, false, attributes), source, module.id, attributes))
+                    this.handleInvalidResolvedId(await this.resolveId(source, module.id, parseAst_js.EMPTY_OBJECT, false, attributes), source, module.id, attributes))
         ]);
     }
     getResolvedIdWithDefaults(resolvedId, attributes) {
@@ -20016,7 +20031,7 @@ class ModuleLoader {
         return resolvedId;
     }
     async loadEntryModule(unresolvedId, isEntry, importer, implicitlyLoadedBefore, isLoadForManualChunks = false) {
-        const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, EMPTY_OBJECT, true, EMPTY_OBJECT);
+        const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, parseAst_js.EMPTY_OBJECT, true, parseAst_js.EMPTY_OBJECT);
         if (resolveIdResult == null) {
             return parseAst_js.error(implicitlyLoadedBefore === null
                 ? parseAst_js.logUnresolvedEntry(unresolvedId)
@@ -20032,7 +20047,7 @@ class ModuleLoader {
         }
         return this.fetchModule(this.getResolvedIdWithDefaults(typeof resolveIdResult === 'object'
             ? resolveIdResult
-            : { id: resolveIdResult }, EMPTY_OBJECT), undefined, isEntry, false);
+            : { id: resolveIdResult }, parseAst_js.EMPTY_OBJECT), undefined, isEntry, false);
     }
     async resolveDynamicImport(module, specifier, importer, attributes) {
         const resolution = await this.pluginDriver.hookFirst('resolveDynamicImport', [
@@ -20057,7 +20072,7 @@ class ModuleLoader {
                 }
                 return existingResolution;
             }
-            return (module.resolvedIds[specifier] = this.handleInvalidResolvedId(await this.resolveId(specifier, module.id, EMPTY_OBJECT, false, attributes), specifier, module.id, attributes));
+            return (module.resolvedIds[specifier] = this.handleInvalidResolvedId(await this.resolveId(specifier, module.id, parseAst_js.EMPTY_OBJECT, false, attributes), specifier, module.id, attributes));
         }
         return this.handleInvalidResolvedId(this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(resolution, importer, specifier), attributes), specifier, importer, attributes);
     }
@@ -20469,7 +20484,7 @@ const getTreeshake = (config) => {
     return {
         annotations: configWithPreset.annotations !== false,
         correctVarValueBeforeDeclaration: configWithPreset.correctVarValueBeforeDeclaration === true,
-        manualPureFunctions: configWithPreset.manualPureFunctions ?? EMPTY_ARRAY,
+        manualPureFunctions: configWithPreset.manualPureFunctions ?? parseAst_js.EMPTY_ARRAY,
         moduleSideEffects: getHasModuleSideEffects(configWithPreset.moduleSideEffects),
         propertyReadSideEffects: configWithPreset.propertyReadSideEffects === 'always'
             ? 'always'