@putout/babel 5.0.5 → 5.0.6

package/bundle/index.js

@@ -8125,7 +8125,8 @@ var functionTypeAnnotationCommon = () => ({
     },
 });
 
-var functionDeclarationCommon = () => Object.assign({}, functionCommon(), {
+var functionDeclarationCommon = () => ({
+    ...functionCommon(),
     declare: {
         validate: assertValueType('boolean'),
         optional: true,
@@ -8152,7 +8153,9 @@ defineType$4('FunctionDeclaration', {
         'returnType',
         'body',
     ],
-    fields: Object.assign({}, functionDeclarationCommon(), functionTypeAnnotationCommon(), {
+    fields: {
+        ...functionDeclarationCommon(),
+        ...functionTypeAnnotationCommon(),
         body: {
             validate: assertNodeType('BlockStatement'),
         },
@@ -8160,7 +8163,7 @@ defineType$4('FunctionDeclaration', {
             validate: assertNodeType('DeclaredPredicate', 'InferredPredicate'),
             optional: true,
         },
-    }),
+    },
     aliases: [
         'Scopable',
         'Function',
@@ -8190,7 +8193,9 @@ defineType$4('FunctionExpression', {
         'Expression',
         'Pureish',
     ],
-    fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
+    fields: {
+        ...functionCommon(),
+        ...functionTypeAnnotationCommon(),
         id: {
             validate: assertNodeType('Identifier'),
             optional: true,
@@ -8202,7 +8207,7 @@ defineType$4('FunctionExpression', {
             validate: assertNodeType('DeclaredPredicate', 'InferredPredicate'),
             optional: true,
         },
-    }),
+    },
 });
 var patternLikeCommon = () => ({
     typeAnnotation: {
@@ -8229,7 +8234,8 @@ defineType$4('Identifier', {
         'LVal',
         'TSEntityName',
     ],
-    fields: Object.assign({}, patternLikeCommon(), {
+    fields: {
+        ...patternLikeCommon(),
         name: {
             validate: chain(assertValueType('string'), Object.assign(function(node, key, val) {
                 if (!isValidIdentifier(val, false)) {
@@ -8239,7 +8245,7 @@ defineType$4('Identifier', {
                 type: 'string',
             })),
         },
-    }),
+    },
     validate: function(parent, key, node) {
         const match = /\.(\w+)$/.exec(key.toString());
         
@@ -8520,7 +8526,7 @@ defineType$4('ObjectExpression', {
         properties: validateArrayOfType('ObjectMethod', 'ObjectProperty', 'SpreadElement'),
     },
 });
-defineType$4('ObjectMethod', Object.assign({
+defineType$4('ObjectMethod', {
     builder: [
         'kind',
         'key',
@@ -8538,8 +8544,10 @@ defineType$4('ObjectMethod', Object.assign({
         'returnType',
         'body',
     ],
-}, classMethodOrPropertyUnionShapeCommon(), {
-    fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
+    ...classMethodOrPropertyUnionShapeCommon(),
+    fields: {
+        ...functionCommon(),
+        ...functionTypeAnnotationCommon(),
         kind: {
             validate: assertOneOf('method', 'get', 'set'),
         },
@@ -8572,7 +8580,7 @@ defineType$4('ObjectMethod', Object.assign({
         body: {
             validate: assertNodeType('BlockStatement'),
         },
-    }),
+    },
     aliases: [
         'UserWhitespacable',
         'Function',
@@ -8582,7 +8590,7 @@ defineType$4('ObjectMethod', Object.assign({
         'Method',
         'ObjectMember',
     ],
-}));
+});
 defineType$4('ObjectProperty', {
     builder: [
         'key',
@@ -8686,11 +8694,12 @@ defineType$4('RestElement', {
     builder: ['argument'],
     aliases: ['FunctionParameter', 'PatternLike'],
     deprecatedAlias: 'RestProperty',
-    fields: Object.assign({}, patternLikeCommon(), {
+    fields: {
+        ...patternLikeCommon(),
         argument: {
             validate: assertNodeType('Identifier', 'ArrayPattern', 'ObjectPattern', 'MemberExpression', 'TSAsExpression', 'TSSatisfiesExpression', 'TSTypeAssertion', 'TSNonNullExpression'),
         },
-    }),
+    },
     validate: function(parent, key) {
         const match = /(\w+)\[(\d+)\]/.exec(key.toString());
         
@@ -8945,7 +8954,8 @@ defineType$4('AssignmentPattern', {
         'Pattern',
         'PatternLike',
     ],
-    fields: Object.assign({}, patternLikeCommon(), {
+    fields: {
+        ...patternLikeCommon(),
         left: {
             validate: assertNodeType('Identifier', 'ObjectPattern', 'ArrayPattern', 'MemberExpression', 'TSAsExpression', 'TSSatisfiesExpression', 'TSTypeAssertion', 'TSNonNullExpression'),
         },
@@ -8956,7 +8966,7 @@ defineType$4('AssignmentPattern', {
             validate: arrayOfType('Decorator'),
             optional: true,
         },
-    }),
+    },
 });
 defineType$4('ArrayPattern', {
     visitor: ['elements', 'typeAnnotation'],
@@ -8967,11 +8977,12 @@ defineType$4('ArrayPattern', {
         'PatternLike',
         'LVal',
     ],
-    fields: Object.assign({}, patternLikeCommon(), {
+    fields: {
+        ...patternLikeCommon(),
         elements: {
             validate: chain(assertValueType('array'), assertEach(assertNodeOrValueType('null', 'PatternLike'))),
         },
-    }),
+    },
 });
 defineType$4('ArrowFunctionExpression', {
     builder: [
@@ -8994,7 +9005,9 @@ defineType$4('ArrowFunctionExpression', {
         'Expression',
         'Pureish',
     ],
-    fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
+    fields: {
+        ...functionCommon(),
+        ...functionTypeAnnotationCommon(),
         expression: {
             validate: assertValueType('boolean'),
         },
@@ -9005,7 +9018,7 @@ defineType$4('ArrowFunctionExpression', {
             validate: assertNodeType('DeclaredPredicate', 'InferredPredicate'),
             optional: true,
         },
-    }),
+    },
 });
 defineType$4('ClassBody', {
     visitor: ['body'],
@@ -9148,12 +9161,13 @@ defineType$4('ExportAllDeclaration', {
         'ImportOrExportDeclaration',
         'ExportDeclaration',
     ],
-    fields: Object.assign({
+    fields: {
         source: {
             validate: assertNodeType('StringLiteral'),
         },
         exportKind: validateOptional(assertOneOf('type', 'value')),
-    }, importAttributes),
+        ...importAttributes,
+    },
 });
 defineType$4('ExportDefaultDeclaration', {
     visitor: ['declaration'],
@@ -9186,7 +9200,7 @@ defineType$4('ExportNamedDeclaration', {
         'ImportOrExportDeclaration',
         'ExportDeclaration',
     ],
-    fields: Object.assign({
+    fields: {
         declaration: {
             optional: true,
             validate: chain(assertNodeType('Declaration'), Object.assign(function(node, key, val) {
@@ -9201,7 +9215,7 @@ defineType$4('ExportNamedDeclaration', {
                 oneOfNodeTypes: ['Declaration'],
             })),
         },
-    }, importAttributes, {
+        ...importAttributes,
         specifiers: {
             default: [],
             validate: arrayOf((function() {
@@ -9225,7 +9239,7 @@ defineType$4('ExportNamedDeclaration', {
             optional: true,
         },
         exportKind: validateOptional(assertOneOf('type', 'value')),
-    }),
+    },
 });
 defineType$4('ExportSpecifier', {
     visitor: ['local', 'exported'],
@@ -9313,7 +9327,8 @@ defineType$4('ImportDeclaration', {
         'Declaration',
         'ImportOrExportDeclaration',
     ],
-    fields: Object.assign({}, importAttributes, {
+    fields: {
+        ...importAttributes,
         module: {
             optional: true,
             validate: assertValueType('boolean'),
@@ -9330,7 +9345,7 @@ defineType$4('ImportDeclaration', {
             validate: assertOneOf('type', 'typeof', 'value'),
             optional: true,
         },
-    }),
+    },
 });
 defineType$4('ImportDefaultSpecifier', {
     visitor: ['local'],
@@ -9453,7 +9468,9 @@ var classMethodOrPropertyCommon = () => ({
     },
 });
 
-var classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), {
+var classMethodOrDeclareMethodCommon = () => ({
+    ...functionCommon(),
+    ...classMethodOrPropertyCommon(),
     params: validateArrayOfType('FunctionParameter', 'TSParameterProperty'),
     kind: {
         validate: assertOneOf('get', 'set', 'method', 'constructor'),
@@ -9469,7 +9486,7 @@ var classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(),
     },
 });
 
-defineType$4('ClassMethod', Object.assign({
+defineType$4('ClassMethod', {
     aliases: [
         'Function',
         'Scopable',
@@ -9495,13 +9512,15 @@ defineType$4('ClassMethod', Object.assign({
         'returnType',
         'body',
     ],
-}, classMethodOrPropertyUnionShapeCommon(), {
-    fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
+    ...classMethodOrPropertyUnionShapeCommon(),
+    fields: {
+        ...classMethodOrDeclareMethodCommon(),
+        ...functionTypeAnnotationCommon(),
         body: {
             validate: assertNodeType('BlockStatement'),
         },
-    }),
-}));
+    },
+});
 defineType$4('ObjectPattern', {
     visitor: [
         'decorators',
@@ -9515,9 +9534,10 @@ defineType$4('ObjectPattern', {
         'PatternLike',
         'LVal',
     ],
-    fields: Object.assign({}, patternLikeCommon(), {
+    fields: {
+        ...patternLikeCommon(),
         properties: validateArrayOfType('RestElement', 'ObjectProperty'),
-    }),
+    },
 });
 defineType$4('SpreadElement', {
     visitor: ['argument'],
@@ -9729,7 +9749,7 @@ defineType$4('OptionalCallExpression', {
         },
     },
 });
-defineType$4('ClassProperty', Object.assign({
+defineType$4('ClassProperty', {
     visitor: [
         'decorators',
         'variance',
@@ -9746,8 +9766,9 @@ defineType$4('ClassProperty', Object.assign({
         'static',
     ],
     aliases: ['Property'],
-}, classMethodOrPropertyUnionShapeCommon(), {
-    fields: Object.assign({}, classMethodOrPropertyCommon(), {
+    ...classMethodOrPropertyUnionShapeCommon(),
+    fields: {
+        ...classMethodOrPropertyCommon(),
         value: {
             validate: assertNodeType('Expression'),
             optional: true,
@@ -9776,9 +9797,9 @@ defineType$4('ClassProperty', Object.assign({
             validate: assertNodeType('Variance'),
             optional: true,
         },
-    }),
-}));
-defineType$4('ClassAccessorProperty', Object.assign({
+    },
+});
+defineType$4('ClassAccessorProperty', {
     visitor: [
         'decorators',
         'key',
@@ -9794,8 +9815,9 @@ defineType$4('ClassAccessorProperty', Object.assign({
         'static',
     ],
     aliases: ['Property', 'Accessor'],
-}, classMethodOrPropertyUnionShapeCommon(true), {
-    fields: Object.assign({}, classMethodOrPropertyCommon(), {
+    ...classMethodOrPropertyUnionShapeCommon(true),
+    fields: {
+        ...classMethodOrPropertyCommon(),
         key: {
             validate: chain((function() {
                 const normal = assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'PrivateName');
@@ -9835,8 +9857,8 @@ defineType$4('ClassAccessorProperty', Object.assign({
             validate: assertNodeType('Variance'),
             optional: true,
         },
-    }),
-}));
+    },
+});
 defineType$4('ClassPrivateProperty', {
     visitor: [
         'decorators',
@@ -9914,7 +9936,9 @@ defineType$4('ClassPrivateMethod', {
         'Method',
         'Private',
     ],
-    fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
+    fields: {
+        ...classMethodOrDeclareMethodCommon(),
+        ...functionTypeAnnotationCommon(),
         kind: {
             validate: assertOneOf('get', 'set', 'method'),
             default: 'method',
@@ -9925,7 +9949,7 @@ defineType$4('ClassPrivateMethod', {
         body: {
             validate: assertNodeType('BlockStatement'),
         },
-    }),
+    },
 });
 defineType$4('PrivateName', {
     visitor: ['id'],
@@ -9985,16 +10009,16 @@ var defineInterfaceishType = (name) => {
             'Statement',
             'Declaration',
         ],
-        fields: Object.assign({
+        fields: {
             id: validateType('Identifier'),
             typeParameters: validateOptionalType('TypeParameterDeclaration'),
             extends: validateOptional(arrayOfType('InterfaceExtends')),
-        }, isDeclareClass2 ? {
-            mixins: validateOptional(arrayOfType('InterfaceExtends')),
-            implements: validateOptional(arrayOfType('ClassImplements')),
-        } : {}, {
+            ...isDeclareClass2 ? {
+                mixins: validateOptional(arrayOfType('InterfaceExtends')),
+                implements: validateOptional(arrayOfType('ClassImplements')),
+            } : {},
             body: validateType('ObjectTypeAnnotation'),
-        }),
+        },
     });
 };
 
@@ -10126,12 +10150,13 @@ defineType$3('DeclareExportDeclaration', {
         'Statement',
         'Declaration',
     ],
-    fields: Object.assign({
+    fields: {
         declaration: validateOptionalType('Flow'),
         specifiers: validateOptional(arrayOfType('ExportSpecifier', 'ExportNamespaceSpecifier')),
         source: validateOptionalType('StringLiteral'),
         default: validateOptional(assertValueType('boolean')),
-    }, importAttributes),
+        ...importAttributes,
+    },
 });
 defineType$3('DeclareExportAllDeclaration', {
     visitor: ['source', 'attributes'],
@@ -10140,10 +10165,11 @@ defineType$3('DeclareExportAllDeclaration', {
         'Statement',
         'Declaration',
     ],
-    fields: Object.assign({
+    fields: {
         source: validateType('StringLiteral'),
         exportKind: validateOptional(assertOneOf('type', 'value')),
-    }, importAttributes),
+        ...importAttributes,
+    },
 });
 defineType$3('DeclaredPredicate', {
     visitor: ['value'],
@@ -10784,14 +10810,15 @@ var defineType$1 = defineAliasedType('Miscellaneous');
 defineType$1('Placeholder', {
     visitor: [],
     builder: ['expectedNode', 'name'],
-    fields: Object.assign({
+    fields: {
         name: {
             validate: assertNodeType('Identifier'),
         },
         expectedNode: {
             validate: assertOneOf(...PLACEHOLDERS),
         },
-    }, patternLikeCommon()),
+        ...patternLikeCommon(),
+    },
 });
 defineType$1('V8IntrinsicIdentifier', {
     builder: ['name'],
@@ -10934,9 +10961,12 @@ defineType('TSDeclareFunction', {
         'params',
         'returnType',
     ],
-    fields: Object.assign({}, functionDeclarationCommon(), tSFunctionTypeAnnotationCommon()),
+    fields: {
+        ...functionDeclarationCommon(),
+        ...tSFunctionTypeAnnotationCommon(),
+    },
 });
-defineType('TSDeclareMethod', Object.assign({
+defineType('TSDeclareMethod', {
     visitor: [
         'decorators',
         'key',
@@ -10944,9 +10974,12 @@ defineType('TSDeclareMethod', Object.assign({
         'params',
         'returnType',
     ],
-}, classMethodOrPropertyUnionShapeCommon(), {
-    fields: Object.assign({}, classMethodOrDeclareMethodCommon(), tSFunctionTypeAnnotationCommon()),
-}));
+    ...classMethodOrPropertyUnionShapeCommon(),
+    fields: {
+        ...classMethodOrDeclareMethodCommon(),
+        ...tSFunctionTypeAnnotationCommon(),
+    },
+});
 defineType('TSQualifiedName', {
     aliases: ['TSEntityName'],
     visitor: ['left', 'right'],
@@ -10984,14 +11017,15 @@ var namedTypeElementCommon = () => ({
 defineType('TSPropertySignature', {
     aliases: ['TSTypeElement'],
     visitor: ['key', 'typeAnnotation'],
-    fields: Object.assign({}, namedTypeElementCommon(), {
+    fields: {
+        ...namedTypeElementCommon(),
         readonly: validateOptional(bool),
         typeAnnotation: validateOptionalType('TSTypeAnnotation'),
         kind: {
             optional: true,
             validate: assertOneOf('get', 'set'),
         },
-    }),
+    },
 });
 defineType('TSMethodSignature', {
     aliases: ['TSTypeElement'],
@@ -11001,11 +11035,13 @@ defineType('TSMethodSignature', {
         'params',
         'returnType',
     ],
-    fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), {
+    fields: {
+        ...signatureDeclarationCommon(),
+        ...namedTypeElementCommon(),
         kind: {
             validate: assertOneOf('method', 'get', 'set'),
         },
-    }),
+    },
 });
 defineType('TSIndexSignature', {
     aliases: ['TSTypeElement'],
@@ -11056,18 +11092,17 @@ var fnOrCtrBase = {
     ],
 };
 
-defineType('TSFunctionType', Object.assign({},
-    fnOrCtrBase,{
-        fields: signatureDeclarationCommon(),
-    },
-));
-defineType('TSConstructorType', Object.assign({},
-    fnOrCtrBase,{
-        fields: Object.assign({}, signatureDeclarationCommon(), {
-            abstract: validateOptional(bool),
-        }),
+defineType('TSFunctionType', {
+    ...fnOrCtrBase,
+    fields: signatureDeclarationCommon(),
+});
+defineType('TSConstructorType', {
+    ...fnOrCtrBase,
+    fields: {
+        ...signatureDeclarationCommon(),
+        abstract: validateOptional(bool),
     },
-));
+});
 defineType('TSTypeReference', {
     aliases: ['TSType'],
     visitor: ['typeName', 'typeArguments'],
@@ -16792,7 +16827,9 @@ function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache)
     }
     
     if (hasOwn(node, 'extra')) {
-        newNode.extra = Object.assign({}, node.extra);
+        newNode.extra = {
+            ...node.extra,
+        };
     }
     
     return newNode;
@@ -17922,22 +17959,6 @@ var react = {
 };
 
 // ../babel-babel/packages/babel-parser/lib/index.js
-function _objectWithoutPropertiesLoose(r, e) {
-    if (null == r)
-        return {};
-    
-    var t = {};
-    
-    for (var n2 in r)    if ({}.hasOwnProperty.call(r, n2)) {
-        if (-1 !== e.indexOf(n2))
-            continue;
-        
-        t[n2] = r[n2];
-    }
-    
-    return t;
-}
-
 var Position = class {
     constructor(line, col, index2) {
         __publicField(this, 'line');
@@ -18030,10 +18051,8 @@ var StandardErrors = {
     ConstructorIsGenerator: 'Constructor can\'t be a generator.',
     DeclarationMissingInitializer: ({kind}) => `Missing initializer in ${kind} declaration.`,
     DecoratorArgumentsOutsideParentheses: 'Decorator arguments must be moved inside parentheses: use \'@(decorator(args))\' instead of \'@(decorator)(args)\'.',
-    DecoratorBeforeExport: 'Decorators must be placed *before* the \'export\' keyword. Remove the \'decoratorsBeforeExport: true\' option to use the \'export @decorator class {}\' syntax.',
     DecoratorsBeforeAfterExport: 'Decorators can be placed *either* before or after the \'export\' keyword, but not in both locations at the same time.',
     DecoratorConstructor: 'Decorators can\'t be used with a constructor. Did you mean \'@dec class { ... }\'?',
-    DecoratorExportClass: 'Decorators must be placed *after* the \'export\' keyword. Remove the \'decoratorsBeforeExport: false\' option to use the \'@decorator export class {}\' syntax.',
     DecoratorSemicolon: 'Decorators must not be followed by a semicolon.',
     DecoratorStaticBlock: 'Decorators can\'t be used with a static block.',
     DeferImportRequiresNamespace: 'Only `import defer * as x from "./module"` is valid.',
@@ -18057,21 +18076,16 @@ var StandardErrors = {
     IllegalBreakContinue: ({type}) => `Unsyntactic ${type === 'BreakStatement' ? 'break' : 'continue'}.`,
     IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list.',
     IllegalReturn: '\'return\' outside of function.',
-    ImportAttributesUseAssert: 'The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedImportAssert` parser plugin to suppress this error.',
     ImportBindingIsString: ({importName}) => `A string literal cannot be used as an imported binding.
 - Did you mean \`import { "${importName}" as foo }\`?`,
     ImportCallArity: `\`import()\` requires exactly one or two arguments.`,
     ImportCallNotNewExpression: 'Cannot use new with import(...).',
     ImportCallSpreadArgument: '`...` is not allowed in `import()`.',
-    ImportJSONBindingNotDefault: 'A JSON module can only be imported with `default`.',
-    ImportReflectionHasAssertion: '`import module x` cannot have assertions.',
-    ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.',
     IncompatibleRegExpUVFlags: 'The \'u\' and \'v\' regular expression flags cannot be enabled at the same time.',
     InvalidBigIntLiteral: 'Invalid BigIntLiteral.',
     InvalidCodePoint: 'Code point out of bounds.',
     InvalidCoverDiscardElement: '\'void\' must be followed by an expression when not used in a binding position.',
     InvalidCoverInitializedName: 'Invalid shorthand property initializer.',
-    InvalidDecimal: 'Invalid decimal.',
     InvalidDigit: ({radix}) => `Expected number in radix ${radix}.`,
     InvalidEscapeSequence: 'Bad character escape sequence.',
     InvalidEscapeSequenceTemplate: 'Invalid escape sequence in template.',
@@ -18086,7 +18100,6 @@ var StandardErrors = {
     InvalidParenthesizedAssignment: 'Invalid parenthesized assignment pattern.',
     InvalidPrivateFieldResolution: ({identifierName}) => `Private name #${identifierName} is not defined.`,
     InvalidPropertyBindingPattern: 'Binding member expression.',
-    InvalidRecordProperty: 'Only properties and spread elements are allowed in record definitions.',
     InvalidRestAssignmentPattern: 'Invalid rest operator\'s argument.',
     LabelRedeclaration: ({labelName}) => `Label '${labelName}' is already declared.`,
     LetInLexicalBinding: '\'let\' is disallowed as a lexically bound name.',
@@ -18103,7 +18116,6 @@ var StandardErrors = {
         .join(', ')}.`,
     MissingUnicodeEscape: 'Expecting Unicode escape sequence \\uXXXX.',
     MixingCoalesceWithLogical: 'Nullish coalescing operator(??) requires parens when mixing with logical operators.',
-    ModuleAttributeDifferentFromType: 'The only accepted module attribute is `type`.',
     ModuleAttributeInvalidValue: 'Only string literals are allowed as module attribute values.',
     ModuleAttributesWithDuplicateKeys: ({key}) => `Duplicate key "${key}" is not allowed in module attributes.`,
     ModuleExportNameHasLoneSurrogate: ({surrogateCharCode}) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
@@ -18122,10 +18134,6 @@ var StandardErrors = {
     PatternHasMethod: 'Object pattern can\'t contain methods.',
     PrivateInExpectedIn: ({identifierName}) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
     PrivateNameRedeclaration: ({identifierName}) => `Duplicate private name #${identifierName}.`,
-    RecordExpressionBarIncorrectEndSyntaxType: 'Record expressions ending with \'|}\' are only allowed when the \'syntaxType\' option of the \'recordAndTuple\' plugin is set to \'bar\'.',
-    RecordExpressionBarIncorrectStartSyntaxType: 'Record expressions starting with \'{|\' are only allowed when the \'syntaxType\' option of the \'recordAndTuple\' plugin is set to \'bar\'.',
-    RecordExpressionHashIncorrectStartSyntaxType: 'Record expressions starting with \'#{\' are only allowed when the \'syntaxType\' option of the \'recordAndTuple\' plugin is set to \'hash\'.',
-    RecordNoProto: '\'__proto__\' is not allowed in Record expressions.',
     RestTrailingComma: 'Unexpected trailing comma after rest element.',
     SloppyFunction: 'In non-strict mode code, functions can only be declared at top level or inside a block.',
     SloppyFunctionAnnexB: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.',
@@ -18134,11 +18142,7 @@ var StandardErrors = {
     SuperNotAllowed: '`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name (\'constructor\') or not extending another class?',
     SuperPrivateField: 'Private fields can\'t be accessed on super.',
     TrailingDecorator: 'Decorators must be attached to a class element.',
-    TupleExpressionBarIncorrectEndSyntaxType: 'Tuple expressions ending with \'|]\' are only allowed when the \'syntaxType\' option of the \'recordAndTuple\' plugin is set to \'bar\'.',
-    TupleExpressionBarIncorrectStartSyntaxType: 'Tuple expressions starting with \'[|\' are only allowed when the \'syntaxType\' option of the \'recordAndTuple\' plugin is set to \'bar\'.',
-    TupleExpressionHashIncorrectStartSyntaxType: 'Tuple expressions starting with \'#[\' are only allowed when the \'syntaxType\' option of the \'recordAndTuple\' plugin is set to \'hash\'.',
     UnexpectedArgumentPlaceholder: 'Unexpected argument placeholder.',
-    UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.',
     UnexpectedDigitAfterHash: 'Unexpected digit after hash token.',
     UnexpectedImportExport: '\'import\' and \'export\' may only appear at the top level.',
     UnexpectedKeyword: ({keyword}) => `Unexpected keyword '${keyword}'.`,
@@ -18209,8 +18213,6 @@ var PipelineOperatorErrors = {
     })}; please wrap it in parentheses.`,
 };
 
-var _excluded = ['message'];
-
 function defineHidden(obj, key, value) {
     Object.defineProperty(obj, key, {
         enumerable: false,
@@ -18242,7 +18244,10 @@ function toParseErrorConstructor({toMessage, code: code2, reasonCode, syntaxPlug
                 index: index2,
             } = overrides.loc ?? loc;
             
-            return constructor(new Position(line, column, index2), Object.assign({}, details, overrides.details));
+            return constructor(new Position(line, column, index2), {
+                ...details,
+                ...overrides.details,
+            });
         });
         defineHidden(error, 'details', details);
         Object.defineProperty(error, 'message', {
@@ -18273,27 +18278,35 @@ function ParseErrorEnum(argument, syntaxPlugin) {
     
     for (const reasonCode of Object.keys(argument)) {
         const template = argument[reasonCode];
-        const _ref = typeof template === 'string' ? {
-                message: () => template,
-            } : typeof template === 'function' ? {
-                message: template,
-            } : template, {message} = _ref, rest = _objectWithoutPropertiesLoose(_ref, _excluded);
+        const {message, ...rest} = typeof template === 'string' ? {
+            message: () => template,
+        } : typeof template === 'function' ? {
+            message: template,
+        } : template;
         
         const toMessage = typeof message === 'string' ? () => message : message;
         
-        ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
+        ParseErrorConstructors[reasonCode] = toParseErrorConstructor({
             code: 'BABEL_PARSER_SYNTAX_ERROR',
             reasonCode,
             toMessage,
-        }, syntaxPlugin ? {
-            syntaxPlugin,
-        } : {}, rest));
+            ...syntaxPlugin ? {
+                syntaxPlugin,
+            } : {},
+            ...rest,
+        });
     }
     
     return ParseErrorConstructors;
 }
 
-var Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(ParseExpressionErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
+var Errors = {
+    ...ParseErrorEnum(ModuleErrors),
+    ...ParseErrorEnum(StandardErrors),
+    ...ParseErrorEnum(StrictModeErrors),
+    ...ParseErrorEnum(ParseExpressionErrors),
+    ...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),
+};
 
 function createDefaultOptions() {
     return {
@@ -18425,14 +18438,6 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
         return node;
     }
     
-    parseDecimalLiteral(value) {
-        const decimal = null;
-        const node = this.estreeParseLiteral(decimal);
-        
-        node.decimal = String(node.value || value);
-        return node;
-    }
-    
     estreeParseLiteral(value) {
         return this.parseLiteral(value, 'Literal');
     }
@@ -22655,24 +22660,27 @@ var Tokenizer = class extends CommentsParser {
             numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),
             unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator),
         });
-        __publicField(this, 'errorHandlers_readCodePoint', Object.assign({}, this.errorHandlers_readInt, {
+        __publicField(this, 'errorHandlers_readCodePoint', {
+            ...this.errorHandlers_readInt,
             invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),
             invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint),
-        }));
-        __publicField(this, 'errorHandlers_readStringContents_string', Object.assign({}, this.errorHandlers_readCodePoint, {
+        });
+        __publicField(this, 'errorHandlers_readStringContents_string', {
+            ...this.errorHandlers_readCodePoint,
             strictNumericEscape: (pos, lineStart, curLine) => {
                 this.recordStrictModeErrors(Errors.StrictNumericEscape, buildPosition(pos, lineStart, curLine));
             },
             unterminated: (pos, lineStart, curLine) => {
                 throw this.raise(Errors.UnterminatedString, buildPosition(pos - 1, lineStart, curLine));
             },
-        }));
-        __publicField(this, 'errorHandlers_readStringContents_template', Object.assign({}, this.errorHandlers_readCodePoint, {
+        });
+        __publicField(this, 'errorHandlers_readStringContents_template', {
+            ...this.errorHandlers_readCodePoint,
             strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
             unterminated: (pos, lineStart, curLine) => {
                 throw this.raise(Errors.UnterminatedTemplate, buildPosition(pos, lineStart, curLine));
             },
-        }));
+        });
         this.state = new State();
         this.state.init(options);
         this.input = input;
@@ -23525,8 +23533,6 @@ var Tokenizer = class extends CommentsParser {
         if (next === 110) {
             ++this.state.pos;
             isBigInt = true;
-        } else if (next === 109) {
-            throw this.raise(Errors.InvalidDecimal, startLoc);
         }
         
         if (isIdentifierStart2(this.codePointAtPos(this.state.pos))) {
@@ -25057,7 +25063,6 @@ var TSErrors = ParseErrorEnum`typescript`({
     EmptyTypeParameters: 'Type parameter list cannot be empty.',
     ExpectedAmbientAfterExportDeclare: '\'export declare\' must be followed by an ambient declaration.',
     ImportAliasHasImportType: 'An import alias can not use \'import type\'.',
-    ImportReflectionHasImportType: 'An `import module` declaration can not use `type` modifier',
     IncompatibleModifiers: ({modifiers}) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
     IndexSignatureHasAbstract: 'Index signatures cannot have the \'abstract\' modifier.',
     IndexSignatureHasAccessibility: ({modifier}) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
@@ -27108,8 +27113,8 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         return exprList;
     }
     
-    parseArrayLike(close, isTuple, refExpressionErrors) {
-        const node = super.parseArrayLike(close, isTuple, refExpressionErrors);
+    parseArrayLike(close, refExpressionErrors) {
+        const node = super.parseArrayLike(close, refExpressionErrors);
         
         if (node.type === 'ArrayExpression') {
             this.tsCheckForInvalidTypeCasts(node.elements);
@@ -27266,14 +27271,6 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         }
     }
     
-    checkImportReflection(node) {
-        super.checkImportReflection(node);
-        
-        if (node.module && node.importKind !== 'value') {
-            this.raise(TSErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
-        }
-    }
-    
     checkDuplicateExports() {}
     
     isPotentialImportPhase(isExport) {
@@ -28985,18 +28982,6 @@ function validatePlugins(pluginsMap) {
         if (pluginsMap.has('decorators-legacy')) {
             throw new Error('Cannot use the decorators and decorators-legacy plugin together');
         }
-        
-        const decoratorsBeforeExport = pluginsMap.get('decorators').decoratorsBeforeExport;
-        
-        if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== 'boolean') {
-            throw new Error('\'decoratorsBeforeExport\' must be a boolean, if specified.');
-        }
-        
-        const allowCallParenthesized = pluginsMap.get('decorators').allowCallParenthesized;
-        
-        if (allowCallParenthesized != null && typeof allowCallParenthesized !== 'boolean') {
-            throw new Error('\'allowCallParenthesized\' must be a boolean.');
-        }
     }
     
     if (pluginsMap.has('flow') && pluginsMap.has('typescript')) {
@@ -29090,7 +29075,7 @@ var mixinPlugins = {
 var mixinPluginNames = Object.keys(mixinPlugins);
 
 var ExpressionParser = class extends LValParser {
-    checkProto(prop, isRecord, sawProto, refExpressionErrors) {
+    checkProto(prop, sawProto, refExpressionErrors) {
         if (prop.type === 'SpreadElement' || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
             return sawProto;
         }
@@ -29099,11 +29084,6 @@ var ExpressionParser = class extends LValParser {
         const name = key.type === 'Identifier' ? key.name : key.value;
         
         if (name === '__proto__') {
-            if (isRecord) {
-                this.raise(Errors.RecordNoProto, key);
-                return true;
-            }
-            
             if (sawProto) {
                 if (refExpressionErrors) {
                     if (refExpressionErrors.doubleProtoLoc === null) {
@@ -29847,11 +29827,11 @@ var ExpressionParser = class extends LValParser {
         }
         
         case 0: {
-            return this.parseArrayLike(3, false, refExpressionErrors);
+            return this.parseArrayLike(3, refExpressionErrors);
         }
         
         case 5: {
-            return this.parseObjectLike(8, false, false, refExpressionErrors);
+            return this.parseObjectLike(8, false, refExpressionErrors);
         }
         
         case 68:
@@ -30014,9 +29994,6 @@ var ExpressionParser = class extends LValParser {
             }]);
         }
         
-        case 'smart':
-            return tokenType === 27;
-        
         default:
             throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);
         }
@@ -30185,10 +30162,6 @@ var ExpressionParser = class extends LValParser {
         return node;
     }
     
-    parseDecimalLiteral(value) {
-        return this.parseLiteral(value, 'DecimalLiteral');
-    }
-    
     parseRegExpLiteral(value) {
         const node = this.startNode();
         this.addExtra(node, 'raw', this.input.slice(this.offsetToSourcePos(node.start), this.state.end));
@@ -30431,11 +30404,7 @@ var ExpressionParser = class extends LValParser {
         return this.parseExpression();
     }
     
-    parseObjectLike(close, isPattern3, isRecord, refExpressionErrors) {
-        if (isRecord) {
-            this.expectPlugin('recordAndTuple');
-        }
-        
+    parseObjectLike(close, isPattern3, refExpressionErrors) {
         const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
         
         this.state.inFSharpPipelineDirectBody = false;
@@ -30463,11 +30432,7 @@ var ExpressionParser = class extends LValParser {
                 prop = this.parseBindingProperty();
             } else {
                 prop = this.parsePropertyDefinition(refExpressionErrors);
-                sawProto = this.checkProto(prop, isRecord, sawProto, refExpressionErrors);
-            }
-            
-            if (isRecord && !this.isObjectProperty(prop) && prop.type !== 'SpreadElement') {
-                this.raise(Errors.InvalidRecordProperty, prop);
+                sawProto = this.checkProto(prop, sawProto, refExpressionErrors);
             }
             
             node.properties.push(prop);
@@ -30475,13 +30440,7 @@ var ExpressionParser = class extends LValParser {
         
         this.next();
         this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-        let type = 'ObjectExpression';
-        
-        if (isPattern3) {
-            type = 'ObjectPattern';
-        } else if (isRecord) {
-            type = 'RecordExpression';
-        }
+        const type = isPattern3 ? 'ObjectPattern' : 'ObjectExpression';
         
         return this.finishNode(node, type);
     }
@@ -30728,19 +30687,15 @@ var ExpressionParser = class extends LValParser {
         return finishedNode;
     }
     
-    parseArrayLike(close, isTuple, refExpressionErrors) {
-        if (isTuple) {
-            this.expectPlugin('recordAndTuple');
-        }
-        
+    parseArrayLike(close, refExpressionErrors) {
         const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
         
         this.state.inFSharpPipelineDirectBody = false;
         const node = this.startNode();
         this.next();
-        node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);
+        node.elements = this.parseExprList(close, true, refExpressionErrors, node);
         this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-        return this.finishNode(node, isTuple ? 'TupleExpression' : 'ArrayExpression');
+        return this.finishNode(node, 'ArrayExpression');
     }
     
     parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
@@ -31112,10 +31067,6 @@ var ExpressionParser = class extends LValParser {
         }
     }
     
-    withSmartMixTopicForbiddingContext(callback) {
-        return callback();
-    }
-    
     withSoloAwaitPermittingContext(callback) {
         const outerContextSoloAwaitState = this.state.soloAwait;
         
@@ -31646,20 +31597,10 @@ var StatementParser = class extends ExpressionParser {
         }
     }
     
-    decoratorsEnabledBeforeExport() {
-        if (this.hasPlugin('decorators-legacy'))
-            return true;
-        
-        return this.hasPlugin('decorators') && this.getPluginOption('decorators', 'decoratorsBeforeExport') !== false;
-    }
-    
     maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
         if (maybeDecorators) {
             if (classNode.decorators?.length) {
-                if (typeof this.getPluginOption('decorators', 'decoratorsBeforeExport') !== 'boolean') {
-                    this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);
-                }
-                
+                this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);
                 classNode.decorators.unshift(...maybeDecorators);
             } else {
                 classNode.decorators = maybeDecorators;
@@ -31688,10 +31629,6 @@ var StatementParser = class extends ExpressionParser {
             if (!allowExport) {
                 this.unexpected();
             }
-            
-            if (!this.decoratorsEnabledBeforeExport()) {
-                this.raise(Errors.DecoratorExportClass, this.state.startLoc);
-            }
         } else if (!this.canHaveLeadingDecorator()) {
             throw this.raise(Errors.UnexpectedLeadingDecorator, this.state.startLoc);
         }
@@ -31718,7 +31655,7 @@ var StatementParser = class extends ExpressionParser {
                 
                 node.expression = this.parseMaybeDecoratorArguments(expr, startLoc2);
                 
-                if (this.getPluginOption('decorators', 'allowCallParenthesized') === false && node.expression !== expr) {
+                if (node.expression !== expr) {
                     this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);
                 }
             } else {
@@ -31816,7 +31753,7 @@ var StatementParser = class extends ExpressionParser {
     parseDoWhileStatement(node) {
         this.next();
         this.state.labels.push(loopLabel);
-        node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
+        node.body = this.parseStatement();
         this.state.labels.pop();
         this.expect(92);
         node.test = this.parseHeaderExpression();
@@ -32043,7 +31980,7 @@ var StatementParser = class extends ExpressionParser {
                 this.scope.enter(0);
             }
             
-            clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));
+            clause.body = this.parseBlock(false, false);
             this.scope.exit();
             node.handler = this.finishNode(clause, 'CatchClause');
         }
@@ -32068,7 +32005,7 @@ var StatementParser = class extends ExpressionParser {
         this.next();
         node.test = this.parseHeaderExpression();
         this.state.labels.push(loopLabel);
-        node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
+        node.body = this.parseStatement();
         this.state.labels.pop();
         return this.finishNode(node, 'WhileStatement');
     }
@@ -32080,7 +32017,7 @@ var StatementParser = class extends ExpressionParser {
         
         this.next();
         node.object = this.parseHeaderExpression();
-        node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
+        node.body = this.parseStatement();
         return this.finishNode(node, 'WithStatement');
     }
     
@@ -32204,7 +32141,7 @@ var StatementParser = class extends ExpressionParser {
         this.semicolon(false);
         node.update = this.match(11) ? null : this.parseExpression();
         this.expect(11);
-        node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
+        node.body = this.parseStatement();
         this.scope.exit();
         this.state.labels.pop();
         return this.finishNode(node, 'ForStatement');
@@ -32238,7 +32175,7 @@ var StatementParser = class extends ExpressionParser {
         node.left = init;
         node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
         this.expect(11);
-        node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
+        node.body = this.parseStatement();
         this.scope.exit();
         this.state.labels.pop();
         return this.finishNode(node, isForIn ? 'ForInStatement' : 'ForOfStatement');
@@ -32329,9 +32266,7 @@ var StatementParser = class extends ExpressionParser {
         }
         
         this.parseFunctionParams(node, false);
-        this.withSmartMixTopicForbiddingContext(() => {
-            this.parseFunctionBodyAndFinish(node, isDeclaration2 ? 'FunctionDeclaration' : 'FunctionExpression');
-        });
+        this.parseFunctionBodyAndFinish(node, isDeclaration2 ? 'FunctionDeclaration' : 'FunctionExpression');
         this.prodParam.exit();
         this.scope.exit();
         
@@ -32401,36 +32336,35 @@ var StatementParser = class extends ExpressionParser {
         
         classBody2.body = [];
         this.expect(5);
-        this.withSmartMixTopicForbiddingContext(() => {
-            while (!this.match(8)) {
-                if (this.eat(13)) {
-                    if (decorators.length > 0) {
-                        throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);
-                    }
-                    
-                    continue;
-                }
-                
-                if (this.match(26)) {
-                    decorators.push(this.parseDecorator());
-                    continue;
-                }
-                
-                const member = this.startNode();
-                
-                if (decorators.length) {
-                    member.decorators = decorators;
-                    this.resetStartLocationFromNode(member, decorators[0]);
-                    decorators = [];
+        while (!this.match(8)) {
+            if (this.eat(13)) {
+                if (decorators.length > 0) {
+                    throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);
                 }
                 
-                this.parseClassMember(classBody2, member, state);
-                
-                if (member.kind === 'constructor' && member.decorators && member.decorators.length > 0) {
-                    this.raise(Errors.DecoratorConstructor, member);
-                }
+                continue;
             }
-        });
+            
+            if (this.match(26)) {
+                decorators.push(this.parseDecorator());
+                continue;
+            }
+            
+            const member = this.startNode();
+            
+            if (decorators.length) {
+                member.decorators = decorators;
+                this.resetStartLocationFromNode(member, decorators[0]);
+                decorators = [];
+            }
+            
+            this.parseClassMember(classBody2, member, state);
+            
+            if (member.kind === 'constructor' && member.decorators && member.decorators.length > 0) {
+                this.raise(Errors.DecoratorConstructor, member);
+            }
+        }
+        
         this.state.strict = oldStrict;
         this.next();
         
@@ -32926,10 +32860,6 @@ var StatementParser = class extends ExpressionParser {
         }
         
         if (this.match(26)) {
-            if (this.hasPlugin('decorators') && this.getPluginOption('decorators', 'decoratorsBeforeExport') === true) {
-                this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);
-            }
-            
             return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
         }
         
@@ -32992,7 +32922,6 @@ var StatementParser = class extends ExpressionParser {
             node.source = this.parseImportSource();
             this.checkExport(node);
             this.maybeParseImportAttributes(node);
-            this.checkJSONModuleImport(node);
         } else if (expect) {
             this.unexpected();
         }
@@ -33007,10 +32936,6 @@ var StatementParser = class extends ExpressionParser {
             this.expectOnePlugin(['decorators', 'decorators-legacy']);
             
             if (this.hasPlugin('decorators')) {
-                if (this.getPluginOption('decorators', 'decoratorsBeforeExport') === true) {
-                    this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);
-                }
-                
                 return true;
             }
         }
@@ -33185,17 +33110,7 @@ var StatementParser = class extends ExpressionParser {
         return this.parseIdentifier(true);
     }
     
-    isJSONModuleImport(node) {
-        if (node.assertions != null) {
-            return node.assertions.some(({key, value}) => {
-                return value.value === 'json' && (key.type === 'Identifier' ? key.name === 'type' : key.value === 'type');
-            });
-        }
-        
-        return false;
-    }
-    
-    checkImportReflection(node) {
+    checkImportPhase(node) {
         const {specifiers} = node;
         
         const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;
@@ -33208,41 +33123,6 @@ var StatementParser = class extends ExpressionParser {
             if (singleBindingType !== 'ImportNamespaceSpecifier') {
                 this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start);
             }
-        } else if (node.module) {
-            if (singleBindingType !== 'ImportDefaultSpecifier') {
-                this.raise(Errors.ImportReflectionNotBinding, specifiers[0].loc.start);
-            }
-            
-            if (node.assertions?.length > 0) {
-                this.raise(Errors.ImportReflectionHasAssertion, specifiers[0].loc.start);
-            }
-        }
-
-    }
-    
-    checkJSONModuleImport(node) {
-        if (this.isJSONModuleImport(node) && node.type !== 'ExportAllDeclaration') {
-            const {specifiers} = node;
-            
-            if (specifiers != null) {
-                const nonDefaultNamedSpecifier = specifiers.find((specifier) => {
-                    let imported;
-                    
-                    if (specifier.type === 'ExportSpecifier') {
-                        imported = specifier.local;
-                    } else if (specifier.type === 'ImportSpecifier') {
-                        imported = specifier.imported;
-                    }
-                    
-                    if (imported !== void 0) {
-                        return imported.type === 'Identifier' ? imported.name !== 'default' : imported.value !== 'default';
-                    }
-                });
-                
-                if (nonDefaultNamedSpecifier !== void 0) {
-                    this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start);
-                }
-            }
         }
     }
     
@@ -33258,10 +33138,6 @@ var StatementParser = class extends ExpressionParser {
             return;
         }
         
-        if (this.hasPlugin('importReflection')) {
-            node.module = false;
-        }
-        
         if (phase === 'source') {
             this.expectPlugin('sourcePhaseImports', loc);
             node.phase = 'source';
@@ -33327,8 +33203,7 @@ var StatementParser = class extends ExpressionParser {
         node.specifiers ?? (node.specifiers = []);
         node.source = this.parseImportSource();
         this.maybeParseImportAttributes(node);
-        this.checkImportReflection(node);
-        this.checkJSONModuleImport(node);
+        this.checkImportPhase(node);
         this.semicolon();
         this.sawUnambiguousESM = true;
         return this.finishNode(node, 'ImportDeclaration');
@@ -33393,39 +33268,6 @@ var StatementParser = class extends ExpressionParser {
         return attrs;
     }
     
-    parseModuleAttributes() {
-        const attrs = [];
-        const attributes =         /* @__PURE__ */new Set();
-        
-        do {
-            const node = this.startNode();
-            
-            node.key = this.parseIdentifier(true);
-            
-            if (node.key.name !== 'type') {
-                this.raise(Errors.ModuleAttributeDifferentFromType, node.key);
-            }
-            
-            if (attributes.has(node.key.name)) {
-                this.raise(Errors.ModuleAttributesWithDuplicateKeys, node.key, {
-                    key: node.key.name,
-                });
-            }
-            
-            attributes.add(node.key.name);
-            this.expect(14);
-            
-            if (!this.match(134)) {
-                throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
-            }
-            
-            node.value = this.parseStringLiteral(this.state.value);
-            attrs.push(this.finishNode(node, 'ImportAttribute'));
-        } while (this.eat(12))
-        
-        return attrs;
-    }
-    
     maybeParseImportAttributes(node) {
         let attributes;
         
@@ -33615,7 +33457,9 @@ var Parser = class extends StatementParser {
 
 function parse(input, options) {
     if (options?.sourceType === 'unambiguous') {
-        options = Object.assign({}, options);
+        options = {
+            ...options,
+        };
         try {
             options.sourceType = 'module';
             const parser = getParser(options, input);
@@ -34415,12 +34259,17 @@ function highlight(text) {
 var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 
 function getMarkerLines(loc, source, opts) {
-    const startLoc = Object.assign({
+    const startLoc = {
         column: 0,
         line: -1,
-    }, loc.start);
+        ...loc.start,
+    };
+    
+    const endLoc = {
+        ...startLoc,
+        ...loc.end,
+    };
     
-    const endLoc = Object.assign({}, startLoc, loc.end);
     const {linesAbove = 2, linesBelow = 3} = opts || {};
     
     const startLine = startLoc.line;
@@ -34618,29 +34467,6 @@ var program$1 = {
     unwrap: (ast) => ast.program,
 };
 
-function _objectWithoutPropertiesLoose2(r, e) {
-    if (null == r)
-        return {};
-    
-    var t = {};
-    
-    for (var n2 in r)    if ({}.hasOwnProperty.call(r, n2)) {
-        if (-1 !== e.indexOf(n2))
-            continue;
-        
-        t[n2] = r[n2];
-    }
-    
-    return t;
-}
-
-var _excluded2 = [
-    'placeholderWhitelist',
-    'placeholderPattern',
-    'preserveComments',
-    'syntacticPlaceholders',
-];
-
 function merge(a, b2) {
     const {
         placeholderWhitelist = a.placeholderWhitelist,
@@ -34650,7 +34476,10 @@ function merge(a, b2) {
     } = b2;
     
     return {
-        parser: Object.assign({}, a.parser, b2.parser),
+        parser: {
+            ...a.parser,
+            ...b2.parser,
+        },
         placeholderWhitelist,
         placeholderPattern,
         preserveComments,
@@ -34663,12 +34492,13 @@ function validate$12(opts) {
         throw new Error('Unknown template options.');
     }
     
-    const _ref = opts || {}, {
-            placeholderWhitelist,
-            placeholderPattern,
-            preserveComments,
-            syntacticPlaceholders,
-        } = _ref, parser = _objectWithoutPropertiesLoose2(_ref, _excluded2);
+    const {
+        placeholderWhitelist,
+        placeholderPattern,
+        preserveComments,
+        syntacticPlaceholders,
+        ...parser
+    } = opts || {};
     
     if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {
         throw new Error('\'.placeholderWhitelist\' must be a Set, null, or undefined');
@@ -34757,9 +34587,10 @@ function parseAndBuildMetadata(formatter, code2, opts) {
     };
     
     traverse2(ast, placeholderVisitorHandler, state);
-    return Object.assign({
+    return {
         ast,
-    }, state.syntactic.placeholders.length ? state.syntactic : state.legacy);
+        ...state.syntactic.placeholders.length ? state.syntactic : state.legacy,
+    };
 }
 
 function placeholderVisitorHandler(node, ancestors, state) {
@@ -34854,16 +34685,16 @@ function parseWithCodeFrame(code2, parserOpts, syntacticPlaceholders) {
         plugins.push('placeholders');
     }
     
-    parserOpts = Object.assign({
+    parserOpts = {
         allowAwaitOutsideFunction: true,
         allowReturnOutsideFunction: true,
         allowNewTargetOutsideFunction: true,
         allowSuperOutsideMethod: true,
         allowYieldOutsideFunction: true,
         sourceType: 'module',
-    }, parserOpts, {
+        ...parserOpts,
         plugins,
-    });
+    };
     try {
         return parse(code2, parserOpts);
     } catch(err) {
@@ -37823,7 +37654,7 @@ function NewExpression2(node, parent) {
     this.space();
     this.print(node.callee);
     
-    if (this.format.minified && node.arguments.length === 0 && !node.optional && !isCallExpression3(parent, {callee: node}) && !isMemberExpression2(parent) && !isNewExpression3(parent)) {
+    if (this.format.minified && node.arguments.length === 0 && !isCallExpression3(parent, {callee: node}) && !isMemberExpression2(parent) && !isNewExpression3(parent)) {
         return;
     }
     
@@ -37853,10 +37684,6 @@ function Super2() {
 }
 
 function _shouldPrintDecoratorsBeforeExport(node) {
-    if (typeof this.format.decoratorsBeforeExport === 'boolean') {
-        return this.format.decoratorsBeforeExport;
-    }
-    
     return typeof node.start === 'number' && node.start === node.declaration.start;
 }
 
@@ -38060,6 +37887,7 @@ var {
     isForStatement: isForStatement2,
     isIfStatement: isIfStatement2,
     isStatement: isStatement$3,
+    isVoidPattern: isVoidPattern2,
 } = lib_exports;
 
 function WithStatement2(node) {
@@ -38347,7 +38175,9 @@ function VariableDeclarator2(node) {
     if (node.definite)
         this.tokenChar(33);
     
-    this.print(node.id.typeAnnotation);
+    if (!isVoidPattern2(node.id)) {
+        this.print(node.id.typeAnnotation);
+    }
     
     if (node.init) {
         this.space();
@@ -39385,7 +39215,7 @@ function DeclareFunction2(node, parent) {
     this.word('function');
     this.space();
     this.print(node.id);
-    this.print(node.id.typeAnnotation.typeAnnotation);
+    this.print(node.id.typeAnnotation?.typeAnnotation);
     
     if (node.predicate) {
         this.space();
@@ -42318,11 +42148,12 @@ function normalizeOptions(code2, opts, ast) {
             adjustMultilineComment: true,
             style: '  ',
         },
-        jsescOption: Object.assign({
+        jsescOption: {
             quotes: 'double',
             wrap: true,
             minimal: true,
-        }, opts.jsescOption),
+            ...opts.jsescOption,
+        },
         topicToken: opts.topicToken,
     };
     
@@ -42867,7 +42698,9 @@ function explode$1(visitor) {
             if (existing) {
                 mergePair(existing, fns);
             } else {
-                visitor[alias2] = Object.assign({}, fns);
+                visitor[alias2] = {
+                    ...fns,
+                };
             }
         }
     }
@@ -42899,7 +42732,7 @@ function verify$1(visitor) {
             continue;
         
         if (!TYPES2.includes(nodeType)) {
-            throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${'8.0.0-beta.3'}`);
+            throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${'7.28.5'}`);
         }
         
         const visitors2 = visitor[nodeType];
@@ -43218,8 +43051,8 @@ function traverseForScope(path, visitors2, state) {
         throw new Error('Should not be used with enter/exit visitors.');
     }
     
-    _traverse2(path.parentPath, path.parent, path.node, path.container, path.key, path.listKey, path.hub, path);
-    function _traverse2(parentPath, parent, node, container, key, listKey, hub, inPath) {
+    _traverse(path.parentPath, path.parent, path.node, path.container, path.key, path.listKey, path.hub, path);
+    function _traverse(parentPath, parent, node, container, key, listKey, hub, inPath) {
         if (!node) {
             return;
         }
@@ -43261,10 +43094,10 @@ function traverseForScope(path, visitors2, state) {
             if (Array.isArray(prop)) {
                 for (let i = 0; i < prop.length; i++) {
                     const value = prop[i];
-                    _traverse2(path2, node, value, prop, i, key2);
+                    _traverse(path2, node, value, prop, i, key2);
                 }
             } else {
-                _traverse2(path2, node, prop, node, key2, null);
+                _traverse(path2, node, prop, node, key2, null);
             }
         }
         
@@ -46717,8 +46550,9 @@ function arrowFunctionToExpression({allowInsertArrow = true, allowInsertArrowWit
         }
         
         fn.get('body').unshiftContainer('body', expressionStatement3(callExpression2(this.hub.addHelper('newArrowCheck'), [thisExpression2(), checkBinding ? identifier3(checkBinding.name) : identifier3(thisBinding)])));
-        fn.replaceWith(callExpression2(memberExpression2(fn.node, identifier3('bind')), [checkBinding ? identifier3(checkBinding.name) : thisExpression2()]));
-        return fn.get('callee.object');
+        return fn
+            .replaceWith(callExpression2(memberExpression2(fn.node, identifier3('bind')), [checkBinding ? identifier3(checkBinding.name) : thisExpression2()]))[0]
+            .get('callee.object');
     }
     
     return fn;
@@ -46759,8 +46593,9 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
         if (arrowParent) {
             thisEnvFn = arrowParent;
         } else if (allowInsertArrow) {
-            fnPath.replaceWith(callExpression2(arrowFunctionExpression2([], toExpression2(fnPath.node)), []));
-            thisEnvFn = fnPath.get('callee');
+            thisEnvFn = fnPath
+                .replaceWith(callExpression2(arrowFunctionExpression2([], toExpression2(fnPath.node)), []))[0]
+                .get('callee');
             fnPath = thisEnvFn.get('body');
         } else {
             throw fnPath.buildCodeFrameError('Unable to transform arrow inside class property');
@@ -46872,8 +46707,9 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
             } else if (isAssignment) {
                 superParentPath.replaceWith(call2);
             } else if (isTaggedTemplate) {
-                superProp.replaceWith(callExpression2(memberExpression2(call2, identifier3('bind'), false), [thisExpression2()]));
-                thisPaths.push(superProp.get('arguments.0'));
+                thisPaths.push(superProp
+                    .replaceWith(callExpression2(memberExpression2(call2, identifier3('bind'), false), [thisExpression2()]))[0]
+                    .get('arguments.0'));
             } else {
                 superProp.replaceWith(call2);
             }
@@ -46952,9 +46788,9 @@ function standardizeSuperProperty(superProp) {
             parts.push(identifier3(tmp.name));
         }
         
-        updateExpr.replaceWith(sequenceExpression2(parts));
-        const left = updateExpr.get('expressions.0.right');
-        const right = updateExpr.get('expressions.1.left');
+        const sequenceExpr = updateExpr.replaceWith(sequenceExpression2(parts))[0];
+        const left = sequenceExpr.get('expressions.0.right');
+        const right = sequenceExpr.get('expressions.1.left');
         
         return [left, right];
     }
@@ -47899,9 +47735,10 @@ function getStatementListCompletion(paths, context) {
         
         for (let i = 0; i < paths.length; i++) {
             const path = paths[i];
-            const newContext = Object.assign({}, context, {
+            const newContext = {
+                ...context,
                 inCaseClause: false,
-            });
+            };
             
             if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
                 newContext.shouldPopulateBreak = true;
@@ -48737,7 +48574,7 @@ function _visit(ctx, path) {
     }
     
     const opts = ctx.opts;
-    const denylist = opts.denylist ?? opts.blacklist;
+    const denylist = opts.denylist;
     
     if (denylist?.includes(node.type)) {
         return false;
@@ -48758,7 +48595,7 @@ function _visit(ctx, path) {
             return path.shouldStop;
     }
     
-    path.shouldStop = _traverse(path.node, opts, path.scope, ctx.state, path, path.skipKeys);
+    path.shouldStop = traverseNode(path.node, opts, path.scope, ctx.state, path, path.skipKeys);
     
     if (path.node) {
         if (_call.call(path, opts.exit))
@@ -48772,7 +48609,7 @@ function _visit(ctx, path) {
     return path.shouldStop;
 }
 
-function _traverse(node, opts, scope2, state, path, skipKeys, visitSelf) {
+function traverseNode(node, opts, scope2, state, path, skipKeys, visitSelf) {
     const keys2 = VISITOR_KEYS$12[node.type];
     
     if (!keys2?.length)
@@ -48828,10 +48665,6 @@ function _traverse(node, opts, scope2, state, path, skipKeys, visitSelf) {
     return false;
 }
 
-function traverseNode(node, opts, scope2, state, path, skipKeys, visitSelf) {
-    return _traverse(node, opts, scope2, state, path, skipKeys, visitSelf);
-}
-
 function call(key) {
     const opts = this.opts;
     this.debug(key);
@@ -48882,8 +48715,7 @@ function _call(fns) {
 }
 
 function isDenylisted() {
-    const denylist = this.opts.denylist ?? this.opts.blacklist;
-    return denylist?.includes(this.node.type);
+    return !!this.opts.denylist?.includes(this.node.type);
 }
 
 function restoreContext(path, context) {