rollup 3.28.0 → 4.0.0-10

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

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.28.0
-	Wed, 09 Aug 2023 05:34:03 GMT - commit e3b614c9d4555248caa43d062f4003859b388434
+	Rollup.js v4.0.0-10
+	Mon, 21 Aug 2023 15:29:18 GMT - commit 2c7e3e32f5d56c60d92907a9ceacd338aa99ca82
 
 	https://github.com/rollup/rollup
 
@@ -12,10 +12,11 @@ import require$$0$1, { win32, posix, isAbsolute as isAbsolute$1, resolve as reso
 import process$1, { env as env$1 } from 'node:process';
 import { performance } from 'node:perf_hooks';
 import { createHash as createHash$1 } from 'node:crypto';
+import native from './native.cjs';
 import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import * as tty from 'tty';
 
-var version$1 = "3.28.0";
+var version$1 = "4.0.0-10";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -347,7 +348,7 @@ let Chunk$1 = class Chunk {
 	}
 };
 
-function getBtoa () {
+function getBtoa() {
 	if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
 		return (str) => window.btoa(unescape(encodeURIComponent(str)));
 	} else if (typeof Buffer === 'function') {
@@ -460,6 +461,8 @@ function getLocator$1(source) {
 	};
 }
 
+const wordRegex = /\w/;
+
 class Mappings {
 	constructor(hires) {
 		this.hires = hires;
@@ -488,10 +491,29 @@ class Mappings {
 	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
 		let originalCharIndex = chunk.start;
 		let first = true;
+		// when iterating each char, check if it's in a word boundary
+		let charInHiresBoundary = false;
 
 		while (originalCharIndex < chunk.end) {
 			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
-				this.rawSegments.push([this.generatedCodeColumn, sourceIndex, loc.line, loc.column]);
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+				if (this.hires === 'boundary') {
+					// in hires "boundary", group segments per word boundary than per char
+					if (wordRegex.test(original[originalCharIndex])) {
+						// for first char in the boundary found, start the boundary by pushing a segment
+						if (!charInHiresBoundary) {
+							this.rawSegments.push(segment);
+							charInHiresBoundary = true;
+						}
+					} else {
+						// for non-word char, end the boundary by pushing a segment
+						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
+					}
+				} else {
+					this.rawSegments.push(segment);
+				}
 			}
 
 			if (original[originalCharIndex] === '\n') {
@@ -664,7 +686,7 @@ class MagicString {
 					sourceIndex,
 					chunk.content,
 					loc,
-					chunk.storeName ? names.indexOf(chunk.original) : -1
+					chunk.storeName ? names.indexOf(chunk.original) : -1,
 				);
 			} else {
 				mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
@@ -675,11 +697,13 @@ class MagicString {
 
 		return {
 			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
-			sources: [options.source ? getRelativePath(options.file || '', options.source) : (options.file || '')],
+			sources: [
+				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+			],
 			sourcesContent: options.includeContent ? [this.original] : undefined,
 			names,
 			mappings: mappings.raw,
-			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
 		};
 	}
 
@@ -793,14 +817,14 @@ class MagicString {
 
 	insert() {
 		throw new Error(
-			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)'
+			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
 		);
 	}
 
 	insertLeft(index, content) {
 		if (!warned.insertLeft) {
 			console.warn(
-				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead'
+				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
 			); // eslint-disable-line no-console
 			warned.insertLeft = true;
 		}
@@ -811,7 +835,7 @@ class MagicString {
 	insertRight(index, content) {
 		if (!warned.insertRight) {
 			console.warn(
-				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead'
+				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
 			); // eslint-disable-line no-console
 			warned.insertRight = true;
 		}
@@ -870,7 +894,7 @@ class MagicString {
 		if (end > this.original.length) throw new Error('end is out of bounds');
 		if (start === end)
 			throw new Error(
-				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead'
+				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
 			);
 
 		this._split(start);
@@ -879,7 +903,7 @@ class MagicString {
 		if (options === true) {
 			if (!warned.storeName) {
 				console.warn(
-					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string'
+					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
 				); // eslint-disable-line no-console
 				warned.storeName = true;
 			}
@@ -1101,7 +1125,7 @@ class MagicString {
 			// zero-length edited chunks are a special case (overlapping replacements)
 			const loc = getLocator$1(this.original)(index);
 			throw new Error(
-				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`
+				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
 			);
 		}
 
@@ -1260,7 +1284,7 @@ class MagicString {
 					this.overwrite(
 						match.index,
 						match.index + match[0].length,
-						getReplacement(match, this.original)
+						getReplacement(match, this.original),
 					);
 			});
 		} else {
@@ -1269,7 +1293,7 @@ class MagicString {
 				this.overwrite(
 					match.index,
 					match.index + match[0].length,
-					getReplacement(match, this.original)
+					getReplacement(match, this.original),
 				);
 		}
 		return this;
@@ -1315,7 +1339,7 @@ class MagicString {
 
 		if (!searchValue.global) {
 			throw new TypeError(
-				'MagicString.prototype.replaceAll called with a non-global RegExp argument'
+				'MagicString.prototype.replaceAll called with a non-global RegExp argument',
 			);
 		}
 
@@ -1345,7 +1369,7 @@ let Bundle$1 = class Bundle {
 
 		if (!isObject$1(source) || !source.content) {
 			throw new Error(
-				'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`'
+				'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',
 			);
 		}
 
@@ -1439,7 +1463,7 @@ let Bundle$1 = class Bundle {
 							sourceIndex,
 							chunk.content,
 							loc,
-							chunk.storeName ? names.indexOf(chunk.original) : -1
+							chunk.storeName ? names.indexOf(chunk.original) : -1,
 						);
 					} else {
 						mappings.addUneditedChunk(
@@ -1447,7 +1471,7 @@ let Bundle$1 = class Bundle {
 							chunk,
 							magicString.original,
 							loc,
-							magicString.sourcemapLocations
+							magicString.sourcemapLocations,
 						);
 					}
 				} else {
@@ -1565,7 +1589,7 @@ let Bundle$1 = class Bundle {
 	length() {
 		return this.sources.reduce(
 			(length, source) => length + source.content.length(),
-			this.intro.length
+			this.intro.length,
 		);
 	}
 
@@ -2254,7 +2278,11 @@ function augmentCodeLocation(properties, pos, source, id) {
     }
     else {
         properties.pos = pos;
-        const { line, column } = locate(source, pos, { offsetLine: 1 });
+        const location = locate(source, pos, { offsetLine: 1 });
+        if (!location) {
+            return;
+        }
+        const { line, column } = location;
         properties.loc = { column, file: id, line };
     }
     if (properties.frame === undefined) {
@@ -2341,12 +2369,12 @@ function logChunkNotGeneratedForFileName(name) {
         message: `Plugin error - Unable to get file name for emitted chunk "${name}". You can only get file names once chunks have been generated after the "renderStart" hook.`
     };
 }
-function logChunkInvalid({ fileName, code }, exception) {
+function logChunkInvalid({ fileName, code }, { pos, message }) {
     const errorProperties = {
         code: CHUNK_INVALID,
-        message: `Chunk "${fileName}" is not valid JavaScript: ${exception.message}.`
+        message: `Chunk "${fileName}" is not valid JavaScript: ${message}.`
     };
-    augmentCodeLocation(errorProperties, exception.loc, code, fileName);
+    augmentCodeLocation(errorProperties, pos, code, fileName);
     return errorProperties;
 }
 function logCircularDependency(cyclePath) {
@@ -5341,462 +5369,1235 @@ function getMemberReturnExpressionWhenCalled(members, memberName) {
     return [members[memberName].returns, false];
 }
 
-// AST walker module for Mozilla Parser API compatible trees
-
-
-function skipThrough(node, st, c) { c(node, st); }
-function ignore(_node, _st, _c) {}
-
-// Node walkers.
-
-var base$1 = {};
-
-base$1.Program = base$1.BlockStatement = base$1.StaticBlock = function (node, st, c) {
-  for (var i = 0, list = node.body; i < list.length; i += 1)
-    {
-    var stmt = list[i];
-
-    c(stmt, st, "Statement");
-  }
-};
-base$1.Statement = skipThrough;
-base$1.EmptyStatement = ignore;
-base$1.ExpressionStatement = base$1.ParenthesizedExpression = base$1.ChainExpression =
-  function (node, st, c) { return c(node.expression, st, "Expression"); };
-base$1.IfStatement = function (node, st, c) {
-  c(node.test, st, "Expression");
-  c(node.consequent, st, "Statement");
-  if (node.alternate) { c(node.alternate, st, "Statement"); }
-};
-base$1.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };
-base$1.BreakStatement = base$1.ContinueStatement = ignore;
-base$1.WithStatement = function (node, st, c) {
-  c(node.object, st, "Expression");
-  c(node.body, st, "Statement");
-};
-base$1.SwitchStatement = function (node, st, c) {
-  c(node.discriminant, st, "Expression");
-  for (var i$1 = 0, list$1 = node.cases; i$1 < list$1.length; i$1 += 1) {
-    var cs = list$1[i$1];
-
-    if (cs.test) { c(cs.test, st, "Expression"); }
-    for (var i = 0, list = cs.consequent; i < list.length; i += 1)
-      {
-      var cons = list[i];
-
-      c(cons, st, "Statement");
-    }
-  }
-};
-base$1.SwitchCase = function (node, st, c) {
-  if (node.test) { c(node.test, st, "Expression"); }
-  for (var i = 0, list = node.consequent; i < list.length; i += 1)
-    {
-    var cons = list[i];
-
-    c(cons, st, "Statement");
-  }
-};
-base$1.ReturnStatement = base$1.YieldExpression = base$1.AwaitExpression = function (node, st, c) {
-  if (node.argument) { c(node.argument, st, "Expression"); }
-};
-base$1.ThrowStatement = base$1.SpreadElement =
-  function (node, st, c) { return c(node.argument, st, "Expression"); };
-base$1.TryStatement = function (node, st, c) {
-  c(node.block, st, "Statement");
-  if (node.handler) { c(node.handler, st); }
-  if (node.finalizer) { c(node.finalizer, st, "Statement"); }
-};
-base$1.CatchClause = function (node, st, c) {
-  if (node.param) { c(node.param, st, "Pattern"); }
-  c(node.body, st, "Statement");
-};
-base$1.WhileStatement = base$1.DoWhileStatement = function (node, st, c) {
-  c(node.test, st, "Expression");
-  c(node.body, st, "Statement");
-};
-base$1.ForStatement = function (node, st, c) {
-  if (node.init) { c(node.init, st, "ForInit"); }
-  if (node.test) { c(node.test, st, "Expression"); }
-  if (node.update) { c(node.update, st, "Expression"); }
-  c(node.body, st, "Statement");
-};
-base$1.ForInStatement = base$1.ForOfStatement = function (node, st, c) {
-  c(node.left, st, "ForInit");
-  c(node.right, st, "Expression");
-  c(node.body, st, "Statement");
-};
-base$1.ForInit = function (node, st, c) {
-  if (node.type === "VariableDeclaration") { c(node, st); }
-  else { c(node, st, "Expression"); }
-};
-base$1.DebuggerStatement = ignore;
-
-base$1.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };
-base$1.VariableDeclaration = function (node, st, c) {
-  for (var i = 0, list = node.declarations; i < list.length; i += 1)
-    {
-    var decl = list[i];
-
-    c(decl, st);
-  }
-};
-base$1.VariableDeclarator = function (node, st, c) {
-  c(node.id, st, "Pattern");
-  if (node.init) { c(node.init, st, "Expression"); }
-};
-
-base$1.Function = function (node, st, c) {
-  if (node.id) { c(node.id, st, "Pattern"); }
-  for (var i = 0, list = node.params; i < list.length; i += 1)
-    {
-    var param = list[i];
-
-    c(param, st, "Pattern");
-  }
-  c(node.body, st, node.expression ? "Expression" : "Statement");
-};
-
-base$1.Pattern = function (node, st, c) {
-  if (node.type === "Identifier")
-    { c(node, st, "VariablePattern"); }
-  else if (node.type === "MemberExpression")
-    { c(node, st, "MemberPattern"); }
-  else
-    { c(node, st); }
-};
-base$1.VariablePattern = ignore;
-base$1.MemberPattern = skipThrough;
-base$1.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };
-base$1.ArrayPattern = function (node, st, c) {
-  for (var i = 0, list = node.elements; i < list.length; i += 1) {
-    var elt = list[i];
-
-    if (elt) { c(elt, st, "Pattern"); }
-  }
-};
-base$1.ObjectPattern = function (node, st, c) {
-  for (var i = 0, list = node.properties; i < list.length; i += 1) {
-    var prop = list[i];
-
-    if (prop.type === "Property") {
-      if (prop.computed) { c(prop.key, st, "Expression"); }
-      c(prop.value, st, "Pattern");
-    } else if (prop.type === "RestElement") {
-      c(prop.argument, st, "Pattern");
-    }
-  }
-};
-
-base$1.Expression = skipThrough;
-base$1.ThisExpression = base$1.Super = base$1.MetaProperty = ignore;
-base$1.ArrayExpression = function (node, st, c) {
-  for (var i = 0, list = node.elements; i < list.length; i += 1) {
-    var elt = list[i];
-
-    if (elt) { c(elt, st, "Expression"); }
-  }
-};
-base$1.ObjectExpression = function (node, st, c) {
-  for (var i = 0, list = node.properties; i < list.length; i += 1)
-    {
-    var prop = list[i];
-
-    c(prop, st);
-  }
-};
-base$1.FunctionExpression = base$1.ArrowFunctionExpression = base$1.FunctionDeclaration;
-base$1.SequenceExpression = function (node, st, c) {
-  for (var i = 0, list = node.expressions; i < list.length; i += 1)
-    {
-    var expr = list[i];
-
-    c(expr, st, "Expression");
-  }
-};
-base$1.TemplateLiteral = function (node, st, c) {
-  for (var i = 0, list = node.quasis; i < list.length; i += 1)
-    {
-    var quasi = list[i];
-
-    c(quasi, st);
-  }
-
-  for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1)
-    {
-    var expr = list$1[i$1];
-
-    c(expr, st, "Expression");
-  }
-};
-base$1.TemplateElement = ignore;
-base$1.UnaryExpression = base$1.UpdateExpression = function (node, st, c) {
-  c(node.argument, st, "Expression");
-};
-base$1.BinaryExpression = base$1.LogicalExpression = function (node, st, c) {
-  c(node.left, st, "Expression");
-  c(node.right, st, "Expression");
-};
-base$1.AssignmentExpression = base$1.AssignmentPattern = function (node, st, c) {
-  c(node.left, st, "Pattern");
-  c(node.right, st, "Expression");
-};
-base$1.ConditionalExpression = function (node, st, c) {
-  c(node.test, st, "Expression");
-  c(node.consequent, st, "Expression");
-  c(node.alternate, st, "Expression");
-};
-base$1.NewExpression = base$1.CallExpression = function (node, st, c) {
-  c(node.callee, st, "Expression");
-  if (node.arguments)
-    { for (var i = 0, list = node.arguments; i < list.length; i += 1)
-      {
-        var arg = list[i];
-
-        c(arg, st, "Expression");
-      } }
-};
-base$1.MemberExpression = function (node, st, c) {
-  c(node.object, st, "Expression");
-  if (node.computed) { c(node.property, st, "Expression"); }
-};
-base$1.ExportNamedDeclaration = base$1.ExportDefaultDeclaration = function (node, st, c) {
-  if (node.declaration)
-    { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); }
-  if (node.source) { c(node.source, st, "Expression"); }
-};
-base$1.ExportAllDeclaration = function (node, st, c) {
-  if (node.exported)
-    { c(node.exported, st); }
-  c(node.source, st, "Expression");
-};
-base$1.ImportDeclaration = function (node, st, c) {
-  for (var i = 0, list = node.specifiers; i < list.length; i += 1)
-    {
-    var spec = list[i];
-
-    c(spec, st);
-  }
-  c(node.source, st, "Expression");
-};
-base$1.ImportExpression = function (node, st, c) {
-  c(node.source, st, "Expression");
-};
-base$1.ImportSpecifier = base$1.ImportDefaultSpecifier = base$1.ImportNamespaceSpecifier = base$1.Identifier = base$1.PrivateIdentifier = base$1.Literal = ignore;
-
-base$1.TaggedTemplateExpression = function (node, st, c) {
-  c(node.tag, st, "Expression");
-  c(node.quasi, st, "Expression");
-};
-base$1.ClassDeclaration = base$1.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };
-base$1.Class = function (node, st, c) {
-  if (node.id) { c(node.id, st, "Pattern"); }
-  if (node.superClass) { c(node.superClass, st, "Expression"); }
-  c(node.body, st);
-};
-base$1.ClassBody = function (node, st, c) {
-  for (var i = 0, list = node.body; i < list.length; i += 1)
-    {
-    var elt = list[i];
-
-    c(elt, st);
-  }
-};
-base$1.MethodDefinition = base$1.PropertyDefinition = base$1.Property = function (node, st, c) {
-  if (node.computed) { c(node.key, st, "Expression"); }
-  if (node.value) { c(node.value, st, "Expression"); }
-};
-
-const ArrowFunctionExpression$1 = 'ArrowFunctionExpression';
-const BinaryExpression$1 = 'BinaryExpression';
-const BlockStatement$1 = 'BlockStatement';
-const CallExpression$1 = 'CallExpression';
-const ChainExpression$1 = 'ChainExpression';
-const ConditionalExpression$1 = 'ConditionalExpression';
-const ExportDefaultDeclaration$1 = 'ExportDefaultDeclaration';
-const ExportNamedDeclaration$1 = 'ExportNamedDeclaration';
-const ExpressionStatement$1 = 'ExpressionStatement';
-const FunctionDeclaration$1 = 'FunctionDeclaration';
-const Identifier$1 = 'Identifier';
-const LogicalExpression$1 = 'LogicalExpression';
-const NewExpression$1 = 'NewExpression';
-const Program$1 = 'Program';
-const Property$1 = 'Property';
-const ReturnStatement$1 = 'ReturnStatement';
-const SequenceExpression$1 = 'SequenceExpression';
-const VariableDeclarator$1 = 'VariableDeclarator';
-const VariableDeclaration$1 = 'VariableDeclaration';
-
-// this looks ridiculous, but it prevents sourcemap tooling from mistaking
-// this for an actual sourceMappingURL
-let SOURCEMAPPING_URL = 'sourceMa';
-SOURCEMAPPING_URL += 'ppingURL';
-const whiteSpaceNoNewline = '[ \\f\\r\\t\\v\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]';
-const SOURCEMAPPING_URL_RE = new RegExp(`^#${whiteSpaceNoNewline}+${SOURCEMAPPING_URL}=.+`);
+const FIXED_STRINGS = [
+    'var',
+    'let',
+    'const',
+    'init',
+    'get',
+    'set',
+    'constructor',
+    'method',
+    '-',
+    '+',
+    '!',
+    '~',
+    'typeof',
+    'void',
+    'delete',
+    '++',
+    '--',
+    '==',
+    '!=',
+    '===',
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    '<<',
+    '>>',
+    '>>>',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '|',
+    '^',
+    '&',
+    '||',
+    '&&',
+    'in',
+    'instanceof',
+    '**',
+    '??',
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '<<=',
+    '>>=',
+    '>>>=',
+    '|=',
+    '^=',
+    '&=',
+    '**=',
+    '&&=',
+    '||=',
+    '??=',
+    'pure',
+    'noSideEffects'
+];
 
-const ANNOTATION_KEY = '_rollupAnnotations';
-const INVALID_COMMENT_KEY = '_rollupRemoved';
-function handlePureAnnotationsOfNode(node, state, type = node.type) {
-    const { annotations, code } = state;
-    // eslint-disable-next-line unicorn/consistent-destructuring
-    let comment = annotations[state.annotationIndex];
-    while (comment && node.start >= comment.end) {
-        markPureNode(node, comment, code);
-        comment = annotations[++state.annotationIndex];
-    }
-    if (comment && comment.end <= node.end) {
-        base$1[type](node, state, handlePureAnnotationsOfNode);
-        // eslint-disable-next-line unicorn/consistent-destructuring
-        while ((comment = annotations[state.annotationIndex]) && comment.end <= node.end) {
-            ++state.annotationIndex;
-            annotateNode(node, comment, false);
-        }
-    }
-}
-const neitherWithespaceNorBrackets = /[^\s(]/g;
-const noWhitespace = /\S/g;
-function markPureNode(node, comment, code) {
-    const annotatedNodes = [];
-    let invalidAnnotation;
-    const codeInBetween = code.slice(comment.end, node.start);
-    if (doesNotMatchOutsideComment(codeInBetween, neitherWithespaceNorBrackets)) {
-        const parentStart = node.start;
-        while (true) {
-            annotatedNodes.push(node);
-            switch (node.type) {
-                case ExpressionStatement$1:
-                case ChainExpression$1: {
-                    node = node.expression;
-                    continue;
-                }
-                case SequenceExpression$1: {
-                    // if there are parentheses, the annotation would apply to the entire expression
-                    if (doesNotMatchOutsideComment(code.slice(parentStart, node.start), noWhitespace)) {
-                        node = node.expressions[0];
-                        continue;
-                    }
-                    invalidAnnotation = true;
-                    break;
-                }
-                case ConditionalExpression$1: {
-                    // if there are parentheses, the annotation would apply to the entire expression
-                    if (doesNotMatchOutsideComment(code.slice(parentStart, node.start), noWhitespace)) {
-                        node = node.test;
-                        continue;
-                    }
-                    invalidAnnotation = true;
-                    break;
-                }
-                case LogicalExpression$1:
-                case BinaryExpression$1: {
-                    // if there are parentheses, the annotation would apply to the entire expression
-                    if (doesNotMatchOutsideComment(code.slice(parentStart, node.start), noWhitespace)) {
-                        node = node.left;
-                        continue;
-                    }
-                    invalidAnnotation = true;
-                    break;
-                }
-                case ExportNamedDeclaration$1:
-                case ExportDefaultDeclaration$1: {
-                    node = node.declaration;
-                    continue;
-                }
-                case VariableDeclaration$1: {
-                    
-                    const declaration = node;
-                    if (declaration.kind === 'const') {
-                        // jsdoc only applies to the first declaration
-                        node = declaration.declarations[0].init;
-                        continue;
-                    }
-                    invalidAnnotation = true;
-                    break;
-                }
-                case VariableDeclarator$1: {
-                    node = node.init;
-                    continue;
-                }
-                case FunctionDeclaration$1:
-                case ArrowFunctionExpression$1:
-                case CallExpression$1:
-                case NewExpression$1: {
-                    break;
-                }
-                default: {
-                    invalidAnnotation = true;
-                }
-            }
-            break;
-        }
-    }
-    else {
-        invalidAnnotation = true;
-    }
-    if (invalidAnnotation) {
-        annotateNode(node, comment, false);
-    }
-    else {
-        for (const node of annotatedNodes) {
-            annotateNode(node, comment, true);
-        }
-    }
-}
-function doesNotMatchOutsideComment(code, forbiddenChars) {
-    let nextMatch;
-    while ((nextMatch = forbiddenChars.exec(code)) !== null) {
-        if (nextMatch[0] === '/') {
-            const charCodeAfterSlash = code.charCodeAt(forbiddenChars.lastIndex);
-            if (charCodeAfterSlash === 42 /*"*"*/) {
-                forbiddenChars.lastIndex = code.indexOf('*/', forbiddenChars.lastIndex + 1) + 2;
-                continue;
-            }
-            else if (charCodeAfterSlash === 47 /*"/"*/) {
-                forbiddenChars.lastIndex = code.indexOf('\n', forbiddenChars.lastIndex + 1) + 1;
-                continue;
+const convertProgram = (buffer, readString) => convertNode(0, new Uint32Array(buffer), readString);
+const convertNode = (position, buffer, readString) => {
+    const nodeType = buffer[position];
+    const converter = nodeConverters[nodeType];
+    if (!converter) {
+        console.trace();
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+    return converter(position + 1, buffer, readString);
+};
+/* eslint-disable sort-keys */
+const nodeConverters = [
+    // index:0; ArrayExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const elements = convertNodeList(position, buffer, readString);
+        return {
+            type: 'ArrayExpression',
+            start,
+            end,
+            elements
+        };
+    },
+    // index:1; ArrayPattern
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const elements = convertNodeList(position, buffer, readString);
+        return {
+            type: 'ArrayPattern',
+            start,
+            end,
+            elements
+        };
+    },
+    // index:2; ArrowFunctionExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const async = !!buffer[position++];
+        const generator = !!buffer[position++];
+        const expression = !!buffer[position++];
+        const parameters = convertNodeList(buffer[position++], buffer, readString);
+        const body = convertNode(buffer[position++], buffer, readString);
+        const annotations = convertAnnotationList(position, buffer);
+        return {
+            type: 'ArrowFunctionExpression',
+            start,
+            end,
+            async,
+            body,
+            expression,
+            generator,
+            id: null,
+            params: parameters,
+            _rollupAnnotations: annotations
+        };
+    },
+    // index:3; AssignmentExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const operator = FIXED_STRINGS[buffer[position++]];
+        const right = convertNode(buffer[position++], buffer, readString);
+        const left = convertNode(position, buffer, readString);
+        return {
+            type: 'AssignmentExpression',
+            start,
+            end,
+            left,
+            operator,
+            right
+        };
+    },
+    // index:4; AssignmentPattern
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const right = convertNode(buffer[position++], buffer, readString);
+        const left = convertNode(position, buffer, readString);
+        return {
+            type: 'AssignmentPattern',
+            start,
+            end,
+            left,
+            right
+        };
+    },
+    // index:5; AwaitExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const argument = convertNode(position, buffer, readString);
+        return {
+            type: 'AwaitExpression',
+            start,
+            argument,
+            end
+        };
+    },
+    // index:6; BinaryExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const operator = FIXED_STRINGS[buffer[position++]];
+        const right = convertNode(buffer[position++], buffer, readString);
+        const left = convertNode(position, buffer, readString);
+        return {
+            type: 'BinaryExpression',
+            start,
+            end,
+            left,
+            operator,
+            right
+        };
+    },
+    // index:7; BlockStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const body = convertNodeList(position, buffer, readString);
+        return {
+            type: 'BlockStatement',
+            start,
+            body,
+            end
+        };
+    },
+    // index:8; BreakStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const labelPosition = buffer[position++];
+        return {
+            type: 'BreakStatement',
+            start,
+            end,
+            label: labelPosition ? convertNode(labelPosition, buffer, readString) : null
+        };
+    },
+    // index:9; CallExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const optional = !!buffer[position++];
+        const callee = convertNode(buffer[position++], buffer, readString);
+        const argumentsList = convertNodeList(buffer[position++], buffer, readString);
+        const annotations = convertAnnotationList(position, buffer);
+        return {
+            type: 'CallExpression',
+            start,
+            end,
+            arguments: argumentsList,
+            callee,
+            optional,
+            ...(annotations.length > 0 ? { _rollupAnnotations: annotations } : {})
+        };
+    },
+    // index:10; CatchClause
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const parameterPosition = buffer[position++];
+        const body = convertNode(buffer[position], buffer, readString);
+        return {
+            type: 'CatchClause',
+            start,
+            end,
+            body,
+            param: parameterPosition ? convertNode(parameterPosition, buffer, readString) : null
+        };
+    },
+    // index:11; ChainExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const expression = convertNode(position, buffer, readString);
+        return {
+            type: 'ChainExpression',
+            start,
+            end,
+            expression
+        };
+    },
+    // index:12; ClassBody
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const body = convertNodeList(position, buffer, readString);
+        return {
+            type: 'ClassBody',
+            start,
+            end,
+            body
+        };
+    },
+    // index:13; ClassDeclaration
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const idPosition = buffer[position++];
+        const superClassPosition = buffer[position++];
+        const body = convertNode(buffer[position], buffer, readString);
+        return {
+            type: 'ClassDeclaration',
+            start,
+            end,
+            body,
+            id: idPosition ? convertNode(idPosition, buffer, readString) : null,
+            superClass: superClassPosition ? convertNode(superClassPosition, buffer, readString) : null
+        };
+    },
+    // index:14; ClassExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const idPosition = buffer[position++];
+        const superClassPosition = buffer[position++];
+        const body = convertNode(buffer[position], buffer, readString);
+        return {
+            type: 'ClassExpression',
+            start,
+            end,
+            body,
+            id: idPosition ? convertNode(idPosition, buffer, readString) : null,
+            superClass: superClassPosition ? convertNode(superClassPosition, buffer, readString) : null
+        };
+    },
+    // index:15; ConditionalExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const consequent = convertNode(buffer[position++], buffer, readString);
+        const alternate = convertNode(buffer[position++], buffer, readString);
+        const test = convertNode(position, buffer, readString);
+        return {
+            type: 'ConditionalExpression',
+            start,
+            end,
+            alternate,
+            consequent,
+            test
+        };
+    },
+    // index:16; ContinueStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const labelPosition = buffer[position];
+        return {
+            type: 'ContinueStatement',
+            start,
+            end,
+            label: labelPosition ? convertNode(labelPosition, buffer, readString) : null
+        };
+    },
+    // index:17; DebuggerStatement
+    (position, buffer) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        return {
+            type: 'DebuggerStatement',
+            start,
+            end
+        };
+    },
+    // index:18; DoWhileStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const test = convertNode(buffer[position++], buffer, readString);
+        const body = convertNode(position, buffer, readString);
+        return {
+            type: 'DoWhileStatement',
+            start,
+            end,
+            body,
+            test
+        };
+    },
+    // index:19; EmptyStatement
+    (position, buffer) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        return {
+            type: 'EmptyStatement',
+            start,
+            end
+        };
+    },
+    // index:20; ExportAllDeclaration
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const exportedPosition = buffer[position++];
+        const source = convertNode(buffer[position++], buffer, readString);
+        const assertions = convertNodeList(buffer[position], buffer, readString);
+        return {
+            type: 'ExportAllDeclaration',
+            start,
+            end,
+            exported: exportedPosition ? convertNode(exportedPosition, buffer, readString) : null,
+            source,
+            ...(assertions.length > 0 ? { assertions } : {})
+        };
+    },
+    // index:21; ExportDefaultDeclaration
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const declaration = convertNode(position, buffer, readString);
+        return {
+            type: 'ExportDefaultDeclaration',
+            start,
+            end,
+            declaration
+        };
+    },
+    // index:22; ExportNamedDeclaration
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const declarationPosition = buffer[position++];
+        const sourcePosition = buffer[position++];
+        const assertions = convertNodeList(buffer[position++], buffer, readString);
+        const specifiers = convertNodeList(position, buffer, readString);
+        return {
+            type: 'ExportNamedDeclaration',
+            start,
+            end,
+            declaration: declarationPosition
+                ? convertNode(declarationPosition, buffer, readString)
+                : null,
+            source: sourcePosition ? convertNode(sourcePosition, buffer, readString) : null,
+            specifiers,
+            ...(assertions.length > 0 ? { assertions } : {})
+        };
+    },
+    // index:23; ExportSpecifier
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const exportedPosition = buffer[position++];
+        const local = convertNode(position, buffer, readString);
+        const exported = exportedPosition ? convertNode(exportedPosition, buffer, readString) : local;
+        return {
+            type: 'ExportSpecifier',
+            start,
+            end,
+            exported,
+            local
+        };
+    },
+    // index:24; ExpressionStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const directivePosition = buffer[position++];
+        const expression = convertNode(position, buffer, readString);
+        return {
+            type: 'ExpressionStatement',
+            start,
+            end,
+            expression,
+            ...(directivePosition
+                ? { directive: convertString(directivePosition, buffer, readString) }
+                : {})
+        };
+    },
+    // index:25; ForInStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const right = convertNode(buffer[position++], buffer, readString);
+        const body = convertNode(buffer[position++], buffer, readString);
+        const left = convertNode(position, buffer, readString);
+        return {
+            type: 'ForInStatement',
+            start,
+            end,
+            body,
+            left,
+            right
+        };
+    },
+    // index:26; ForOfStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const awaited = !!buffer[position++];
+        const right = convertNode(buffer[position++], buffer, readString);
+        const body = convertNode(buffer[position++], buffer, readString);
+        const left = convertNode(position, buffer, readString);
+        return {
+            type: 'ForOfStatement',
+            start,
+            end,
+            await: awaited,
+            body,
+            left,
+            right
+        };
+    },
+    // index:27; ForStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const initPosition = buffer[position++];
+        const testPosition = buffer[position++];
+        const updatePosition = buffer[position++];
+        const body = convertNode(buffer[position], buffer, readString);
+        return {
+            type: 'ForStatement',
+            start,
+            end,
+            body,
+            init: initPosition ? convertNode(initPosition, buffer, readString) : null,
+            test: testPosition ? convertNode(testPosition, buffer, readString) : null,
+            update: updatePosition ? convertNode(updatePosition, buffer, readString) : null
+        };
+    },
+    // index:28; FunctionDeclaration
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const async = !!buffer[position++];
+        const generator = !!buffer[position++];
+        const idPosition = buffer[position++];
+        const parameters = convertNodeList(buffer[position++], buffer, readString);
+        const body = convertNode(buffer[position++], buffer, readString);
+        const annotations = convertAnnotationList(position, buffer);
+        return {
+            type: 'FunctionDeclaration',
+            start,
+            end,
+            async,
+            body,
+            expression: false,
+            generator,
+            id: idPosition ? convertNode(idPosition, buffer, readString) : null,
+            params: parameters,
+            _rollupAnnotations: annotations
+        };
+    },
+    // index:29; FunctionExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const async = !!buffer[position++];
+        const generator = !!buffer[position++];
+        const idPosition = buffer[position++];
+        const parameters = convertNodeList(buffer[position++], buffer, readString);
+        const body = convertNode(buffer[position++], buffer, readString);
+        const annotations = convertAnnotationList(position, buffer);
+        return {
+            type: 'FunctionExpression',
+            start,
+            end,
+            async,
+            body,
+            expression: false,
+            generator,
+            id: idPosition ? convertNode(idPosition, buffer, readString) : null,
+            params: parameters,
+            _rollupAnnotations: annotations
+        };
+    },
+    // index:30; Identifier
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const name = convertString(position, buffer, readString);
+        return {
+            type: 'Identifier',
+            start,
+            end,
+            name
+        };
+    },
+    // index:31; IfStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const consequent = convertNode(buffer[position++], buffer, readString);
+        const alternatePosition = buffer[position++];
+        const test = convertNode(position, buffer, readString);
+        return {
+            type: 'IfStatement',
+            start,
+            end,
+            alternate: alternatePosition ? convertNode(alternatePosition, buffer, readString) : null,
+            consequent,
+            test
+        };
+    },
+    // index:32; ImportAttribute
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const value = convertNode(buffer[position++], buffer, readString);
+        const key = convertNode(position, buffer, readString);
+        return {
+            type: 'ImportAttribute',
+            start,
+            end,
+            key,
+            value
+        };
+    },
+    // index:33; ImportDeclaration
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const source = convertNode(buffer[position++], buffer, readString);
+        const assertions = convertNodeList(buffer[position++], buffer, readString);
+        const specifiers = convertNodeList(position, buffer, readString);
+        return {
+            type: 'ImportDeclaration',
+            start,
+            end,
+            source,
+            specifiers,
+            ...(assertions.length > 0 ? { assertions } : {})
+        };
+    },
+    // index:34; ImportDefaultSpecifier
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const local = convertNode(position, buffer, readString);
+        return {
+            type: 'ImportDefaultSpecifier',
+            start,
+            end,
+            local
+        };
+    },
+    // index:35; ImportExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const arguments_ = convertNodeList(buffer[position++], buffer, readString);
+        const source = convertNode(position, buffer, readString);
+        return {
+            type: 'ImportExpression',
+            start,
+            end,
+            source,
+            ...(arguments_.length > 0 ? { arguments: arguments_ } : {})
+        };
+    },
+    // index:36; ImportNamespaceSpecifier
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const local = convertNode(position, buffer, readString);
+        return {
+            type: 'ImportNamespaceSpecifier',
+            start,
+            end,
+            local
+        };
+    },
+    // index:37; ImportSpecifier
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const importedPosition = buffer[position++];
+        const local = convertNode(buffer[position], buffer, readString);
+        const imported = importedPosition ? convertNode(importedPosition, buffer, readString) : local;
+        return {
+            type: 'ImportSpecifier',
+            start,
+            end,
+            imported,
+            local
+        };
+    },
+    // index:38; LabeledStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const body = convertNode(buffer[position++], buffer, readString);
+        const label = convertNode(position, buffer, readString);
+        return {
+            type: 'LabeledStatement',
+            start,
+            end,
+            body,
+            label
+        };
+    },
+    // index:39; Literal<string>
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const rawPosition = buffer[position++];
+        const raw = rawPosition ? convertString(rawPosition, buffer, readString) : undefined;
+        const value = convertString(position, buffer, readString);
+        return {
+            type: 'Literal',
+            start,
+            end,
+            raw,
+            value
+        };
+    },
+    // index:40; Literal<boolean>
+    (position, buffer) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const value = !!buffer[position++];
+        return {
+            type: 'Literal',
+            start,
+            end,
+            raw: value ? 'true' : 'false',
+            value
+        };
+    },
+    // index:41; Literal<number>
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const rawPosition = buffer[position++];
+        const raw = rawPosition ? convertString(rawPosition, buffer, readString) : undefined;
+        const value = new DataView(buffer.buffer).getFloat64(position << 2, true);
+        return {
+            type: 'Literal',
+            start,
+            end,
+            raw,
+            value
+        };
+    },
+    // index:42; Literal<null>
+    (position, buffer) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        return {
+            type: 'Literal',
+            start,
+            end,
+            raw: 'null',
+            value: null
+        };
+    },
+    // index:43; Literal<RegExp>
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const pattern = convertString(buffer[position++], buffer, readString);
+        const flags = convertString(position, buffer, readString);
+        return {
+            type: 'Literal',
+            start,
+            end,
+            raw: `/${pattern}/${flags}`,
+            regex: {
+                flags,
+                pattern
+            },
+            value: new RegExp(pattern, flags)
+        };
+    },
+    // index:44; Literal<bigint>
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const bigint = convertString(buffer[position++], buffer, readString);
+        const raw = convertString(position, buffer, readString);
+        return {
+            type: 'Literal',
+            start,
+            end,
+            bigint,
+            raw,
+            value: BigInt(bigint)
+        };
+    },
+    // index:45; LogicalExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const operator = FIXED_STRINGS[buffer[position++]];
+        const right = convertNode(buffer[position++], buffer, readString);
+        const left = convertNode(position, buffer, readString);
+        return {
+            type: 'LogicalExpression',
+            start,
+            end,
+            left,
+            operator,
+            right
+        };
+    },
+    // index:46; MemberExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const optional = !!buffer[position++];
+        const computed = !!buffer[position++];
+        const property = convertNode(buffer[position++], buffer, readString);
+        const object = convertNode(position, buffer, readString);
+        return {
+            type: 'MemberExpression',
+            start,
+            end,
+            computed,
+            object,
+            optional,
+            property
+        };
+    },
+    // index:47; MetaProperty
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const property = convertNode(buffer[position++], buffer, readString);
+        const meta = convertNode(position, buffer, readString);
+        return {
+            type: 'MetaProperty',
+            start,
+            end,
+            meta,
+            property
+        };
+    },
+    // index:48; MethodDefinition
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const kind = FIXED_STRINGS[buffer[position++]];
+        const computed = !!buffer[position++];
+        const isStatic = !!buffer[position++];
+        const value = convertNode(buffer[position++], buffer, readString);
+        const key = convertNode(position, buffer, readString);
+        return {
+            type: 'MethodDefinition',
+            start,
+            end,
+            computed,
+            key,
+            kind,
+            static: isStatic,
+            value
+        };
+    },
+    // index:49; NewExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const callee = convertNode(buffer[position++], buffer, readString);
+        const argumentsPosition = buffer[position++];
+        const annotations = convertAnnotationList(position, buffer);
+        return {
+            type: 'NewExpression',
+            start,
+            end,
+            arguments: argumentsPosition ? convertNodeList(argumentsPosition, buffer, readString) : [],
+            callee,
+            ...(annotations.length > 0 ? { _rollupAnnotations: annotations } : {})
+        };
+    },
+    // index:50; ObjectExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const properties = convertNodeList(position, buffer, readString);
+        return {
+            type: 'ObjectExpression',
+            start,
+            end,
+            properties
+        };
+    },
+    // index:51; ObjectPattern
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const properties = convertNodeList(position, buffer, readString);
+        return {
+            type: 'ObjectPattern',
+            start,
+            end,
+            properties
+        };
+    },
+    // index:52; PrivateIdentifier
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const name = convertString(position, buffer, readString);
+        return {
+            type: 'PrivateIdentifier',
+            start,
+            end,
+            name
+        };
+    },
+    // index:53; Program
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const annotations = convertAnnotationList(buffer[position++], buffer);
+        const body = convertNodeList(position, buffer, readString);
+        return {
+            type: 'Program',
+            start,
+            end,
+            body,
+            sourceType: 'module',
+            ...(annotations.length > 0 ? { _rollupRemoved: annotations } : {})
+        };
+    },
+    // index:54; Property
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const kind = FIXED_STRINGS[buffer[position++]];
+        const method = !!buffer[position++];
+        const computed = !!buffer[position++];
+        const shorthand = !!buffer[position++];
+        const key = convertNode(buffer[position++], buffer, readString);
+        const valuePosition = buffer[position];
+        return {
+            type: 'Property',
+            start,
+            end,
+            computed,
+            key,
+            kind,
+            method,
+            shorthand,
+            value: valuePosition ? convertNode(valuePosition, buffer, readString) : key
+        };
+    },
+    // index:55; PropertyDefinition
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const computed = !!buffer[position++];
+        const isStatic = !!buffer[position++];
+        const valuePosition = buffer[position++];
+        const key = convertNode(position, buffer, readString);
+        return {
+            type: 'PropertyDefinition',
+            start,
+            end,
+            computed,
+            key,
+            static: isStatic,
+            value: valuePosition ? convertNode(valuePosition, buffer, readString) : null
+        };
+    },
+    // index:56; RestElement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const argument = convertNode(position, buffer, readString);
+        return {
+            type: 'RestElement',
+            start,
+            end,
+            argument
+        };
+    },
+    // index:57; ReturnStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const argumentPosition = buffer[position];
+        return {
+            type: 'ReturnStatement',
+            start,
+            end,
+            argument: argumentPosition ? convertNode(argumentPosition, buffer, readString) : null
+        };
+    },
+    // index:58; SequenceExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const expressions = convertNodeList(position, buffer, readString);
+        return {
+            type: 'SequenceExpression',
+            start,
+            end,
+            expressions
+        };
+    },
+    // index:59; SpreadElement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const argument = convertNode(position, buffer, readString);
+        return {
+            type: 'SpreadElement',
+            start,
+            end,
+            argument
+        };
+    },
+    // index:60; StaticBlock
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const body = convertNodeList(position, buffer, readString);
+        return {
+            type: 'StaticBlock',
+            start,
+            end,
+            body
+        };
+    },
+    // index:61; Super
+    (position, buffer) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        return {
+            type: 'Super',
+            start,
+            end
+        };
+    },
+    // index:62; SwitchCase
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const testPosition = buffer[position++];
+        const consequent = convertNodeList(buffer[position], buffer, readString);
+        return {
+            type: 'SwitchCase',
+            start,
+            end,
+            consequent,
+            test: testPosition ? convertNode(testPosition, buffer, readString) : null
+        };
+    },
+    // index:63; SwitchStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const cases = convertNodeList(buffer[position++], buffer, readString);
+        const discriminant = convertNode(position, buffer, readString);
+        return {
+            type: 'SwitchStatement',
+            start,
+            end,
+            cases,
+            discriminant
+        };
+    },
+    // index:64; TaggedTemplateExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const quasi = convertNode(buffer[position++], buffer, readString);
+        const tag = convertNode(position, buffer, readString);
+        return {
+            type: 'TaggedTemplateExpression',
+            start,
+            end,
+            quasi,
+            tag
+        };
+    },
+    // index:65; TemplateElement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const tail = !!buffer[position++];
+        const cookedPosition = buffer[position++];
+        const raw = convertString(position, buffer, readString);
+        return {
+            type: 'TemplateElement',
+            start,
+            end,
+            tail,
+            value: {
+                cooked: cookedPosition ? convertString(cookedPosition, buffer, readString) : null,
+                raw
             }
-        }
-        forbiddenChars.lastIndex = 0;
-        return false;
+        };
+    },
+    // index:66; TemplateLiteral
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const expressions = convertNodeList(buffer[position++], buffer, readString);
+        const quasis = convertNodeList(position, buffer, readString);
+        return {
+            type: 'TemplateLiteral',
+            start,
+            end,
+            expressions,
+            quasis
+        };
+    },
+    // index:67; ThisExpression
+    (position, buffer) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        return {
+            type: 'ThisExpression',
+            start,
+            end
+        };
+    },
+    // index:68; ThrowStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const argument = convertNode(position, buffer, readString);
+        return {
+            type: 'ThrowStatement',
+            start,
+            end,
+            argument
+        };
+    },
+    // index:69; TryStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const handlerPosition = buffer[position++];
+        const finalizerPosition = buffer[position++];
+        const block = convertNode(position, buffer, readString);
+        return {
+            type: 'TryStatement',
+            start,
+            end,
+            block,
+            finalizer: finalizerPosition ? convertNode(finalizerPosition, buffer, readString) : null,
+            handler: handlerPosition ? convertNode(handlerPosition, buffer, readString) : null
+        };
+    },
+    // index:70; UnaryExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const operator = FIXED_STRINGS[buffer[position++]];
+        const argument = convertNode(position, buffer, readString);
+        return {
+            type: 'UnaryExpression',
+            start,
+            end,
+            argument,
+            operator,
+            prefix: true
+        };
+    },
+    // index:71; UpdateExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const prefix = !!buffer[position++];
+        const operator = FIXED_STRINGS[buffer[position++]];
+        const argument = convertNode(position, buffer, readString);
+        return {
+            type: 'UpdateExpression',
+            start,
+            end,
+            argument,
+            operator,
+            prefix
+        };
+    },
+    // index:72; VariableDeclaration
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const kind = FIXED_STRINGS[buffer[position++]];
+        const declarations = convertNodeList(position, buffer, readString);
+        return {
+            type: 'VariableDeclaration',
+            start,
+            end,
+            declarations,
+            kind
+        };
+    },
+    // index:73; VariableDeclarator
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const init_position = buffer[position++];
+        const id = convertNode(position, buffer, readString);
+        return {
+            type: 'VariableDeclarator',
+            start,
+            end,
+            id,
+            init: init_position ? convertNode(init_position, buffer, readString) : null
+        };
+    },
+    // index:74; WhileStatement
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const body = convertNode(buffer[position++], buffer, readString);
+        const test = convertNode(position, buffer, readString);
+        return {
+            type: 'WhileStatement',
+            start,
+            end,
+            body,
+            test
+        };
+    },
+    // index:75; YieldExpression
+    (position, buffer, readString) => {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const delegate = !!buffer[position++];
+        const argumentPosition = buffer[position];
+        return {
+            type: 'YieldExpression',
+            start,
+            end,
+            argument: argumentPosition ? convertNode(argumentPosition, buffer, readString) : null,
+            delegate
+        };
+    },
+    // index:76; Syntax Error
+    (position, buffer, readString) => {
+        const pos = buffer[position++];
+        const message = convertString(position, buffer, readString);
+        error({
+            pos,
+            message
+        });
     }
