@rollup/wasm-node 4.14.0 → 4.14.2

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.14.0
-	Wed, 03 Apr 2024 05:22:15 GMT - commit 5abe71bd5bae3423b4e2ee80207c871efde20253
+	Rollup.js v4.14.2
+	Fri, 12 Apr 2024 06:23:07 GMT - commit 7275328b41b29605142bfdf55d68cb54e895a20c
 
 	https://github.com/rollup/rollup
 
@@ -12,7 +12,7 @@
 const parseAst_js = require('./parseAst.js');
 const process$1 = require('node:process');
 const tty = require('tty');
-const node_path = require('node:path');
+const path$2 = require('node:path');
 const require$$0$1 = require('path');
 const native_js = require('../native.js');
 const node_perf_hooks = require('node:perf_hooks');
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.14.0";
+var version = "4.14.2";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -195,7 +195,7 @@ function renderNamePattern(pattern, patternName, replacements) {
 function makeUnique(name, { [lowercaseBundleKeys]: reservedLowercaseBundleKeys }) {
     if (!reservedLowercaseBundleKeys.has(name.toLowerCase()))
         return name;
-    const extension = node_path.extname(name);
+    const extension = path$2.extname(name);
     name = name.slice(0, Math.max(0, name.length - extension.length));
     let uniqueName, uniqueIndex = 1;
     while (reservedLowercaseBundleKeys.has((uniqueName = name + ++uniqueIndex + extension).toLowerCase()))
@@ -208,10 +208,10 @@ function generateAssetFileName(name, source, sourceHash, outputOptions, bundle)
     return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
         ? outputOptions.assetFileNames({ name, source, type: 'asset' })
         : outputOptions.assetFileNames, 'output.assetFileNames', {
-        ext: () => node_path.extname(emittedName).slice(1),
-        extname: () => node_path.extname(emittedName),
+        ext: () => path$2.extname(emittedName).slice(1),
+        extname: () => path$2.extname(emittedName),
         hash: size => sourceHash.slice(0, Math.max(0, size || DEFAULT_HASH_SIZE)),
-        name: () => emittedName.slice(0, Math.max(0, emittedName.length - node_path.extname(emittedName).length))
+        name: () => emittedName.slice(0, Math.max(0, emittedName.length - path$2.extname(emittedName).length))
     }), bundle);
 }
 function reserveFileNameInBundle(fileName, { bundle }, log) {
@@ -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) {
@@ -2829,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;
 	}
@@ -2875,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;
@@ -3217,7 +3218,7 @@ class ExternalChunk {
         const { paths } = this.options;
         return (this.fileName =
             (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
-                (this.renormalizeRenderPath ? parseAst_js.normalize(node_path.relative(this.inputBase, this.id)) : this.id));
+                (this.renormalizeRenderPath ? parseAst_js.normalize(path$2.relative(this.inputBase, this.id)) : this.id));
     }
     getImportAttributes(snippets) {
         return (this.importAttributes ||= formatAttributes(this.options.format === 'es' &&
@@ -3601,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();
             },
@@ -3610,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();
             },
@@ -6092,7 +6093,7 @@ function getMemberReturnExpressionWhenCalled(members, memberName) {
     return [members[memberName].returns, false];
 }
 
-// This file is generated by scripts/generate-ast-converters.js.
+// This file is generated by scripts/generate-child-node-keys.js.
 // Do not edit this file directly.
 const childNodeKeys = {
     ArrayExpression: ['elements'],
@@ -7147,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();
             }
@@ -7246,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]);
@@ -8883,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) {
@@ -9364,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);
@@ -9560,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);
@@ -9632,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);
     }
@@ -9869,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);
     }
@@ -10090,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) {
@@ -10201,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';
@@ -10347,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();
             }
@@ -10482,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
@@ -10837,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, '(');
@@ -10893,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();
             }
@@ -10971,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 });
@@ -11373,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, '(');
@@ -11840,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)) {
@@ -11889,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) {
@@ -11924,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 ||
@@ -11939,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) {
@@ -12213,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();
             }
