@rollup/wasm-node 4.18.0 → 4.19.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.18.0
-	Wed, 22 May 2024 05:03:09 GMT - commit bb6f069ea3623b0297ef3895f2dcb98a2ca5ef58
+	Rollup.js v4.19.0
+	Sat, 20 Jul 2024 05:45:44 GMT - commit 28546b5821efcb72c2eb05f422d986524647a0e3
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.18.0";
+var version = "4.19.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -1500,6 +1500,42 @@ for (let i = 0; i < chars.length; i++) {
     intToChar[i] = c;
     charToInt[c] = i;
 }
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
+}
+
+const bufLength = 1024 * 16;
 // Provide a fallback for older environments.
 const td = typeof TextDecoder !== 'undefined'
     ? /* #__PURE__ */ new TextDecoder()
@@ -1519,74 +1555,89 @@ const td = typeof TextDecoder !== 'undefined'
                 return out;
             },
         };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
+    }
+}
+
 function decode(mappings) {
-    const state = new Int32Array(5);
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
     const decoded = [];
-    let index = 0;
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     do {
-        const semi = indexOf(mappings, index);
+        const semi = reader.indexOf(';');
         const line = [];
         let sorted = true;
         let lastCol = 0;
-        state[0] = 0;
-        for (let i = index; i < semi; i++) {
+        genColumn = 0;
+        while (reader.pos < semi) {
             let seg;
-            i = decodeInteger(mappings, i, state, 0); // genColumn
-            const col = state[0];
-            if (col < lastCol)
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
                 sorted = false;
-            lastCol = col;
-            if (hasMoreVlq(mappings, i, semi)) {
-                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
-                i = decodeInteger(mappings, i, state, 2); // sourceLine
-                i = decodeInteger(mappings, i, state, 3); // sourceColumn
-                if (hasMoreVlq(mappings, i, semi)) {
-                    i = decodeInteger(mappings, i, state, 4); // namesIndex
-                    seg = [col, state[1], state[2], state[3], state[4]];
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
                 }
                 else {
-                    seg = [col, state[1], state[2], state[3]];
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
                 }
             }
             else {
-                seg = [col];
+                seg = [genColumn];
             }
             line.push(seg);
+            reader.pos++;
         }
         if (!sorted)
             sort(line);
         decoded.push(line);
-        index = semi + 1;
-    } while (index <= mappings.length);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
     return decoded;
 }
-function indexOf(mappings, index) {
-    const idx = mappings.indexOf(';', index);
-    return idx === -1 ? mappings.length : idx;
-}
-function decodeInteger(mappings, pos, state, j) {
-    let value = 0;
-    let shift = 0;
-    let integer = 0;
-    do {
-        const c = mappings.charCodeAt(pos++);
-        integer = charToInt[c];
-        value |= (integer & 31) << shift;
-        shift += 5;
-    } while (integer & 32);
-    const shouldNegate = value & 1;
-    value >>>= 1;
-    if (shouldNegate) {
-        value = -0x80000000 | -value;
-    }
-    state[j] += value;
-    return pos;
-}
-function hasMoreVlq(mappings, i, length) {
-    if (i >= length)
-        return false;
-    return mappings.charCodeAt(i) !== comma;
-}
 function sort(line) {
     line.sort(sortComparator);
 }
@@ -1594,62 +1645,34 @@ function sortComparator(a, b) {
     return a[0] - b[0];
 }
 function encode(decoded) {
-    const state = new Int32Array(5);
-    const bufLength = 1024 * 16;
-    const subLength = bufLength - 36;
-    const buf = new Uint8Array(bufLength);
-    const sub = buf.subarray(0, subLength);
-    let pos = 0;
-    let out = '';
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     for (let i = 0; i < decoded.length; i++) {
         const line = decoded[i];
-        if (i > 0) {
-            if (pos === bufLength) {
-                out += td.decode(buf);
-                pos = 0;
-            }
-            buf[pos++] = semicolon;
-        }
+        if (i > 0)
+            writer.write(semicolon);
         if (line.length === 0)
             continue;
-        state[0] = 0;
+        let genColumn = 0;
         for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            // We can push up to 5 ints, each int can take at most 7 chars, and we
-            // may push a comma.
-            if (pos > subLength) {
-                out += td.decode(sub);
-                buf.copyWithin(0, subLength, pos);
-                pos -= subLength;
-            }
             if (j > 0)
-                buf[pos++] = comma;
-            pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
-            pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
-            pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
         }
     }
-    return out + td.decode(buf.subarray(0, pos));
-}
-function encodeInteger(buf, pos, state, segment, j) {
-    const next = segment[j];
-    let num = next - state[j];
-    state[j] = next;
-    num = num < 0 ? (-num << 1) | 1 : num << 1;
-    do {
-        let clamped = num & 0b011111;
-        num >>>= 5;
-        if (num > 0)
-            clamped |= 0b100000;
-        buf[pos++] = intToChar[clamped];
-    } while (num > 0);
-    return pos;
+    return writer.flush();
 }
 
 class BitSet {
@@ -6132,11 +6155,12 @@ const childNodeKeys = {
     CatchClause: ['param', 'body'],
     ChainExpression: ['expression'],
     ClassBody: ['body'],
-    ClassDeclaration: ['id', 'superClass', 'body'],
-    ClassExpression: ['id', 'superClass', 'body'],
+    ClassDeclaration: ['decorators', 'id', 'superClass', 'body'],
+    ClassExpression: ['decorators', 'id', 'superClass', 'body'],
     ConditionalExpression: ['test', 'consequent', 'alternate'],
     ContinueStatement: ['label'],
     DebuggerStatement: [],
+    Decorator: ['expression'],
     DoWhileStatement: ['body', 'test'],
     EmptyStatement: [],
     ExportAllDeclaration: ['exported', 'source', 'attributes'],
@@ -6162,7 +6186,7 @@ const childNodeKeys = {
     LogicalExpression: ['left', 'right'],
     MemberExpression: ['object', 'property'],
     MetaProperty: ['meta', 'property'],
-    MethodDefinition: ['key', 'value'],
+    MethodDefinition: ['decorators', 'key', 'value'],
     NewExpression: ['callee', 'arguments'],
     ObjectExpression: ['properties'],
     ObjectPattern: ['properties'],
@@ -6171,7 +6195,7 @@ const childNodeKeys = {
     PrivateIdentifier: [],
     Program: ['body'],
     Property: ['key', 'value'],
-    PropertyDefinition: ['key', 'value'],
+    PropertyDefinition: ['decorators', 'key', 'value'],
     RestElement: ['argument'],
     ReturnStatement: ['argument'],
     SequenceExpression: ['expressions'],
@@ -6656,10 +6680,10 @@ class ObjectEntity extends ExpressionEntity {
         }
         const key = path[0];
         if (path.length === 1) {
-            if (typeof key !== 'string') {
-                if (key === UnknownInteger) {
-                    return this.deoptimizeIntegerProperties();
-                }
+            if (key === UnknownInteger) {
+                return this.deoptimizeIntegerProperties();
+            }
+            else if (typeof key !== 'string') {
                 return this.deoptimizeAllProperties(key === UnknownNonAccessorKey);
             }
             if (!this.deoptimizedPaths[key]) {
@@ -10727,6 +10751,15 @@ class ClassBody extends NodeBase {
     applyDeoptimizations() { }
 }
 
+function checkEffectForNodes(nodes, context) {
+    for (const node of nodes) {
+        if (node.hasEffects(context)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 class MethodBase extends NodeBase {
     constructor() {
         super(...arguments);
@@ -10804,9 +10837,44 @@ class MethodBase extends NodeBase {
 }
 
 class MethodDefinition extends MethodBase {
+    hasEffects(context) {
+        return super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
     applyDeoptimizations() { }
 }
 
+class StaticBlock extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        for (const node of this.body) {
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        for (const node of this.body) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                node.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options) {
+        if (this.body.length > 0) {
+            const bodyStartPos = findFirstOccurrenceOutsideComment(code.original.slice(this.start, this.end), '{') + 1;
+            renderStatementList(this.body, code, this.start + bodyStartPos, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+function isStaticBlock(statement) {
+    return statement.type === parseAst_js.StaticBlock;
+}
+
 class ObjectMember extends ExpressionEntity {
     constructor(object, key) {
         super();
@@ -10858,7 +10926,7 @@ class ClassNode extends NodeBase {
             this.applyDeoptimizations();
         const initEffect = this.superClass?.hasEffects(context) || this.body.hasEffects(context);
         this.id?.markDeclarationReached();
-        return initEffect || super.hasEffects(context);
+        return initEffect || super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return interaction.type === INTERACTION_CALLED && path.length === 0
@@ -10875,6 +10943,8 @@ class ClassNode extends NodeBase {
         this.included = true;
         this.superClass?.include(context, includeChildrenRecursively);
         this.body.include(context, includeChildrenRecursively);
+        for (const decorator of this.decorators)
+            decorator.include(context, includeChildrenRecursively);
         if (this.id) {
             this.id.markDeclarationReached();
             this.id.include();
@@ -10894,8 +10964,9 @@ class ClassNode extends NodeBase {
     applyDeoptimizations() {
         this.deoptimized = true;
         for (const definition of this.body.body) {
-            if (!(definition.static ||
-                (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
+            if (!isStaticBlock(definition) &&
+                !(definition.static ||
+                    (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
                 // Calls to methods are not tracked, ensure that the return value is deoptimized
                 definition.deoptimizePath(UNKNOWN_PATH);
             }
@@ -10909,6 +10980,8 @@ class ClassNode extends NodeBase {
         const staticProperties = [];
         const dynamicMethods = [];
         for (const definition of this.body.body) {
+            if (isStaticBlock(definition))
+                continue;
             const properties = definition.static ? staticProperties : dynamicMethods;
             const definitionKind = definition.kind;
             // Note that class fields do not end up on the prototype
@@ -10965,6 +11038,7 @@ class ClassDeclaration extends ClassNode {
             }
             const renderedVariable = variable.getName(getPropertyAccess);
             if (renderedVariable !== name) {
+                this.decorators.map(decorator => decorator.render(code, options));
                 this.superClass?.render(code, options);
                 this.body.render(code, {
                     ...options,
@@ -11200,6 +11274,13 @@ class DebuggerStatement extends NodeBase {
     }
 }
 
+class Decorator extends NodeBase {
+    hasEffects(context) {
+        return (this.expression.hasEffects(context) ||
+            this.expression.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context));
+    }
+}
+
 function hasLoopBodyEffects(context, body) {
     const { brokenFlow, hasBreak, hasContinue, ignore } = context;
     const { breaks, continues } = ignore;
@@ -12452,8 +12533,8 @@ class LogicalExpression extends NodeBase {
     }
     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) {
+                const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
                 const removePos = findNonWhiteSpace(code.original, operatorPos + 2);
                 code.remove(this.start, removePos);
                 if (preventASI) {
@@ -12462,7 +12543,7 @@ class LogicalExpression extends NodeBase {
                 this.left.removeAnnotations(code);
             }
             else {
-                code.remove(operatorPos, this.end);
+                code.remove(this.left.end, this.end);
             }
             this.getUsedBranch().render(code, options, {
                 isCalleeOfRenderedParent,
@@ -12922,7 +13003,9 @@ class PropertyDefinition extends NodeBase {
             : UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffects(context) {
-        return this.key.hasEffects(context) || (this.static && !!this.value?.hasEffects(context));
+        return (this.key.hasEffects(context) ||
+            (this.static && !!this.value?.hasEffects(context)) ||
+            checkEffectForNodes(this.decorators, context));
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return !this.value || this.value.hasEffectsOnInteractionAtPath(path, interaction, context);
@@ -13021,35 +13104,6 @@ class SequenceExpression extends NodeBase {
     }
 }
 
-class StaticBlock extends NodeBase {
-    createScope(parentScope) {
-        this.scope = new BlockScope(parentScope);
-    }
-    hasEffects(context) {
-        for (const node of this.body) {
-            if (node.hasEffects(context))
-                return true;
-        }
-        return false;
-    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        for (const node of this.body) {
-            if (includeChildrenRecursively || node.shouldBeIncluded(context))
-                node.include(context, includeChildrenRecursively);
-        }
-    }
-    render(code, options) {
-        if (this.body.length > 0) {
-            const bodyStartPos = findFirstOccurrenceOutsideComment(code.original.slice(this.start, this.end), '{') + 1;
-            renderStatementList(this.body, code, this.start + bodyStartPos, this.end - 1, options);
-        }
-        else {
-            super.render(code, options);
-        }
-    }
-}
-
 class Super extends NodeBase {
     bind() {
         this.variable = this.scope.findVariable('this');
@@ -13838,7 +13892,7 @@ class YieldExpression extends NodeBase {
 // 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));
+    return convertNode(parent, parentScope, 0, parseAst_js.getAstBuffer(buffer));
 }
 const nodeTypeStrings = [
     'PanicError',
@@ -13861,6 +13915,7 @@ const nodeTypeStrings = [
     'ConditionalExpression',
     'ContinueStatement',
     'DebuggerStatement',
+    'Decorator',
     'ExpressionStatement',
     'DoWhileStatement',
     'EmptyStatement',
@@ -13942,6 +13997,7 @@ const nodeConstructors$1 = [
     ConditionalExpression,
     ContinueStatement,
     DebuggerStatement,
+    Decorator,
     ExpressionStatement,
     DoWhileStatement,
     EmptyStatement,
@@ -14003,21 +14059,21 @@ const nodeConstructors$1 = [
     YieldExpression
 ];
 const bufferParsers = [
-    function panicError(node, position, buffer, readString) {
-        node.message = parseAst_js.convertString(buffer[position], buffer, readString);
+    function panicError(node, position, buffer) {
+        node.message = buffer.convertString(buffer[position]);
     },
-    function parseError(node, position, buffer, readString) {
-        node.message = parseAst_js.convertString(buffer[position], buffer, readString);
+    function parseError(node, position, buffer) {
+        node.message = buffer.convertString(buffer[position]);
     },
-    function arrayExpression(node, position, buffer, readString) {
+    function arrayExpression(node, position, buffer) {
         const { scope } = node;
-        node.elements = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.elements = convertNodeList(node, scope, buffer[position], buffer);
     },
-    function arrayPattern(node, position, buffer, readString) {
+    function arrayPattern(node, position, buffer) {
         const { scope } = node;
-        node.elements = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.elements = convertNodeList(node, scope, buffer[position], buffer);
     },
-    function arrowFunctionExpression(node, position, buffer, readString) {
+    function arrowFunctionExpression(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.async = (flags & 1) === 1;
@@ -14025,64 +14081,61 @@ const bufferParsers = [
         node.generator = (flags & 4) === 4;
         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));
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer));
         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);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 3], buffer);
     },
-    function assignmentExpression(node, position, buffer, readString) {
+    function assignmentExpression(node, position, buffer) {
         const { scope } = node;
         node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
-        node.left = convertNode(node, scope, buffer[position + 1], buffer, readString);
-        node.right = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
     },
-    function assignmentPattern(node, position, buffer, readString) {
+    function assignmentPattern(node, position, buffer) {
         const { scope } = node;
-        node.left = convertNode(node, scope, buffer[position], buffer, readString);
-        node.right = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.left = convertNode(node, scope, buffer[position], buffer);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function awaitExpression(node, position, buffer, readString) {
+    function awaitExpression(node, position, buffer) {
         const { scope } = node;
-        node.argument = convertNode(node, scope, buffer[position], buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position], buffer);
     },
-    function binaryExpression(node, position, buffer, readString) {
+    function binaryExpression(node, position, buffer) {
         const { scope } = node;
         node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
-        node.left = convertNode(node, scope, buffer[position + 1], buffer, readString);
-        node.right = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
     },
-    function blockStatement(node, position, buffer, readString) {
+    function blockStatement(node, position, buffer) {
         const { scope } = node;
-        node.body = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
     },
-    function breakStatement(node, position, buffer, readString) {
+    function breakStatement(node, position, buffer) {
         const { scope } = node;
         const labelPosition = buffer[position];
-        node.label =
-            labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer, readString);
+        node.label = labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer);
     },
-    function callExpression(node, position, buffer, readString) {
+    function callExpression(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.optional = (flags & 1) === 1;
         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);
+        node.callee = convertNode(node, scope, buffer[position + 2], buffer);
+        node.arguments = convertNodeList(node, scope, buffer[position + 3], buffer);
     },
-    function catchClause(node, position, buffer, readString) {
+    function catchClause(node, position, buffer) {
         const { scope } = node;
         const parameterPosition = buffer[position];
         const parameter = (node.param =
-            parameterPosition === 0
-                ? null
-                : convertNode(node, scope, parameterPosition, buffer, readString));
+            parameterPosition === 0 ? null : convertNode(node, scope, parameterPosition, buffer));
         parameter?.declare('parameter', UNKNOWN_EXPRESSION);
-        node.body = convertNode(node, scope.bodyScope, buffer[position + 1], buffer, readString);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 1], buffer);
     },
-    function chainExpression(node, position, buffer, readString) {
+    function chainExpression(node, position, buffer) {
         const { scope } = node;
-        node.expression = convertNode(node, scope, buffer[position], buffer, readString);
+        node.expression = convertNode(node, scope, buffer[position], buffer);
     },
-    function classBody(node, position, buffer, readString) {
+    function classBody(node, position, buffer) {
         const { scope } = node;
         const bodyPosition = buffer[position];
         const body = (node.body = []);
@@ -14090,127 +14143,116 @@ const bufferParsers = [
             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));
+                body.push(convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer));
             }
         }
     },
-    function classDeclaration(node, position, buffer, readString) {
+    function classDeclaration(node, position, buffer) {
         const { scope } = node;
-        const idPosition = buffer[position];
+        node.decorators = convertNodeList(node, scope, buffer[position], buffer);
+        const idPosition = buffer[position + 1];
         node.id =
-            idPosition === 0
-                ? null
-                : convertNode(node, scope.parent, idPosition, buffer, readString);
-        const superClassPosition = buffer[position + 1];
+            idPosition === 0 ? null : convertNode(node, scope.parent, idPosition, buffer);
+        const superClassPosition = buffer[position + 2];
         node.superClass =
-            superClassPosition === 0
-                ? null
-                : convertNode(node, scope, superClassPosition, buffer, readString);
-        node.body = convertNode(node, scope, buffer[position + 2], buffer, readString);
+            superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
     },
-    function classExpression(node, position, buffer, readString) {
+    function classExpression(node, position, buffer) {
         const { scope } = node;
-        const idPosition = buffer[position];
-        node.id = idPosition === 0 ? null : convertNode(node, scope, idPosition, buffer, readString);
-        const superClassPosition = buffer[position + 1];
+        node.decorators = convertNodeList(node, scope, buffer[position], buffer);
+        const idPosition = buffer[position + 1];
+        node.id = idPosition === 0 ? null : convertNode(node, scope, idPosition, buffer);
+        const superClassPosition = buffer[position + 2];
         node.superClass =
-            superClassPosition === 0
-                ? null
-                : convertNode(node, scope, superClassPosition, buffer, readString);
-        node.body = convertNode(node, scope, buffer[position + 2], buffer, readString);
+            superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
     },
-    function conditionalExpression(node, position, buffer, readString) {
+    function conditionalExpression(node, position, buffer) {
         const { scope } = node;
-        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);
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.consequent = convertNode(node, scope, buffer[position + 1], buffer);
+        node.alternate = convertNode(node, scope, buffer[position + 2], buffer);
     },
-    function continueStatement(node, position, buffer, readString) {
+    function continueStatement(node, position, buffer) {
         const { scope } = node;
         const labelPosition = buffer[position];
-        node.label =
-            labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer, readString);
+        node.label = labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer);
     },
     function debuggerStatement() { },
-    function directive(node, position, buffer, readString) {
+    function decorator(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function directive(node, position, buffer) {
         const { scope } = node;
-        node.directive = parseAst_js.convertString(buffer[position], buffer, readString);
-        node.expression = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.directive = buffer.convertString(buffer[position]);
+        node.expression = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function doWhileStatement(node, position, buffer, readString) {
+    function doWhileStatement(node, position, buffer) {
         const { scope } = node;
-        node.body = convertNode(node, scope, buffer[position], buffer, readString);
-        node.test = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.body = convertNode(node, scope, buffer[position], buffer);
+        node.test = convertNode(node, scope, buffer[position + 1], buffer);
     },
     function emptyStatement() { },
-    function exportAllDeclaration(node, position, buffer, readString) {
+    function exportAllDeclaration(node, position, buffer) {
         const { scope } = node;
         const exportedPosition = buffer[position];
         node.exported =
-            exportedPosition === 0
-                ? null
-                : convertNode(node, scope, exportedPosition, buffer, readString);
-        node.source = convertNode(node, scope, buffer[position + 1], buffer, readString);
-        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer, readString);
+            exportedPosition === 0 ? null : convertNode(node, scope, exportedPosition, buffer);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
     },
-    function exportDefaultDeclaration(node, position, buffer, readString) {
+    function exportDefaultDeclaration(node, position, buffer) {
         const { scope } = node;
-        node.declaration = convertNode(node, scope, buffer[position], buffer, readString);
+        node.declaration = convertNode(node, scope, buffer[position], buffer);
     },
-    function exportNamedDeclaration(node, position, buffer, readString) {
+    function exportNamedDeclaration(node, position, buffer) {
         const { scope } = node;
-        node.specifiers = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer);
         const sourcePosition = buffer[position + 1];
-        node.source =
-            sourcePosition === 0 ? null : convertNode(node, scope, sourcePosition, buffer, readString);
-        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer, readString);
+        node.source = sourcePosition === 0 ? null : convertNode(node, scope, sourcePosition, buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
         const declarationPosition = buffer[position + 3];
         node.declaration =
-            declarationPosition === 0
-                ? null
-                : convertNode(node, scope, declarationPosition, buffer, readString);
+            declarationPosition === 0 ? null : convertNode(node, scope, declarationPosition, buffer);
     },
-    function exportSpecifier(node, position, buffer, readString) {
+    function exportSpecifier(node, position, buffer) {
         const { scope } = node;
-        node.local = convertNode(node, scope, buffer[position], buffer, readString);
+        node.local = convertNode(node, scope, buffer[position], buffer);
         const exportedPosition = buffer[position + 1];
         node.exported =
-            exportedPosition === 0
-                ? node.local
-                : convertNode(node, scope, exportedPosition, buffer, readString);
+            exportedPosition === 0 ? node.local : convertNode(node, scope, exportedPosition, buffer);
     },
-    function expressionStatement(node, position, buffer, readString) {
+    function expressionStatement(node, position, buffer) {
         const { scope } = node;
-        node.expression = convertNode(node, scope, buffer[position], buffer, readString);
+        node.expression = convertNode(node, scope, buffer[position], buffer);
     },
-    function forInStatement(node, position, buffer, readString) {
+    function forInStatement(node, position, buffer) {
         const { scope } = node;
-        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);
+        node.left = convertNode(node, scope, buffer[position], buffer);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer);
+        node.body = convertNode(node, scope, buffer[position + 2], buffer);
     },
-    function forOfStatement(node, position, buffer, readString) {
+    function forOfStatement(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.await = (flags & 1) === 1;
-        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);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
     },
-    function forStatement(node, position, buffer, readString) {
+    function forStatement(node, position, buffer) {
         const { scope } = node;
         const initPosition = buffer[position];
-        node.init =
-            initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer, readString);
+        node.init = initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer);
         const testPosition = buffer[position + 1];
-        node.test =
-            testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer, readString);
+        node.test = testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer);
         const updatePosition = buffer[position + 2];
-        node.update =
-            updatePosition === 0 ? null : convertNode(node, scope, updatePosition, buffer, readString);
-        node.body = convertNode(node, scope, buffer[position + 3], buffer, readString);
+        node.update = updatePosition === 0 ? null : convertNode(node, scope, updatePosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
     },
-    function functionDeclaration(node, position, buffer, readString) {
+    function functionDeclaration(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.async = (flags & 1) === 1;
@@ -14219,14 +14261,12 @@ const bufferParsers = [
         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 + 3], buffer, readString));
+            idPosition === 0 ? null : convertNode(node, scope.parent, idPosition, buffer);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
         scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
-        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer, readString);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
     },
-    function functionExpression(node, position, buffer, readString) {
+    function functionExpression(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.async = (flags & 1) === 1;
@@ -14234,69 +14274,65 @@ const bufferParsers = [
         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 + 3], buffer, readString));
+        node.id = idPosition === 0 ? null : convertNode(node, node.idScope, idPosition, buffer);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
         scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
-        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer, readString);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
     },
-    function identifier(node, position, buffer, readString) {
-        node.name = parseAst_js.convertString(buffer[position], buffer, readString);
+    function identifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
     },
-    function ifStatement(node, position, buffer, readString) {
+    function ifStatement(node, position, buffer) {
         const { scope } = node;
-        node.test = convertNode(node, scope, buffer[position], buffer, readString);
-        node.consequent = convertNode(node, (node.consequentScope = new TrackingScope(scope)), buffer[position + 1], buffer, readString);
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.consequent = convertNode(node, (node.consequentScope = new TrackingScope(scope)), buffer[position + 1], buffer);
         const alternatePosition = buffer[position + 2];
         node.alternate =
             alternatePosition === 0
                 ? null
-                : convertNode(node, (node.alternateScope = new TrackingScope(scope)), alternatePosition, buffer, readString);
+                : convertNode(node, (node.alternateScope = new TrackingScope(scope)), alternatePosition, buffer);
     },
-    function importAttribute(node, position, buffer, readString) {
+    function importAttribute(node, position, buffer) {
         const { scope } = node;
-        node.key = convertNode(node, scope, buffer[position], buffer, readString);
-        node.value = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.key = convertNode(node, scope, buffer[position], buffer);
+        node.value = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function importDeclaration(node, position, buffer, readString) {
+    function importDeclaration(node, position, buffer) {
         const { scope } = node;
-        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);
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
     },
-    function importDefaultSpecifier(node, position, buffer, readString) {
+    function importDefaultSpecifier(node, position, buffer) {
         const { scope } = node;
-        node.local = convertNode(node, scope, buffer[position], buffer, readString);
+        node.local = convertNode(node, scope, buffer[position], buffer);
     },
-    function importExpression(node, position, buffer, readString) {
+    function importExpression(node, position, buffer) {
         const { scope } = node;
-        node.source = convertNode(node, scope, buffer[position], buffer, readString);
-        node.sourceAstNode = parseAst_js.convertNode(buffer[position], buffer, readString);
+        node.source = convertNode(node, scope, buffer[position], buffer);
+        node.sourceAstNode = parseAst_js.convertNode(buffer[position], buffer);
         const optionsPosition = buffer[position + 1];
-        node.options =
-            optionsPosition === 0 ? null : convertNode(node, scope, optionsPosition, buffer, readString);
+        node.options = optionsPosition === 0 ? null : convertNode(node, scope, optionsPosition, buffer);
     },
-    function importNamespaceSpecifier(node, position, buffer, readString) {
+    function importNamespaceSpecifier(node, position, buffer) {
         const { scope } = node;
-        node.local = convertNode(node, scope, buffer[position], buffer, readString);
+        node.local = convertNode(node, scope, buffer[position], buffer);
     },
-    function importSpecifier(node, position, buffer, readString) {
+    function importSpecifier(node, position, buffer) {
         const { scope } = node;
         const importedPosition = buffer[position];
-        node.local = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.local = convertNode(node, scope, buffer[position + 1], buffer);
         node.imported =
-            importedPosition === 0
-                ? node.local
-                : convertNode(node, scope, importedPosition, buffer, readString);
+            importedPosition === 0 ? node.local : convertNode(node, scope, importedPosition, buffer);
     },
-    function labeledStatement(node, position, buffer, readString) {
+    function labeledStatement(node, position, buffer) {
         const { scope } = node;
-        node.label = convertNode(node, scope, buffer[position], buffer, readString);
-        node.body = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.label = convertNode(node, scope, buffer[position], buffer);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function literalBigInt(node, position, buffer, readString) {
-        const bigint = (node.bigint = parseAst_js.convertString(buffer[position], buffer, readString));
-        node.raw = parseAst_js.convertString(buffer[position + 1], buffer, readString);
+    function literalBigInt(node, position, buffer) {
+        const bigint = (node.bigint = buffer.convertString(buffer[position]));
+        node.raw = buffer.convertString(buffer[position + 1]);
         node.value = BigInt(bigint);
     },
     function literalBoolean(node, position, buffer) {
@@ -14307,208 +14343,199 @@ const bufferParsers = [
     function literalNull(node) {
         node.value = null;
     },
-    function literalNumber(node, position, buffer, readString) {
+    function literalNumber(node, position, buffer) {
         const rawPosition = buffer[position];
-        node.raw = rawPosition === 0 ? undefined : parseAst_js.convertString(rawPosition, buffer, readString);
+        node.raw = rawPosition === 0 ? undefined : buffer.convertString(rawPosition);
         node.value = new DataView(buffer.buffer).getFloat64((position + 1) << 2, true);
     },
-    function literalRegExp(node, position, buffer, readString) {
-        const flags = parseAst_js.convertString(buffer[position], buffer, readString);
-        const pattern = parseAst_js.convertString(buffer[position + 1], buffer, readString);
+    function literalRegExp(node, position, buffer) {
+        const flags = buffer.convertString(buffer[position]);
+        const pattern = buffer.convertString(buffer[position + 1]);
         node.raw = `/${pattern}/${flags}`;
         node.regex = { flags, pattern };
         node.value = new RegExp(pattern, flags);
     },
-    function literalString(node, position, buffer, readString) {
-        node.value = parseAst_js.convertString(buffer[position], buffer, readString);
+    function literalString(node, position, buffer) {
+        node.value = buffer.convertString(buffer[position]);
         const rawPosition = buffer[position + 1];
-        node.raw = rawPosition === 0 ? undefined : parseAst_js.convertString(rawPosition, buffer, readString);
+        node.raw = rawPosition === 0 ? undefined : buffer.convertString(rawPosition);
     },
-    function logicalExpression(node, position, buffer, readString) {
+    function logicalExpression(node, position, buffer) {
         const { scope } = node;
         node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
-        node.left = convertNode(node, scope, buffer[position + 1], buffer, readString);
-        node.right = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
     },
-    function memberExpression(node, position, buffer, readString) {
+    function memberExpression(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.computed = (flags & 1) === 1;
         node.optional = (flags & 2) === 2;
-        node.object = convertNode(node, scope, buffer[position + 1], buffer, readString);
-        node.property = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.object = convertNode(node, scope, buffer[position + 1], buffer);
+        node.property = convertNode(node, scope, buffer[position + 2], buffer);
     },
-    function metaProperty(node, position, buffer, readString) {
+    function metaProperty(node, position, buffer) {
         const { scope } = node;
-        node.meta = convertNode(node, scope, buffer[position], buffer, readString);
-        node.property = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.meta = convertNode(node, scope, buffer[position], buffer);
+        node.property = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function methodDefinition(node, position, buffer, readString) {
+    function methodDefinition(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.static = (flags & 1) === 1;
         node.computed = (flags & 2) === 2;
-        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]];
+        node.decorators = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.key = convertNode(node, scope, buffer[position + 2], buffer);
+        node.value = convertNode(node, scope, buffer[position + 3], buffer);
+        node.kind = parseAst_js.FIXED_STRINGS[buffer[position + 4]];
     },
-    function newExpression(node, position, buffer, readString) {
+    function newExpression(node, position, buffer) {
         const { scope } = node;
         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);
+        node.callee = convertNode(node, scope, buffer[position + 1], buffer);
+        node.arguments = convertNodeList(node, scope, buffer[position + 2], buffer);
     },
-    function objectExpression(node, position, buffer, readString) {
+    function objectExpression(node, position, buffer) {
         const { scope } = node;
-        node.properties = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.properties = convertNodeList(node, scope, buffer[position], buffer);
     },
-    function objectPattern(node, position, buffer, readString) {
+    function objectPattern(node, position, buffer) {
         const { scope } = node;
-        node.properties = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.properties = convertNodeList(node, scope, buffer[position], buffer);
     },
-    function privateIdentifier(node, position, buffer, readString) {
-        node.name = parseAst_js.convertString(buffer[position], buffer, readString);
+    function privateIdentifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
     },
-    function program(node, position, buffer, readString) {
+    function program(node, position, buffer) {
         const { scope } = node;
-        node.body = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
         node.invalidAnnotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer);
     },
-    function property(node, position, buffer, readString) {
+    function property(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.method = (flags & 1) === 1;
         node.shorthand = (flags & 2) === 2;
         node.computed = (flags & 4) === 4;
         const keyPosition = buffer[position + 1];
-        node.value = convertNode(node, scope, buffer[position + 2], buffer, readString);
+        node.value = convertNode(node, scope, buffer[position + 2], buffer);
         node.kind = parseAst_js.FIXED_STRINGS[buffer[position + 3]];
-        node.key =
-            keyPosition === 0 ? node.value : convertNode(node, scope, keyPosition, buffer, readString);
+        node.key = keyPosition === 0 ? node.value : convertNode(node, scope, keyPosition, buffer);
     },
-    function propertyDefinition(node, position, buffer, readString) {
+    function propertyDefinition(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.static = (flags & 1) === 1;
         node.computed = (flags & 2) === 2;
-        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.decorators = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.key = convertNode(node, scope, buffer[position + 2], buffer);
+        const valuePosition = buffer[position + 3];
+        node.value = valuePosition === 0 ? null : convertNode(node, scope, valuePosition, buffer);
     },
-    function restElement(node, position, buffer, readString) {
+    function restElement(node, position, buffer) {
         const { scope } = node;
-        node.argument = convertNode(node, scope, buffer[position], buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position], buffer);
     },
-    function returnStatement(node, position, buffer, readString) {
+    function returnStatement(node, position, buffer) {
         const { scope } = node;
         const argumentPosition = buffer[position];
         node.argument =
-            argumentPosition === 0
-                ? null
-                : convertNode(node, scope, argumentPosition, buffer, readString);
+            argumentPosition === 0 ? null : convertNode(node, scope, argumentPosition, buffer);
     },
-    function sequenceExpression(node, position, buffer, readString) {
+    function sequenceExpression(node, position, buffer) {
         const { scope } = node;
-        node.expressions = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.expressions = convertNodeList(node, scope, buffer[position], buffer);
     },
-    function spreadElement(node, position, buffer, readString) {
+    function spreadElement(node, position, buffer) {
         const { scope } = node;
-        node.argument = convertNode(node, scope, buffer[position], buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position], buffer);
     },
-    function staticBlock(node, position, buffer, readString) {
+    function staticBlock(node, position, buffer) {
         const { scope } = node;
-        node.body = convertNodeList(node, scope, buffer[position], buffer, readString);
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
     },
     function superElement() { },
-    function switchCase(node, position, buffer, readString) {
+    function switchCase(node, position, buffer) {
         const { scope } = node;
         const testPosition = buffer[position];
-        node.test =
-            testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer, readString);
-        node.consequent = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+        node.test = testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer);
+        node.consequent = convertNodeList(node, scope, buffer[position + 1], buffer);
     },
-    function switchStatement(node, position, buffer, readString) {
+    function switchStatement(node, position, buffer) {
         const { scope } = node;
-        node.discriminant = convertNode(node, node.parentScope, buffer[position], buffer, readString);
-        node.cases = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+        node.discriminant = convertNode(node, node.parentScope, buffer[position], buffer);
+        node.cases = convertNodeList(node, scope, buffer[position + 1], buffer);
     },
-    function taggedTemplateExpression(node, position, buffer, readString) {
+    function taggedTemplateExpression(node, position, buffer) {
         const { scope } = node;
-        node.tag = convertNode(node, scope, buffer[position], buffer, readString);
-        node.quasi = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.tag = convertNode(node, scope, buffer[position], buffer);
+        node.quasi = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function templateElement(node, position, buffer, readString) {
+    function templateElement(node, position, buffer) {
         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(buffer[position + 2], buffer, readString);
+        const cooked = cookedPosition === 0 ? undefined : buffer.convertString(cookedPosition);
+        const raw = buffer.convertString(buffer[position + 2]);
         node.value = { cooked, raw };
     },
-    function templateLiteral(node, position, buffer, readString) {
+    function templateLiteral(node, position, buffer) {
         const { scope } = node;
-        node.quasis = convertNodeList(node, scope, buffer[position], buffer, readString);
-        node.expressions = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+        node.quasis = convertNodeList(node, scope, buffer[position], buffer);
+        node.expressions = convertNodeList(node, scope, buffer[position + 1], buffer);
     },
     function thisExpression() { },
-    function throwStatement(node, position, buffer, readString) {
+    function throwStatement(node, position, buffer) {
         const { scope } = node;
-        node.argument = convertNode(node, scope, buffer[position], buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position], buffer);
     },
-    function tryStatement(node, position, buffer, readString) {
+    function tryStatement(node, position, buffer) {
         const { scope } = node;
-        node.block = convertNode(node, scope, buffer[position], buffer, readString);
+        node.block = convertNode(node, scope, buffer[position], buffer);
         const handlerPosition = buffer[position + 1];
-        node.handler =
-            handlerPosition === 0 ? null : convertNode(node, scope, handlerPosition, buffer, readString);
+        node.handler = handlerPosition === 0 ? null : convertNode(node, scope, handlerPosition, buffer);
         const finalizerPosition = buffer[position + 2];
         node.finalizer =
-            finalizerPosition === 0
-                ? null
-                : convertNode(node, scope, finalizerPosition, buffer, readString);
+            finalizerPosition === 0 ? null : convertNode(node, scope, finalizerPosition, buffer);
     },
-    function unaryExpression(node, position, buffer, readString) {
+    function unaryExpression(node, position, buffer) {
         const { scope } = node;
         node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
-        node.argument = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function updateExpression(node, position, buffer, readString) {
+    function updateExpression(node, position, buffer) {
         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, buffer[position + 2], buffer, readString);
+        node.argument = convertNode(node, scope, buffer[position + 2], buffer);
     },
-    function variableDeclaration(node, position, buffer, readString) {
+    function variableDeclaration(node, position, buffer) {
         const { scope } = node;
         node.kind = parseAst_js.FIXED_STRINGS[buffer[position]];
-        node.declarations = convertNodeList(node, scope, buffer[position + 1], buffer, readString);
+        node.declarations = convertNodeList(node, scope, buffer[position + 1], buffer);
     },
-    function variableDeclarator(node, position, buffer, readString) {
+    function variableDeclarator(node, position, buffer) {
         const { scope } = node;
-        node.id = convertNode(node, scope, buffer[position], buffer, readString);
+        node.id = convertNode(node, scope, buffer[position], buffer);
         const initPosition = buffer[position + 1];
-        node.init =
-            initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer, readString);
+        node.init = initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer);
     },
-    function whileStatement(node, position, buffer, readString) {
+    function whileStatement(node, position, buffer) {
         const { scope } = node;
-        node.test = convertNode(node, scope, buffer[position], buffer, readString);
-        node.body = convertNode(node, scope, buffer[position + 1], buffer, readString);
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer);
     },
-    function yieldExpression(node, position, buffer, readString) {
+    function yieldExpression(node, position, buffer) {
         const { scope } = node;
         const flags = buffer[position];
         node.delegate = (flags & 1) === 1;
         const argumentPosition = buffer[position + 1];
         node.argument =
-            argumentPosition === 0
-                ? null
-                : convertNode(node, scope, argumentPosition, buffer, readString);
+            argumentPosition === 0 ? null : convertNode(node, scope, argumentPosition, buffer);
     }
 ];
-function convertNode(parent, parentScope, position, buffer, readString) {
+function convertNode(parent, parentScope, position, buffer) {
     const nodeType = buffer[position];
     const NodeConstructor = nodeConstructors$1[nodeType];
     /* istanbul ignore if: This should never be executed but is a safeguard against faulty buffers */
@@ -14520,18 +14547,18 @@ function convertNode(parent, parentScope, position, buffer, readString) {
     node.type = nodeTypeStrings[nodeType];
     node.start = buffer[position + 1];
     node.end = buffer[position + 2];
-    bufferParsers[nodeType](node, position + 3, buffer, readString);
+    bufferParsers[nodeType](node, position + 3, buffer);
     node.initialise();
     return node;
 }
-function convertNodeList(parent, parentScope, position, buffer, readString) {
+function convertNodeList(parent, parentScope, position, buffer) {
     if (position === 0)
         return parseAst_js.EMPTY_ARRAY;
     const length = buffer[position++];
     const list = [];
     for (let index = 0; index < length; index++) {
         const nodePosition = buffer[position++];
-        list.push(nodePosition ? convertNode(parent, parentScope, nodePosition, buffer, readString) : null);
+        list.push(nodePosition ? convertNode(parent, parentScope, nodePosition, buffer) : null);
     }
     return list;
 }
@@ -14566,6 +14593,7 @@ const nodeConstructors = {
     ConditionalExpression,
     ContinueStatement,
     DebuggerStatement,
+    Decorator,
     DoWhileStatement,
     EmptyStatement,
     ExportAllDeclaration,
@@ -16098,8 +16126,11 @@ function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snip
         return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess)};`;
     }
     let exportBlock = '';
-    for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
-        if (reexports && namedExportsMode) {
+    if (namedExportsMode) {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
             for (const specifier of reexports) {
                 if (specifier.reexported !== '*') {
                     const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
@@ -16143,8 +16174,11 @@ function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snip
                     : `${lhs}${_}=${_}${rhs};`;
         }
     }
-    for (const { name, reexports } of dependencies) {
-        if (reexports && namedExportsMode) {
+    if (namedExportsMode) {
+        for (const { name, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
             for (const specifier of reexports) {
                 if (specifier.reexported === '*') {
                     if (exportBlock)
@@ -19598,7 +19632,7 @@ function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
 
 function flru (max) {
 	var num, curr, prev;
-	var limit = max ;
+	var limit = max;
 
 	function keep(key, value) {
 		if (++num > limit) {
@@ -20693,7 +20727,7 @@ const getHasModuleSideEffects = (moduleSideEffectsOption) => {
 
 // https://datatracker.ietf.org/doc/html/rfc2396
 // eslint-disable-next-line no-control-regex
-const INVALID_CHAR_REGEX = /[\u0000-\u001F"#$&*+,:;<=>?[\]^`{|}\u007F]/g;
+const INVALID_CHAR_REGEX = /[\u0000-\u001F"#$%&*+,:;<=>?[\]^`{|}\u007F]/g;
 const DRIVE_LETTER_REGEX = /^[a-z]:/i;
 function sanitizeFileName(name) {
     const match = DRIVE_LETTER_REGEX.exec(name);
@@ -20922,7 +20956,7 @@ const getIndent = (config, compact) => {
         return '';
     }
     const configIndent = config.indent;
-    return configIndent === false ? '' : configIndent ?? true;
+    return configIndent === false ? '' : (configIndent ?? true);
 };
 const ALLOWED_INTEROP_TYPES = new Set([
     'compat',