@rollup/wasm-node 4.18.1 → 4.19.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.18.1
-	Mon, 08 Jul 2024 15:24:39 GMT - commit 21f9a4949358b60801c948cd4777d7a39d9e6de0
+	Rollup.js v4.19.1
+	Sat, 27 Jul 2024 04:53:31 GMT - commit 8b967917c2923dc6a02ca1238261387aefa2cb2f
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.18.1";
+var version = "4.19.1";
 
 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'],
@@ -6195,6 +6219,7 @@ const childNodeKeys = {
 };
 
 const INCLUDE_PARAMETERS = 'variables';
+const IS_SKIPPED_CHAIN = Symbol('IS_SKIPPED_CHAIN');
 class NodeBase extends ExpressionEntity {
     /**
      * Nodes can apply custom deoptimizations once they become part of the
@@ -9086,6 +9111,20 @@ function findNonWhiteSpace(code, index) {
     const result = NON_WHITESPACE.exec(code);
     return result.index;
 }
+const WHITESPACE = /\s/;
+function findLastWhiteSpaceReverse(code, start, end) {
+    while (true) {
+        if (start >= end) {
+            return end;
+        }
+        if (WHITESPACE.test(code[end - 1])) {
+            end--;
+        }
+        else {
+            return end;
+        }
+    }
+}
 // This assumes "code" only contains white-space and comments
 // Returns position of line-comment if applicable
 function findFirstLineBreakOutsideComment(code) {
@@ -10136,6 +10175,20 @@ class Literal extends NodeBase {
     }
 }
 
+function getChainElementLiteralValueAtPath(element, object, path, recursionTracker, origin) {
+    if ('getLiteralValueAtPathAsChainElement' in object) {
+        const calleeValue = object.getLiteralValueAtPathAsChainElement(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin);
+        if (calleeValue === IS_SKIPPED_CHAIN || (element.optional && calleeValue == null)) {
+            return IS_SKIPPED_CHAIN;
+        }
+    }
+    else if (element.optional &&
+        object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null) {
+        return IS_SKIPPED_CHAIN;
+    }
+    return element.getLiteralValueAtPath(path, recursionTracker, origin);
+}
+
 // To avoid infinite recursions
 const MAX_PATH_DEPTH = 7;
 function getResolvablePropertyKey(memberExpression) {
@@ -10279,6 +10332,9 @@ class MemberExpression extends NodeBase {
         }
         return UnknownValue;
     }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        return getChainElementLiteralValueAtPath(this, this.object, path, recursionTracker, origin);
+    }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         if (this.variable) {
             return this.variable.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
@@ -10299,6 +10355,23 @@ class MemberExpression extends NodeBase {
             this.object.hasEffects(context) ||
             this.hasAccessEffect(context));
     }
+    hasEffectsAsChainElement(context) {
+        if (this.variable || this.isUndefined)
+            return this.hasEffects(context);
+        const objectHasEffects = 'hasEffectsAsChainElement' in this.object
+            ? this.object.hasEffectsAsChainElement(context)
+            : this.object.hasEffects(context);
+        if (objectHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return objectHasEffects || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return this.property.hasEffects(context) || this.hasAccessEffect(context);
+    }
     hasEffectsAsAssignmentTarget(context, checkAccess) {
         if (checkAccess && !this.deoptimized)
             this.applyDeoptimizations();
@@ -10349,13 +10422,6 @@ class MemberExpression extends NodeBase {
         this.propertyKey = getResolvablePropertyKey(this);
         this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
     }
-    isSkippedAsOptional(origin) {
-        return (!this.variable &&
-            !this.isUndefined &&
-            (this.object.isSkippedAsOptional?.(origin) ||
-                (this.optional &&
-                    this.object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null)));
-    }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = parseAst_js.BLANK) {
         if (this.variable || this.isUndefined) {
             const { snippets: { getPropertyAccess } } = options;
@@ -10595,6 +10661,9 @@ class CallExpression extends CallExpressionBase {
             withNew: false
         };
     }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        return getChainElementLiteralValueAtPath(this, this.callee, path, recursionTracker, origin);
+    }
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -10608,6 +10677,26 @@ class CallExpression extends CallExpressionBase {
         return (this.callee.hasEffects(context) ||
             this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
     }
+    hasEffectsAsChainElement(context) {
+        const calleeHasEffects = 'hasEffectsAsChainElement' in this.callee
+            ? this.callee.hasEffectsAsChainElement(context)
+            : this.callee.hasEffects(context);
+        if (calleeHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.callee.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return (!this.annotationPure && calleeHasEffects) || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        return (!this.annotationPure &&
+            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
     include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -10632,11 +10721,6 @@ class CallExpression extends CallExpressionBase {
             this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
         }
     }
-    isSkippedAsOptional(origin) {
-        return (this.callee.isSkippedAsOptional?.(origin) ||
-            (this.optional &&
-                this.callee.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null));
-    }
     render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
         this.callee.render(code, options, {
             isCalleeOfRenderedParent: true,
@@ -10679,18 +10763,16 @@ class ChainExpression extends NodeBase {
     // deoptimizations are not relevant as we are not caching values
     deoptimizeCache() { }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.expression.isSkippedAsOptional(origin))
-            return undefined;
-        return this.expression.getLiteralValueAtPath(path, recursionTracker, origin);
+        const literalValue = this.expression.getLiteralValueAtPathAsChainElement(path, recursionTracker, origin);
+        return literalValue === IS_SKIPPED_CHAIN ? undefined : literalValue;
     }
     hasEffects(context) {
-        if (this.expression.isSkippedAsOptional(this))
-            return false;
-        return this.expression.hasEffects(context);
+        return this.expression.hasEffectsAsChainElement(context) === true;
     }
     removeAnnotations(code) {
         this.expression.removeAnnotations(code);
     }
+    applyDeoptimizations() { }
 }
 
 class ClassBodyScope extends ChildScope {
@@ -10727,6 +10809,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,6 +10895,9 @@ class MethodBase extends NodeBase {
 }
 
 class MethodDefinition extends MethodBase {
+    hasEffects(context) {
+        return super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
     applyDeoptimizations() { }
 }
 
@@ -10890,7 +10984,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
@@ -10907,6 +11001,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();
@@ -11000,6 +11096,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,
@@ -11235,6 +11332,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;
@@ -12497,7 +12601,7 @@ class LogicalExpression extends NodeBase {
                 this.left.removeAnnotations(code);
             }
             else {
-                code.remove(operatorPos, this.end);
+                code.remove(findLastWhiteSpaceReverse(code.original, this.left.end, operatorPos), this.end);
             }
             this.getUsedBranch().render(code, options, {
                 isCalleeOfRenderedParent,
@@ -12957,7 +13061,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);
@@ -13867,6 +13973,7 @@ const nodeTypeStrings = [
     'ConditionalExpression',
     'ContinueStatement',
     'DebuggerStatement',
+    'Decorator',
     'ExpressionStatement',
     'DoWhileStatement',
     'EmptyStatement',
@@ -13948,6 +14055,7 @@ const nodeConstructors$1 = [
     ConditionalExpression,
     ContinueStatement,
     DebuggerStatement,
+    Decorator,
     ExpressionStatement,
     DoWhileStatement,
     EmptyStatement,
@@ -14099,22 +14207,24 @@ const bufferParsers = [
     },
     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);
-        const superClassPosition = buffer[position + 1];
+        const superClassPosition = buffer[position + 2];
         node.superClass =
             superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
-        node.body = convertNode(node, scope, buffer[position + 2], buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
     },
     function classExpression(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, idPosition, buffer);
-        const superClassPosition = buffer[position + 1];
+        const superClassPosition = buffer[position + 2];
         node.superClass =
             superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
-        node.body = convertNode(node, scope, buffer[position + 2], buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
     },
     function conditionalExpression(node, position, buffer) {
         const { scope } = node;
@@ -14128,6 +14238,10 @@ const bufferParsers = [
         node.label = labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer);
     },
     function debuggerStatement() { },
+    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 = buffer.convertString(buffer[position]);
@@ -14328,9 +14442,10 @@ const bufferParsers = [
         const flags = buffer[position];
         node.static = (flags & 1) === 1;
         node.computed = (flags & 2) === 2;
-        node.key = convertNode(node, scope, buffer[position + 1], buffer);
-        node.value = convertNode(node, scope, buffer[position + 2], buffer);
-        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) {
         const { scope } = node;
@@ -14370,8 +14485,9 @@ const bufferParsers = [
         const flags = buffer[position];
         node.static = (flags & 1) === 1;
         node.computed = (flags & 2) === 2;
-        node.key = convertNode(node, scope, buffer[position + 1], buffer);
-        const valuePosition = buffer[position + 2];
+        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) {
@@ -14535,6 +14651,7 @@ const nodeConstructors = {
     ConditionalExpression,
     ContinueStatement,
     DebuggerStatement,
+    Decorator,
     DoWhileStatement,
     EmptyStatement,
     ExportAllDeclaration,
@@ -16067,8 +16184,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);
@@ -16112,8 +16232,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)
@@ -19567,7 +19690,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) {
@@ -20891,7 +21014,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',