@@ -12285,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) {
@@ -12381,7 +12379,7 @@ class MetaProperty extends NodeBase {
         const chunkId = preliminaryChunkId;
         if (referenceId) {
             const fileName = pluginDriver.getFileName(referenceId);
-            const relativePath = parseAst_js.normalize(node_path.relative(node_path.dirname(chunkId), fileName));
+            const relativePath = parseAst_js.normalize(path$2.relative(path$2.dirname(chunkId), fileName));
             const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
                 { chunkId, fileName, format, moduleId, referenceId, relativePath }
             ]) || relativeUrlMechanisms[format](relativePath);
@@ -12543,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) {
@@ -12828,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];
@@ -13483,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))
@@ -13510,7 +13508,7 @@ class VariableDeclaration extends NodeBase {
     removeAnnotations(code) {
         this.declarations[0].removeAnnotations(code);
     }
-    render(code, options, nodeRenderOptions = BLANK) {
+    render(code, options, nodeRenderOptions = parseAst_js.BLANK) {
         if (this.isUsingDeclaration ||
             areAllDeclarationsIncludedAndNotExported(this.declarations, options.exportNamesByVariable)) {
             for (const declarator of this.declarations) {
@@ -13669,7 +13667,7 @@ class YieldExpression extends NodeBase {
     }
 }
 
-// This file is generated by scripts/generate-ast-converters.js.
+// This file is generated by scripts/generate-buffer-parsers.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));
@@ -13838,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;
@@ -13857,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;
@@ -13898,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;
@@ -13914,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) {
@@ -13952,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;
@@ -13965,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) {
@@ -13986,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
@@ -14012,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;
@@ -14046,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;
@@ -14122,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) {
@@ -14144,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;
@@ -14222,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;
@@ -14241,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) {
@@ -14261,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;
@@ -14356,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++) {
@@ -14742,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 => {
@@ -14766,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;
@@ -14777,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);
@@ -15092,8 +15095,8 @@ class Module {
         };
     }
     basename() {
-        const base = node_path.basename(this.id);
-        const extension = node_path.extname(this.id);
+        const base = path$2.basename(this.id);
+        const extension = path$2.extname(this.id);
         return makeLegal(extension ? base.slice(0, -extension.length) : base);
     }
     bindReferences() {
@@ -15265,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'
@@ -15551,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;
@@ -17297,7 +17300,7 @@ class Chunk {
         let hashPlaceholder = null;
         const { chunkFileNames, entryFileNames, file, format, preserveModules } = this.outputOptions;
         if (file) {
-            fileName = node_path.basename(file);
+            fileName = path$2.basename(file);
         }
         else if (this.fileName === null) {
             const [pattern, patternName] = preserveModules || this.facadeModule?.isUserDefinedEntryPoint
@@ -17395,15 +17398,15 @@ class Chunk {
         const renderedExports = exportMode === 'none' ? [] : this.getChunkExportDeclarations(format);
         let hasExports = renderedExports.length > 0;
         let hasDefaultExport = false;
-        for (const renderedDependence of renderedDependencies) {
-            const { reexports } = renderedDependence;
+        for (const renderedDependency of renderedDependencies) {
+            const { reexports } = renderedDependency;
             if (reexports?.length) {
                 hasExports = true;
                 if (!hasDefaultExport && reexports.some(reexport => reexport.reexported === 'default')) {
                     hasDefaultExport = true;
                 }
                 if (format === 'es') {
-                    renderedDependence.reexports = reexports.filter(
+                    renderedDependency.reexports = reexports.filter(
                     // eslint-disable-next-line unicorn/prefer-array-some
                     ({ reexported }) => !renderedExports.find(({ exported }) => exported === reexported));
                 }
@@ -17610,8 +17613,13 @@ class Chunk {
                                 deconflictedDefault.add(chunk);
                             }
                         }
-                        else if (variable.name === '*' &&
-                            namespaceInteropHelpersByInteropType[interop(module.id)]) {
+                        else if (variable.isNamespace &&
+                            namespaceInteropHelpersByInteropType[interop(module.id)] &&
+                            (this.imports.has(variable) ||
+                                !this.exportNamesByVariable.get(variable)?.every(name => name.startsWith('*')))) {
+                            // We only need to deconflict it if the namespace is actually
+                            // created as a variable, i.e. because it is used internally or
+                            // because it is reexported as an object
                             deconflictedNamespace.add(chunk);
                         }
                     }
@@ -17745,17 +17753,17 @@ class Chunk {
             return predefinedChunkName;
         const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
         const sanitizedId = sanitizeFileName(parseAst_js.normalize(module.id.split(QUERY_HASH_REGEX, 1)[0]));
-        const extensionName = node_path.extname(sanitizedId);
+        const extensionName = path$2.extname(sanitizedId);
         const idWithoutExtension = NON_ASSET_EXTENSIONS.has(extensionName)
             ? sanitizedId.slice(0, -extensionName.length)
             : sanitizedId;
         if (parseAst_js.isAbsolute(idWithoutExtension)) {
-            return preserveModulesRoot && node_path.resolve(idWithoutExtension).startsWith(preserveModulesRoot)
+            return preserveModulesRoot && path$2.resolve(idWithoutExtension).startsWith(preserveModulesRoot)
                 ? idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[/\\]/, '')
                 : parseAst_js.relative(this.inputBase, idWithoutExtension);
         }
         else {
-            return `_virtual/${node_path.basename(idWithoutExtension)}`;
+            return `_virtual/${path$2.basename(idWithoutExtension)}`;
         }
     }
     getReexportSpecifiers() {
@@ -17825,23 +17833,25 @@ class Chunk {
         const reexportSpecifiers = this.getReexportSpecifiers();
         const renderedDependencies = new Map();
         const fileName = this.getFileName();
-        for (const dep of this.dependencies) {
-            const imports = importSpecifiers.get(dep) || null;
-            const reexports = reexportSpecifiers.get(dep) || null;
-            const namedExportsMode = dep instanceof ExternalChunk || dep.exportMode !== 'default';
-            const importPath = dep.getImportPath(fileName);
-            renderedDependencies.set(dep, {
-                attributes: dep instanceof ExternalChunk ? dep.getImportAttributes(this.snippets) : null,
-                defaultVariableName: dep.defaultVariableName,
-                globalName: dep instanceof ExternalChunk &&
+        for (const dependency of this.dependencies) {
+            const imports = importSpecifiers.get(dependency) || null;
+            const reexports = reexportSpecifiers.get(dependency) || null;
+            const namedExportsMode = dependency instanceof ExternalChunk || dependency.exportMode !== 'default';
+            const importPath = dependency.getImportPath(fileName);
+            renderedDependencies.set(dependency, {
+                attributes: dependency instanceof ExternalChunk
+                    ? dependency.getImportAttributes(this.snippets)
+                    : null,
+                defaultVariableName: dependency.defaultVariableName,
+                globalName: dependency instanceof ExternalChunk &&
                     (this.outputOptions.format === 'umd' || this.outputOptions.format === 'iife') &&
-                    getGlobalName(dep, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onLog),
+                    getGlobalName(dependency, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onLog),
                 importPath,
                 imports,
-                isChunk: dep instanceof Chunk,
-                name: dep.variableName,
+                isChunk: dependency instanceof Chunk,
+                name: dependency.variableName,
                 namedExportsMode,
-                namespaceVariableName: dep.namespaceVariableName,
+                namespaceVariableName: dependency.namespaceVariableName,
                 reexports
             });
         }
@@ -18736,7 +18746,7 @@ function commondir(files) {
     if (files.length === 0)
         return '/';
     if (files.length === 1)
-        return node_path.dirname(files[0]);
+        return path$2.dirname(files[0]);
     const commonSegments = files.slice(1).reduce((commonSegments, file) => {
         const pathSegments = file.split(/\/+|\\+/);
         let index;
@@ -18753,6 +18763,13 @@ const compareExecIndex = (unitA, unitB) => unitA.execIndex > unitB.execIndex ? 1
 function sortByExecutionOrder(units) {
     units.sort(compareExecIndex);
 }
+// This process is currently faulty in so far as it only takes the first entry
+// module into account and assumes that dynamic imports are imported in a
+// certain order.
+// A better algorithm would follow every possible execution path and mark which
+// modules are executed before or after which other modules. THen the chunking
+// would need to take care that in each chunk, all modules are always executed
+// in the same sequence.
 function analyseModuleExecution(entryModules) {
     let nextExecIndex = 0;
     const cyclePaths = [];
@@ -18987,9 +19004,9 @@ function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapCha
     if (originalSourcemap) {
         const sources = originalSourcemap.sources;
         const sourcesContent = originalSourcemap.sourcesContent || [];
-        const directory = node_path.dirname(id) || '.';
+        const directory = path$2.dirname(id) || '.';
         const sourceRoot = originalSourcemap.sourceRoot || '.';
-        const baseSources = sources.map((source, index) => new Source(node_path.resolve(directory, sourceRoot, source), sourcesContent[index]));
+        const baseSources = sources.map((source, index) => new Source(path$2.resolve(directory, sourceRoot, source), sourcesContent[index]));
         source = new Link(originalSourcemap, baseSources);
     }
     else {
@@ -19006,9 +19023,9 @@ function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeCon
     const source = bundleSourcemapChain.reduce(linkMap, link);
     let { sources, sourcesContent, names, mappings } = source.traceMappings();
     if (file) {
-        const directory = node_path.dirname(file);
-        sources = sources.map((source) => node_path.relative(directory, source));
-        file = node_path.basename(file);
+        const directory = path$2.dirname(file);
+        sources = sources.map((source) => path$2.relative(directory, source));
+        file = path$2.basename(file);
     }
     sourcesContent = (excludeContent ? null : sourcesContent);
     for (const module of modules) {
@@ -19082,11 +19099,11 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
         timeStart('sourcemaps', 3);
         let resultingFile;
         if (file)
-            resultingFile = node_path.resolve(sourcemapFile || file);
+            resultingFile = path$2.resolve(sourcemapFile || file);
         else if (dir)
-            resultingFile = node_path.resolve(dir, fileName);
+            resultingFile = path$2.resolve(dir, fileName);
         else
-            resultingFile = node_path.resolve(fileName);
+            resultingFile = path$2.resolve(fileName);
         const decodedMap = magicString.generateDecodedMap({});
         map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, log);
         for (let sourcesIndex = 0; sourcesIndex < map.sources.length; ++sourcesIndex) {
@@ -19232,7 +19249,7 @@ function emitSourceMapAndGetComment(fileName, map, pluginDriver, { sourcemap, so
         url = map.toUrl();
     }
     else {
-        const sourcemapFileName = node_path.basename(fileName);
+        const sourcemapFileName = path$2.basename(fileName);
         url = sourcemapBaseUrl
             ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
             : sourcemapFileName;
@@ -19471,9 +19488,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);
             }
         });
     }
@@ -19506,7 +19523,7 @@ async function resolveId(source, importer, preserveSymlinks, pluginDriver, modul
     // absolute path is created. Absolute importees therefore shortcircuit the
     // resolve call and require no special handing on our part.
     // See https://nodejs.org/api/path.html#path_path_resolve_paths
-    return addJsExtensionIfNecessary(importer ? node_path.resolve(node_path.dirname(importer), source) : node_path.resolve(source), preserveSymlinks);
+    return addJsExtensionIfNecessary(importer ? path$2.resolve(path$2.dirname(importer), source) : path$2.resolve(source), preserveSymlinks);
 }
 async function addJsExtensionIfNecessary(file, preserveSymlinks) {
     return ((await findFile(file, preserveSymlinks)) ??
@@ -19520,8 +19537,8 @@ async function findFile(file, preserveSymlinks) {
             return await findFile(await promises.realpath(file), preserveSymlinks);
         if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
             // check case
-            const name = node_path.basename(file);
-            const files = await promises.readdir(node_path.dirname(file));
+            const name = path$2.basename(file);
+            const files = await promises.readdir(path$2.dirname(file));
             if (files.includes(name))
                 return file;
         }
@@ -19722,7 +19739,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) {
@@ -19969,7 +19986,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) {
@@ -20028,7 +20045,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)
@@ -20044,7 +20061,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', [
@@ -20069,7 +20086,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);
     }
@@ -20077,8 +20094,8 @@ class ModuleLoader {
 function normalizeRelativeExternalId(source, importer) {
     return parseAst_js.isRelative(source)
         ? importer
-            ? node_path.resolve(importer, '..', source)
-            : node_path.resolve(source)
+            ? path$2.resolve(importer, '..', source)
+            : path$2.resolve(source)
         : source;
 }
 function addChunkNamesToModule(module, { fileName, name }, isUserDefined, priority) {
@@ -20466,7 +20483,7 @@ const getModuleContext = (config, context) => {
     if (configModuleContext) {
         const contextByModuleId = Object.create(null);
         for (const [key, moduleContext] of Object.entries(configModuleContext)) {
-            contextByModuleId[node_path.resolve(key)] = moduleContext;
+            contextByModuleId[path$2.resolve(key)] = moduleContext;
         }
         return id => contextByModuleId[id] ?? context;
     }
@@ -20481,7 +20498,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'
@@ -20657,7 +20674,7 @@ const getPreserveModulesRoot = (config) => {
     if (preserveModulesRoot === null || preserveModulesRoot === undefined) {
         return undefined;
     }
-    return node_path.resolve(preserveModulesRoot);
+    return path$2.resolve(preserveModulesRoot);
 };
 const getAmd = (config) => {
     const mergedOption = {
@@ -20957,9 +20974,9 @@ function getSortingFileType(file) {
     return SortingFileType.SECONDARY_CHUNK;
 }
 async function writeOutputFile(outputFile, outputOptions) {
-    const fileName = node_path.resolve(outputOptions.dir || node_path.dirname(outputOptions.file), outputFile.fileName);
+    const fileName = path$2.resolve(outputOptions.dir || path$2.dirname(outputOptions.file), outputFile.fileName);
     // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
-    await promises.mkdir(node_path.dirname(fileName), { recursive: true });
+    await promises.mkdir(path$2.dirname(fileName), { recursive: true });
     return promises.writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
 }
 /**