-    return true;
-}
-const annotationsRegexes = [
-    ['pure', /[#@]__PURE__/],
-    ['noSideEffects', /[#@]__NO_SIDE_EFFECTS__/]
 ];
-function addAnnotations(comments, esTreeAst, code) {
-    const annotations = [];
-    const sourceMappingComments = [];
-    for (const comment of comments) {
-        for (const [annotationType, regex] of annotationsRegexes) {
-            if (regex.test(comment.value)) {
-                annotations.push({ ...comment, annotationType });
-            }
-        }
-        if (SOURCEMAPPING_URL_RE.test(comment.value)) {
-            sourceMappingComments.push(comment);
-        }
-    }
-    for (const comment of sourceMappingComments) {
-        annotateNode(esTreeAst, comment, false);
-    }
-    handlePureAnnotationsOfNode(esTreeAst, {
-        annotationIndex: 0,
-        annotations,
-        code
-    });
-}
-function annotateNode(node, comment, valid) {
-    const key = valid ? ANNOTATION_KEY : INVALID_COMMENT_KEY;
-    const property = node[key];
-    if (property) {
-        property.push(comment);
-    }
-    else {
-        node[key] = [comment];
-    }
-}
+const convertNodeList = (position, buffer, readString) => {
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        const nodePosition = buffer[position++];
+        list.push(nodePosition ? convertNode(nodePosition, buffer, readString) : null);
+    }
+    return list;
+};
+// TODO Lukas remove old annotation handling code
+const convertAnnotationList = (position, buffer) => {
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        list.push(convertAnnotation(buffer[position++], buffer));
+    }
+    return list;
+};
+const convertAnnotation = (position, buffer) => {
+    const start = buffer[position++];
+    const end = buffer[position++];
+    const type = FIXED_STRINGS[buffer[position]];
+    return { end, start, type };
+};
+const convertString = (position, buffer, readString) => {
+    const length = buffer[position++];
+    const bytePosition = position << 2;
+    return readString(bytePosition, length);
+};
+const ANNOTATION_KEY = '_rollupAnnotations';
+const INVALID_ANNOTATION_KEY = '_rollupRemoved';
 
 const keys = {
     // TODO this should be removed once ImportExpression follows official ESTree
@@ -5921,11 +6722,11 @@ class NodeBase extends ExpressionEntity {
                     const annotations = value;
                     this.annotations = annotations;
                     if (this.context.options.treeshake.annotations) {
-                        this.annotationNoSideEffects = annotations.some(comment => comment.annotationType === 'noSideEffects');
-                        this.annotationPure = annotations.some(comment => comment.annotationType === 'pure');
+                        this.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+                        this.annotationPure = annotations.some(comment => comment.type === 'pure');
                     }
                 }
-                else if (key === INVALID_COMMENT_KEY) {
+                else if (key === INVALID_ANNOTATION_KEY) {
                     for (const { start, end } of value)
                         this.context.magicString.remove(start, end);
                 }
@@ -5946,6 +6747,13 @@ class NodeBase extends ExpressionEntity {
             }
         }
     }
+    removeAnnotations(code) {
+        if (this.annotations) {
+            for (const annotation of this.annotations) {
+                code.remove(annotation.start, annotation.end);
+            }
+        }
+    }
     render(code, options) {
         for (const key of this.keys) {
             const value = this[key];
@@ -6705,6 +7513,15 @@ class ArrayPattern extends NodeBase {
     }
 }
 
+const ArrowFunctionExpression$1 = 'ArrowFunctionExpression';
+const BlockStatement$1 = 'BlockStatement';
+const CallExpression$1 = 'CallExpression';
+const ExpressionStatement$1 = 'ExpressionStatement';
+const Identifier$1 = 'Identifier';
+const Program$1 = 'Program';
+const Property$1 = 'Property';
+const ReturnStatement$1 = 'ReturnStatement';
+
 class LocalVariable extends Variable {
     constructor(name, declarator, init, context) {
         super(name);
@@ -8308,9 +9125,6 @@ class Identifier extends NodeBase {
         this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
     }
     deoptimizePath(path) {
-        if (path.length === 0 && !this.scope.contains(this.name)) {
-            this.disallowImportReassignment();
-        }
         // We keep conditional chaining because an unknown Node could have an
         // Identifier as property that might be deoptimized by default
         this.variable?.deoptimizePath(path);
@@ -8421,9 +9235,6 @@ class Identifier extends NodeBase {
             this.context.requestTreeshakingPass();
         }
     }
-    disallowImportReassignment() {
-        return this.context.error(logIllegalImportReassignment(this.name, this.context.module.id), this.start);
-    }
     getVariableRespectingTDZ() {
         if (this.isPossibleTDZ()) {
             return UNKNOWN_EXPRESSION;
@@ -8456,26 +9267,7 @@ function closestParentFunctionOrProgram(node) {
 
 function treeshakeNode(node, code, start, end) {
     code.remove(start, end);
-    if (node.annotations) {
-        for (const annotation of node.annotations) {
-            if (annotation.start < start) {
-                code.remove(annotation.start, annotation.end);
-            }
-            else {
-                return;
-            }
-        }
-    }
-}
-function removeAnnotations(node, code) {
-    if (!node.annotations && node.parent.type === ExpressionStatement$1) {
-        node = node.parent;
-    }
-    if (node.annotations) {
-        for (const annotation of node.annotations) {
-            code.remove(annotation.start, annotation.end);
-        }
-    }
+    node.removeAnnotations(code);
 }
 
 const NO_SEMICOLON = { isNoStatement: true };
@@ -8635,6 +9427,9 @@ class ExpressionStatement extends NodeBase {
             logModuleLevelDirective(this.directive, this.context.module.id), this.start);
         }
     }
+    removeAnnotations(code) {
+        this.expression.removeAnnotations(code);
+    }
     render(code, options) {
         super.render(code, options);
         if (this.included)
@@ -9319,6 +10114,9 @@ class BinaryExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, { type }) {
         return type !== INTERACTION_ACCESSED || path.length > 1;
     }
+    removeAnnotations(code) {
+        this.left.removeAnnotations(code);
+    }
     render(code, options, { renderedSurroundingElement } = BLANK) {
         this.left.render(code, options, { renderedSurroundingElement });
         this.right.render(code, options);
@@ -9956,6 +10754,9 @@ class ChainExpression extends NodeBase {
             return false;
         return this.expression.hasEffects(context);
     }
+    removeAnnotations(code) {
+        this.expression.removeAnnotations(code);
+    }
 }
 
 class ClassBodyScope extends ChildScope {
@@ -10376,6 +11177,9 @@ class ConditionalExpression extends NodeBase {
             this.alternate.includeCallArguments(context, parameters);
         }
     }
+    removeAnnotations(code) {
+        this.test.removeAnnotations(code);
+    }
     render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
         const usedBranch = this.getUsedBranch();
         if (this.test.included) {
@@ -10395,7 +11199,7 @@ class ConditionalExpression extends NodeBase {
             if (this.consequent.included) {
                 code.remove(colonPos, this.end);
             }
-            removeAnnotations(this, code);
+            this.test.removeAnnotations(code);
             usedBranch.render(code, options, {
                 isCalleeOfRenderedParent,
                 preventASI: true,
@@ -10545,6 +11349,9 @@ class ExportDefaultDeclaration extends NodeBase {
         this.variable = this.scope.addExportDefaultDeclaration(this.declarationName || this.context.getModuleName(), this, this.context);
         this.context.addExport(this);
     }
+    removeAnnotations(code) {
+        this.declaration.removeAnnotations(code);
+    }
     render(code, options, nodeRenderOptions) {
         const { start, end } = nodeRenderOptions;
         const declarationStart = getDeclarationStart(code.original, this.start);
@@ -10621,6 +11428,9 @@ class ExportNamedDeclaration extends NodeBase {
     initialise() {
         this.context.addExport(this);
     }
+    removeAnnotations(code) {
+        this.declaration?.removeAnnotations(code);
+    }
     render(code, options, nodeRenderOptions) {
         const { start, end } = nodeRenderOptions;
         if (this.declaration === null) {
@@ -11194,6 +12004,9 @@ class VariableDeclarator extends NodeBase {
             id.include(context, includeChildrenRecursively);
         }
     }
+    removeAnnotations(code) {
+        this.init?.removeAnnotations(code);
+    }
     render(code, options) {
         const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
         const { end, id, init, start } = this;
@@ -11652,6 +12465,9 @@ class LogicalExpression extends NodeBase {
             usedBranch.include(context, includeChildrenRecursively);
         }
     }
+    removeAnnotations(code) {
+        this.left.removeAnnotations(code);
+    }
     render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
         if (!this.left.included || !this.right.included) {
             const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
@@ -11661,11 +12477,11 @@ class LogicalExpression extends NodeBase {
                 if (preventASI) {
                     removeLineBreaks(code, removePos, this.right.start);
                 }
+                this.left.removeAnnotations(code);
             }
             else {
                 code.remove(operatorPos, this.end);
             }
-            removeAnnotations(this, code);
             this.getUsedBranch().render(code, options, {
                 isCalleeOfRenderedParent,
                 preventASI,
@@ -12126,6 +12942,9 @@ class SequenceExpression extends NodeBase {
                 expression.include(context, includeChildrenRecursively);
         }
     }
+    removeAnnotations(code) {
+        this.expressions[0].removeAnnotations(code);
+    }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
         let includedNodes = 0;
         let lastSeparatorPos = null;
@@ -12792,6 +13611,9 @@ class VariableDeclaration extends NodeBase {
             declarator.declareDeclarator(this.kind);
         }
     }
+    removeAnnotations(code) {
+        this.declarations[0].removeAnnotations(code);
+    }
     render(code, options, nodeRenderOptions = BLANK) {
         if (areAllDeclarationsIncludedAndNotExported(this.declarations, options.exportNamesByVariable)) {
             for (const declarator of this.declarations) {
@@ -17570,6 +18392,11 @@ function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain,
 
 const createHash = () => createHash$1('sha256');
 
+// this looks ridiculous, but it prevents sourcemap tooling from mistaking
+// this for an actual sourceMappingURL
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
+
 async function renderChunks(chunks, bundle, pluginDriver, outputOptions, log) {
     timeStart('render chunks', 2);
     reserveEntryChunksInBundle(chunks);
@@ -25537,6 +26364,27 @@ class Queue {
     }
 }
 
+function getReadStringFunction(astBuffer) {
+    let bufferConstructor = null;
+    try {
+        bufferConstructor = Buffer;
+    }
+    catch {
+        /* regardless of error */
+    }
+    if (bufferConstructor && astBuffer instanceof bufferConstructor) {
+        return function readString(start, length) {
+            return astBuffer.toString('utf8', start, start + length);
+        };
+    }
+    else {
+        const textDecoder = new TextDecoder();
+        return function readString(start, length) {
+            return textDecoder.decode(astBuffer.subarray(start, start + length));
+        };
+    }
+}
+
 function normalizeEntryModules(entryModules) {
     if (Array.isArray(entryModules)) {
         return entryModules.map(id => ({
@@ -25626,15 +26474,60 @@ class Graph {
                     return onCommentOrig.call(options, block, text, start, end, ...parameters);
                 }
                 : comments;
-        const ast = this.acornParser.parse(code, {
-            ...this.options.acorn,
-            ...options
-        });
+        // console.time('acorn');
+        // const acornAst = this.acornParser.parse(code, {
+        // 	...(this.options.acorn as unknown as acorn.Options),
+        // 	...options
+        // });
+        // console.timeEnd('acorn');
+        // console.log('acorn', JSON.stringify(acornAst, null, 2));
+        // let ast: acorn.Node;
+        // let astBuffer: Buffer;
+        // try {
+        // console.time('swc');
+        const astBuffer = native.parse(code);
+        const readString = getReadStringFunction(astBuffer);
+        const ast = convertProgram(astBuffer.buffer, (start, length) => readString(start, length));
+        // console.timeEnd('swc');
+        // console.log('swc', JSON.stringify(ast, null, 2));
+        // assert.deepStrictEqual(
+        // 	ast,
+        // 	JSON.parse(
+        // 		JSON.stringify(acornAst, (_, value) =>
+        // 			typeof value == 'bigint'
+        // 				? `~BigInt${value.toString()}`
+        // 				: value instanceof RegExp
+        // 				? `~RegExp${JSON.stringify({ flags: value.flags, source: value.source })}`
+        // 				: value
+        // 		),
+        // 		(_, value) =>
+        // 			typeof value === 'string'
+        // 				? value.startsWith('~BigInt')
+        // 					? BigInt(value.slice(7))
+        // 					: value.startsWith('~RegExp')
+        // 					? new RegExp(JSON.parse(value.slice(7)).source, JSON.parse(value.slice(7)).flags)
+        // 					: value
+        // 				: value
+        // 	)
+        // );
+        // } catch (error_) {
+        // console.log(JSON.stringify(code));
+        // console.log(
+        // 	'Size acorn:',
+        // 	JSON.stringify(acornAst).length,
+        // 	', swc:',
+        // 	astBuffer!.length,
+        // 	'code:',
+        // 	code.length
+        // );
+        // throw error_;
+        // }
         if (typeof onCommentOrig == 'object') {
             onCommentOrig.push(...comments);
         }
         options.onComment = onCommentOrig;
-        addAnnotations(comments, ast, code);
+        // TODO SWC do this in Rust
+        // addAnnotations(comments, ast!, code);
         return ast;
     }
     getCache() {
@@ -25793,6 +26686,8 @@ async function catchUnfinishedHookActions(pluginDriver, callback) {
     }
 }
 
+async function initWasm() { }
+
 function getLogger(plugins, onLog, watchMode, logLevel) {
     plugins = getSortedValidatedPlugins('onLog', plugins);
     const minimalPriority = logLevelPriority[logLevel];
@@ -26557,6 +27452,7 @@ function rollup(rawInputOptions) {
 async function rollupInternal(rawInputOptions, watcher) {
     const { options: inputOptions, unsetOptions: unsetInputOptions } = await getInputOptions(rawInputOptions, watcher !== null);
     initialiseTimers(inputOptions);
+    await initWasm();
     const graph = new Graph(inputOptions, watcher);
     // remove the cache object from the memory after graph creation (cache is not used anymore)
     const useCache = rawInputOptions.cache !== false;