@putout/bundle 3.21.1 → 3.22.1

package/bundle/putout.js

@@ -8224,6 +8224,24 @@ var require_globals = __commonJS({
                 uniq: false,
                 which: false
             },
+            vitest: {
+                afterAll: false,
+                afterEach: false,
+                assert: false,
+                assertType: false,
+                beforeAll: false,
+                beforeEach: false,
+                describe: false,
+                expect: false,
+                expectTypeOf: false,
+                it: false,
+                onTestFailed: false,
+                onTestFinished: false,
+                suite: false,
+                test: false,
+                vi: false,
+                vitest: false
+            },
             webextensions: {
                 browser: false,
                 chrome: false,
@@ -8555,8 +8573,8 @@ var require_globals2 = __commonJS({
     }
 });
 // lib/index.mjs
-var lib_exports2 = {};
-__export(lib_exports2, {
+var index_exports = {};
+__export(index_exports, {
     codeFrameColumns: function() {
         return codeFrameColumns$2;
     },
@@ -8582,7 +8600,7 @@ __export(lib_exports2, {
         return lib_exports;
     }
 });
-var bundle = __toCommonJS(lib_exports2);
+var bundle = __toCommonJS(index_exports);
 // node_modules/@babel/types/lib/index.js
 var lib_exports = {};
 __export(lib_exports, {
@@ -9315,6 +9333,9 @@ __export(lib_exports, {
     TSENTITYNAME_TYPES: function() {
         return TSENTITYNAME_TYPES;
     },
+    TSEnumBody: function() {
+        return tsEnumBody;
+    },
     TSEnumDeclaration: function() {
         return tsEnumDeclaration$1;
     },
@@ -10266,6 +10287,9 @@ __export(lib_exports, {
     assertTSEntityName: function() {
         return assertTSEntityName;
     },
+    assertTSEnumBody: function() {
+        return assertTSEnumBody;
+    },
     assertTSEnumDeclaration: function() {
         return assertTSEnumDeclaration;
     },
@@ -11523,6 +11547,9 @@ __export(lib_exports, {
     isTSEntityName: function() {
         return isTSEntityName;
     },
+    isTSEnumBody: function() {
+        return isTSEnumBody;
+    },
     isTSEnumDeclaration: function() {
         return isTSEnumDeclaration;
     },
@@ -12117,6 +12144,9 @@ __export(lib_exports, {
     tsDeclareMethod: function() {
         return tsDeclareMethod$1;
     },
+    tsEnumBody: function() {
+        return tsEnumBody;
+    },
     tsEnumDeclaration: function() {
         return tsEnumDeclaration$1;
     },
@@ -14866,6 +14896,11 @@ function isTSTypeAssertion(node, opts) {
     if (node.type !== "TSTypeAssertion") return false;
     return opts == null || shallowEqual(node, opts);
 }
+function isTSEnumBody(node, opts) {
+    if (!node) return false;
+    if (node.type !== "TSEnumBody") return false;
+    return opts == null || shallowEqual(node, opts);
+}
 function isTSEnumDeclaration(node, opts) {
     if (!node) return false;
     if (node.type !== "TSEnumDeclaration") return false;
@@ -15964,6 +15999,7 @@ function isTypeScript(node, opts) {
         case "TSAsExpression":
         case "TSSatisfiesExpression":
         case "TSTypeAssertion":
+        case "TSEnumBody":
         case "TSEnumDeclaration":
         case "TSEnumMember":
         case "TSModuleDeclaration":
@@ -16943,7 +16979,6 @@ defineType$4("CallExpression", {
     visitor: [
         "callee",
         "arguments",
-        "typeParameters",
         "typeArguments"
     ],
     builder: [
@@ -16957,17 +16992,12 @@ defineType$4("CallExpression", {
         callee: {
             validate: assertNodeType("Expression", "Super", "V8IntrinsicIdentifier")
         },
-        arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder")
-    }, {}, {
+        arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
         typeArguments: {
-            validate: assertNodeType("TypeParameterInstantiation"),
-            optional: true
-        },
-        typeParameters: {
-            validate: assertNodeType("TSTypeParameterInstantiation"),
+            validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
             optional: true
         }
-    })
+    }, {}, {} )
 });
 defineType$4("CatchClause", {
     visitor: [
@@ -17205,6 +17235,7 @@ defineType$4("FunctionDeclaration", {
         "id",
         "typeParameters",
         "params",
+        "predicate",
         "returnType",
         "body"
     ],
@@ -18062,6 +18093,7 @@ defineType$4("ArrowFunctionExpression", {
     visitor: [
         "typeParameters",
         "params",
+        "predicate",
         "returnType",
         "body"
     ],
@@ -18651,7 +18683,7 @@ defineType$4("Super", undefined);
 defineType$4("TaggedTemplateExpression", {
     visitor: [
         "tag",
-        "typeParameters",
+        "typeArguments",
         "quasi"
     ],
     builder: [
@@ -18661,18 +18693,17 @@ defineType$4("TaggedTemplateExpression", {
     aliases: [
         "Expression"
     ],
-    fields: {
+    fields: _define_property({
         tag: {
             validate: assertNodeType("Expression")
         },
         quasi: {
             validate: assertNodeType("TemplateLiteral")
-        },
-        typeParameters: {
-            validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-            optional: true
         }
-    }
+    }, "typeArguments", {
+        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+        optional: true
+    })
 });
 defineType$4("TemplateElement", {
     builder: [
@@ -18861,7 +18892,6 @@ defineType$4("OptionalCallExpression", {
     visitor: [
         "callee",
         "arguments",
-        "typeParameters",
         "typeArguments"
     ],
     builder: [
@@ -18872,7 +18902,7 @@ defineType$4("OptionalCallExpression", {
     aliases: [
         "Expression"
     ],
-    fields: {
+    fields: Object.assign({
         callee: {
             validate: assertNodeType("Expression")
         },
@@ -18881,18 +18911,15 @@ defineType$4("OptionalCallExpression", {
             validate: chain$4(assertValueType("boolean"), assertOptionalChainStart())
         },
         typeArguments: {
-            validate: assertNodeType("TypeParameterInstantiation"),
-            optional: true
-        },
-        typeParameters: {
-            validate: assertNodeType("TSTypeParameterInstantiation"),
+            validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
             optional: true
         }
-    }
+    }, {})
 });
 defineType$4("ClassProperty", {
     visitor: [
         "decorators",
+        "variance",
         "key",
         "typeAnnotation",
         "value"
@@ -19002,6 +19029,7 @@ defineType$4("ClassAccessorProperty", {
 defineType$4("ClassPrivateProperty", {
     visitor: [
         "decorators",
+        "variance",
         "key",
         "typeAnnotation",
         "value"
@@ -19202,9 +19230,13 @@ defineType$3("ClassImplements", {
 });
 defineInterfaceishType("DeclareClass");
 defineType$3("DeclareFunction", {
-    visitor: [
+    builder: [
         "id"
     ],
+    visitor: [
+        "id",
+        "predicate"
+    ],
     aliases: [
         "FlowDeclaration",
         "Statement",
@@ -19349,8 +19381,15 @@ defineType$3("ExistsTypeAnnotation", {
     ]
 });
 defineType$3("FunctionTypeAnnotation", {
+    builder: [
+        "typeParameters",
+        "params",
+        "rest",
+        "returnType"
+    ],
     visitor: [
         "typeParameters",
+        "this",
         "params",
         "rest",
         "returnType"
@@ -19847,9 +19886,13 @@ defineType$3("EnumBooleanMember", {
     aliases: [
         "EnumMember"
     ],
-    visitor: [
+    builder: [
         "id"
     ],
+    visitor: [
+        "id",
+        "init"
+    ],
     fields: {
         id: validateType("Identifier"),
         init: validateType("BooleanLiteral")
@@ -20050,12 +20093,13 @@ defineType$2("JSXOpeningElement", {
     ],
     visitor: [
         "name",
+        "typeArguments",
         "attributes"
     ],
     aliases: [
         "Immutable"
     ],
-    fields: {
+    fields: Object.assign({
         name: {
             validate: assertNodeType("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
         },
@@ -20063,11 +20107,11 @@ defineType$2("JSXOpeningElement", {
             default: false
         },
         attributes: validateArrayOfType("JSXAttribute", "JSXSpreadAttribute"),
-        typeParameters: {
+        typeArguments: {
             validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
             optional: true
         }
-    }
+    }, {})
 });
 defineType$2("JSXSpreadAttribute", {
     visitor: [
@@ -20617,12 +20661,11 @@ defineType("TSTypeQuery", {
     ],
     visitor: [
         "exprName",
-        "typeParameters"
+        "typeArguments"
     ],
-    fields: {
-        exprName: validateType("TSEntityName", "TSImportType"),
-        typeParameters: validateOptionalType("TSTypeParameterInstantiation")
-    }
+    fields: _define_property({
+        exprName: validateType("TSEntityName", "TSImportType")
+    }, "typeArguments", validateOptionalType("TSTypeParameterInstantiation"))
 });
 defineType("TSTypeLiteral", {
     aliases: [
@@ -20836,22 +20879,33 @@ defineType("TSLiteralType", {
         }
     }
 });
-var expressionWithTypeArguments = {
-    aliases: [
-        "TSType"
-    ],
-    visitor: [
-        "expression",
-        "typeParameters"
-    ],
-    fields: {
-        expression: validateType("TSEntityName"),
-        typeParameters: validateOptionalType("TSTypeParameterInstantiation")
-    }
-};
 {
-    defineType("TSClassImplements", expressionWithTypeArguments);
-    defineType("TSInterfaceHeritage", expressionWithTypeArguments);
+    defineType("TSClassImplements", {
+        aliases: [
+            "TSType"
+        ],
+        visitor: [
+            "expression",
+            "typeArguments"
+        ],
+        fields: {
+            expression: validateType("TSEntityName"),
+            typeArguments: validateOptionalType("TSTypeParameterInstantiation")
+        }
+    });
+    defineType("TSInterfaceHeritage", {
+        aliases: [
+            "TSType"
+        ],
+        visitor: [
+            "expression",
+            "typeArguments"
+        ],
+        fields: {
+            expression: validateType("TSEntityName"),
+            typeArguments: validateOptionalType("TSTypeParameterInstantiation")
+        }
+    });
 }defineType("TSInterfaceDeclaration", {
     aliases: [
         "Statement",
@@ -20902,12 +20956,11 @@ defineType("TSInstantiationExpression", {
     ],
     visitor: [
         "expression",
-        "typeParameters"
+        "typeArguments"
     ],
-    fields: {
-        expression: validateType("Expression"),
-        typeParameters: validateOptionalType("TSTypeParameterInstantiation")
-    }
+    fields: _define_property({
+        expression: validateType("Expression")
+    }, "typeArguments", validateOptionalType("TSTypeParameterInstantiation"))
 });
 var TSTypeExpression = {
     aliases: [
@@ -20941,24 +20994,32 @@ defineType("TSTypeAssertion", {
         expression: validateType("Expression")
     }
 });
-defineType("TSEnumDeclaration", {
-    aliases: [
-        "Statement",
-        "Declaration"
-    ],
+defineType("TSEnumBody", {
     visitor: [
-        "id",
         "members"
     ],
     fields: {
-        declare: validateOptional(bool),
-        const: validateOptional(bool),
-        id: validateType("Identifier"),
-        members: validateArrayOfType("TSEnumMember"),
-        initializer: validateOptionalType("Expression")
+        members: validateArrayOfType("TSEnumMember")
     }
 });
-defineType("TSEnumMember", {
+{
+    defineType("TSEnumDeclaration", {
+        aliases: [
+            "Statement",
+            "Declaration"
+        ],
+        visitor: [
+            "id",
+            "body"
+        ],
+        fields: {
+            declare: validateOptional(bool),
+            const: validateOptional(bool),
+            id: validateType("Identifier"),
+            body: validateType("TSEnumBody")
+        }
+    });
+}defineType("TSEnumMember", {
     visitor: [
         "id",
         "initializer"
@@ -21001,24 +21062,29 @@ defineType("TSModuleBlock", {
         body: validateArrayOfType("Statement")
     }
 });
+var _obj2;
 defineType("TSImportType", {
     aliases: [
         "TSType"
     ],
+    builder: [
+        "argument",
+        "qualifier",
+        "typeArguments"
+    ],
     visitor: [
         "argument",
+        "options",
         "qualifier",
-        "typeParameters"
+        "typeArguments"
     ],
-    fields: {
-        argument: validateType("StringLiteral"),
-        qualifier: validateOptionalType("TSEntityName"),
-        typeParameters: validateOptionalType("TSTypeParameterInstantiation"),
-        options: {
-            validate: assertNodeType("Expression"),
-            optional: true
-        }
-    }
+    fields: (_obj2 = {
+        argument: validateType("TSLiteralType"),
+        qualifier: validateOptionalType("TSEntityName")
+    }, _define_property(_obj2, "typeArguments", validateOptionalType("TSTypeParameterInstantiation")), _define_property(_obj2, "options", {
+        validate: assertNodeType("Expression"),
+        optional: true
+    }), _obj2)
 });
 defineType("TSImportEqualsDeclaration", {
     aliases: [
@@ -21114,6 +21180,7 @@ defineType("TSTypeParameter", {
         "name"
     ],
     visitor: [
+        "name",
         "constraint",
         "default"
     ],
@@ -23420,15 +23487,15 @@ function tsTypePredicate(parameterName) {
     return node;
 }
 function tsTypeQuery$1(exprName) {
-    var typeParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var typeArguments = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     var node = {
         type: "TSTypeQuery",
         exprName: exprName,
-        typeParameters: typeParameters
+        typeArguments: typeArguments
     };
     var defs = NODE_FIELDS.TSTypeQuery;
     validate$4(defs.exprName, node, "exprName", exprName, 1);
-    validate$4(defs.typeParameters, node, "typeParameters", typeParameters, 1);
+    validate$4(defs.typeArguments, node, "typeArguments", typeArguments, 1);
     return node;
 }
 function tsTypeLiteral$1(members) {
@@ -23588,27 +23655,27 @@ function tsLiteralType(literal) {
     return node;
 }
 function tsClassImplements(expression2) {
-    var typeParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var typeArguments = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     var node = {
         type: "TSClassImplements",
         expression: expression2,
-        typeParameters: typeParameters
+        typeArguments: typeArguments
     };
     var defs = NODE_FIELDS.TSClassImplements;
     validate$4(defs.expression, node, "expression", expression2, 1);
-    validate$4(defs.typeParameters, node, "typeParameters", typeParameters, 1);
+    validate$4(defs.typeArguments, node, "typeArguments", typeArguments, 1);
     return node;
 }
 function tsInterfaceHeritage(expression2) {
-    var typeParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var typeArguments = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     var node = {
         type: "TSInterfaceHeritage",
         expression: expression2,
-        typeParameters: typeParameters
+        typeArguments: typeArguments
     };
     var defs = NODE_FIELDS.TSInterfaceHeritage;
     validate$4(defs.expression, node, "expression", expression2, 1);
-    validate$4(defs.typeParameters, node, "typeParameters", typeParameters, 1);
+    validate$4(defs.typeArguments, node, "typeArguments", typeArguments, 1);
     return node;
 }
 function tsInterfaceDeclaration$1(id) {
@@ -23651,15 +23718,15 @@ function tsTypeAliasDeclaration$1(id) {
     return node;
 }
 function tsInstantiationExpression(expression2) {
-    var typeParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var typeArguments = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     var node = {
         type: "TSInstantiationExpression",
         expression: expression2,
-        typeParameters: typeParameters
+        typeArguments: typeArguments
     };
     var defs = NODE_FIELDS.TSInstantiationExpression;
     validate$4(defs.expression, node, "expression", expression2, 1);
-    validate$4(defs.typeParameters, node, "typeParameters", typeParameters, 1);
+    validate$4(defs.typeArguments, node, "typeArguments", typeArguments, 1);
     return node;
 }
 function tsAsExpression$1(expression2, typeAnnotation2) {
@@ -23695,15 +23762,24 @@ function tsTypeAssertion(typeAnnotation2, expression2) {
     validate$4(defs.expression, node, "expression", expression2, 1);
     return node;
 }
-function tsEnumDeclaration$1(id, members) {
+function tsEnumBody(members) {
+    var node = {
+        type: "TSEnumBody",
+        members: members
+    };
+    var defs = NODE_FIELDS.TSEnumBody;
+    validate$4(defs.members, node, "members", members, 1);
+    return node;
+}
+function tsEnumDeclaration$1(id, body) {
     var node = {
         type: "TSEnumDeclaration",
         id: id,
-        members: members
+        body: body
     };
     var defs = NODE_FIELDS.TSEnumDeclaration;
     validate$4(defs.id, node, "id", id, 1);
-    validate$4(defs.members, node, "members", members, 1);
+    validate$4(defs.body, node, "body", body, 1);
     return node;
 }
 function tsEnumMember$1(id) {
@@ -23740,17 +23816,17 @@ function tsModuleBlock(body) {
     return node;
 }
 function tsImportType$1(argument) {
-    var qualifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null, typeParameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    var qualifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null, typeArguments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     var node = {
         type: "TSImportType",
         argument: argument,
         qualifier: qualifier,
-        typeParameters: typeParameters
+        typeArguments: typeArguments
     };
     var defs = NODE_FIELDS.TSImportType;
     validate$4(defs.argument, node, "argument", argument, 1);
     validate$4(defs.qualifier, node, "qualifier", qualifier, 1);
-    validate$4(defs.typeParameters, node, "typeParameters", typeParameters, 1);
+    validate$4(defs.typeArguments, node, "typeArguments", typeArguments, 1);
     return node;
 }
 function tsImportEqualsDeclaration(id, moduleReference) {
@@ -24623,6 +24699,9 @@ function assertTSSatisfiesExpression(node, opts) {
 function assertTSTypeAssertion(node, opts) {
     assert("TSTypeAssertion", node, opts);
 }
+function assertTSEnumBody(node, opts) {
+    assert("TSEnumBody", node, opts);
+}
 function assertTSEnumDeclaration(node, opts) {
     assert("TSEnumDeclaration", node, opts);
 }
@@ -26762,6 +26841,71 @@ function ParseErrorEnum(argument, syntaxPlugin) {
     return ParseErrorConstructors;
 }
 var Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(_templateObject())(PipelineOperatorErrors));
+function createDefaultOptions() {
+    return {
+        sourceType: "script",
+        sourceFilename: undefined,
+        startIndex: 0,
+        startColumn: 0,
+        startLine: 1,
+        allowAwaitOutsideFunction: false,
+        allowReturnOutsideFunction: false,
+        allowNewTargetOutsideFunction: false,
+        allowImportExportEverywhere: false,
+        allowSuperOutsideMethod: false,
+        allowUndeclaredExports: false,
+        plugins: [],
+        strictMode: null,
+        ranges: false,
+        tokens: false,
+        createImportExpressions: true,
+        createParenthesizedExpressions: false,
+        errorRecovery: false,
+        attachComment: true,
+        annexB: true
+    };
+}
+function getOptions(opts) {
+    var options = createDefaultOptions();
+    if (opts == null) {
+        return options;
+    }
+    if (opts.annexB != null && opts.annexB !== false) {
+        throw new Error("The `annexB` option can only be set to `false`.");
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.keys(options)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            if (opts[key] != null) options[key] = opts[key];
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (options.startLine === 1) {
+        if (opts.startIndex == null && options.startColumn > 0) {
+            options.startIndex = options.startColumn;
+        } else if (opts.startColumn == null && options.startIndex > 0) {
+            options.startColumn = options.startIndex;
+        }
+    } else if (opts.startColumn == null || opts.startIndex == null) {
+        {
+            throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
+        }
+    }
+    return options;
+}
 var defineProperty = Object.defineProperty;
 var toUnenumerable = function(object, key) {
     if (object) {
@@ -26788,7 +26932,7 @@ var estree = function(superClass) {
                 key: "parse",
                 value: function parse() {
                     var file2 = toESTreeLocation(_get(_get_prototype_of(ESTreeParserMixin.prototype), "parse", this).call(this));
-                    if (this.options.tokens) {
+                    if (this.optionFlags & 128) {
                         file2.tokens = file2.tokens.map(toESTreeLocation);
                     }
                     return file2;
@@ -26921,21 +27065,6 @@ var estree = function(superClass) {
                     delete node.directives;
                 }
             },
-            {
-                key: "pushClassMethod",
-                value: function pushClassMethod(classBody2, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-                    this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
-                    var typeParameters = method.typeParameters;
-                    if (typeParameters) {
-                        delete method.typeParameters;
-                        var fn = method.value;
-                        fn.typeParameters = typeParameters;
-                        fn.start = typeParameters.start;
-                        fn.loc.start = typeParameters.loc.start;
-                    }
-                    classBody2.body.push(method);
-                }
-            },
             {
                 key: "parsePrivateName",
                 value: function parsePrivateName() {
@@ -26993,9 +27122,22 @@ var estree = function(superClass) {
                     funcNode.type = "FunctionExpression";
                     delete funcNode.kind;
                     node.value = funcNode;
+                    var typeParameters = node.typeParameters;
+                    if (typeParameters) {
+                        delete node.typeParameters;
+                        funcNode.typeParameters = typeParameters;
+                        funcNode.start = typeParameters.start;
+                        funcNode.loc.start = typeParameters.loc.start;
+                    }
                     if (type === "ClassPrivateMethod") {
                         node.computed = false;
                     }
+                    if (node.abstract && this.hasPlugin("typescript")) {
+                        if (!funcNode.body) {
+                            funcNode.type = "TSEmptyBodyFunctionExpression";
+                        }
+                        return this.finishNode(node, "TSAbstractMethodDefinition");
+                    }
                     return this.finishNode(node, "MethodDefinition");
                 }
             },
@@ -27016,7 +27158,11 @@ var estree = function(superClass) {
                     var propertyNode = (_$_get = _get(_get_prototype_of(ESTreeParserMixin.prototype), "parseClassProperty", this)).call.apply(_$_get, [
                         this
                     ].concat(_to_consumable_array(args)));
-                    propertyNode.type = "PropertyDefinition";
+                    if (propertyNode.abstract && this.hasPlugin("typescript")) {
+                        propertyNode.type = "TSAbstractPropertyDefinition";
+                    } else {
+                        propertyNode.type = "PropertyDefinition";
+                    }
                     return propertyNode;
                 }
             },
@@ -27030,7 +27176,11 @@ var estree = function(superClass) {
                     var propertyNode = (_$_get = _get(_get_prototype_of(ESTreeParserMixin.prototype), "parseClassPrivateProperty", this)).call.apply(_$_get, [
                         this
                     ].concat(_to_consumable_array(args)));
-                    propertyNode.type = "PropertyDefinition";
+                    if (propertyNode.abstract && this.hasPlugin("typescript")) {
+                        propertyNode.type = "TSAbstractPropertyDefinition";
+                    } else {
+                        propertyNode.type = "PropertyDefinition";
+                    }
                     propertyNode.computed = false;
                     return propertyNode;
                 }
@@ -29328,6 +29478,14 @@ var CommentsParser = /*#__PURE__*/ function(BaseParser) {
                             case "ImportDeclaration":
                                 adjustInnerComments(node, node.specifiers, commentWS);
                                 break;
+                            case "TSEnumDeclaration":
+                                {
+                                    setInnerComments(node, comments);
+                                }
+                                break;
+                            case "TSEnumBody":
+                                adjustInnerComments(node, node.members, commentWS);
+                                break;
                             default:
                                 {
                                     setInnerComments(node, comments);
@@ -29991,7 +30149,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
         __publicField(_this, "tokens", []);
         __publicField(_this, "errorHandlers_readInt", {
             invalidDigit: function(pos, lineStart, curLine, radix) {
-                if (!_this.options.errorRecovery) return false;
+                if (!(_this.optionFlags & 1024)) return false;
                 _this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), {
                     radix: radix
                 });
@@ -30039,7 +30197,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
             key: "next",
             value: function next() {
                 this.checkKeywordEscapes();
-                if (this.options.tokens) {
+                if (this.optionFlags & 128) {
                     this.pushToken(new Token(this.state));
                 }
                 this.state.lastTokEndLoc = this.state.endLoc;
@@ -30206,7 +30364,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                     end: this.sourceToOffsetPos(end + commentEnd.length),
                     loc: new SourceLocation(startLoc, this.state.curPosition())
                 };
-                if (this.options.tokens) this.pushToken(comment);
+                if (this.optionFlags & 128) this.pushToken(comment);
                 return comment;
             }
         },
@@ -30232,7 +30390,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                     end: this.sourceToOffsetPos(end),
                     loc: new SourceLocation(startLoc, this.state.curPosition())
                 };
-                if (this.options.tokens) this.pushToken(comment);
+                if (this.optionFlags & 128) this.pushToken(comment);
                 return comment;
             }
         },
@@ -30240,7 +30398,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
             key: "skipSpace",
             value: function skipSpace() {
                 var spaceStart = this.state.pos;
-                var comments = [];
+                var comments = this.optionFlags & 2048 ? [] : null;
                 loop: while(this.state.pos < this.length){
                     var ch = this.input.charCodeAt(this.state.pos);
                     switch(ch){
@@ -30267,7 +30425,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                                         var comment = this.skipBlockComment("*/");
                                         if (comment !== undefined) {
                                             this.addComment(comment);
-                                            if (this.options.attachComment) comments.push(comment);
+                                            comments === null || comments === undefined ? undefined : comments.push(comment);
                                         }
                                         break;
                                     }
@@ -30276,7 +30434,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                                         var comment1 = this.skipLineComment(2);
                                         if (comment1 !== undefined) {
                                             this.addComment(comment1);
-                                            if (this.options.attachComment) comments.push(comment1);
+                                            comments === null || comments === undefined ? undefined : comments.push(comment1);
                                         }
                                         break;
                                     }
@@ -30287,24 +30445,24 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                         default:
                             if (isWhitespace(ch)) {
                                 ++this.state.pos;
-                            } else if (ch === 45 && !this.inModule && this.options.annexB) {
+                            } else if (ch === 45 && !this.inModule && this.optionFlags & 4096) {
                                 var pos = this.state.pos;
                                 if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
                                     var comment2 = this.skipLineComment(3);
                                     if (comment2 !== undefined) {
                                         this.addComment(comment2);
-                                        if (this.options.attachComment) comments.push(comment2);
+                                        comments === null || comments === undefined ? undefined : comments.push(comment2);
                                     }
                                 } else {
                                     break loop;
                                 }
-                            } else if (ch === 60 && !this.inModule && this.options.annexB) {
+                            } else if (ch === 60 && !this.inModule && this.optionFlags & 4096) {
                                 var pos1 = this.state.pos;
                                 if (this.input.charCodeAt(pos1 + 1) === 33 && this.input.charCodeAt(pos1 + 2) === 45 && this.input.charCodeAt(pos1 + 3) === 45) {
                                     var comment3 = this.skipLineComment(4);
                                     if (comment3 !== undefined) {
                                         this.addComment(comment3);
-                                        if (this.options.attachComment) comments.push(comment3);
+                                        comments === null || comments === undefined ? undefined : comments.push(comment3);
                                     }
                                 } else {
                                     break loop;
@@ -30314,7 +30472,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                             }
                     }
                 }
-                if (comments.length > 0) {
+                if ((comments === null || comments === undefined ? undefined : comments.length) > 0) {
                     var end = this.state.pos;
                     var commentWhitespace = {
                         start: this.sourceToOffsetPos(spaceStart),
@@ -31039,7 +31197,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                 var details = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
                 var loc = _instanceof(at, Position) ? at : at.loc.start;
                 var error = toParseError(loc, details);
-                if (!this.options.errorRecovery) throw error;
+                if (!(this.optionFlags & 1024)) throw error;
                 if (!this.isLookahead) this.state.errors.push(error);
                 return error;
             }
@@ -31747,7 +31905,7 @@ var Node$1 = function Node(parser, pos, loc) {
     this.start = pos;
     this.end = 0;
     this.loc = new SourceLocation(loc);
-    if (parser === null || parser === undefined ? undefined : parser.options.ranges) this.range = [
+    if ((parser === null || parser === undefined ? undefined : parser.optionFlags) & 64) this.range = [
         pos,
         0
     ];
@@ -31829,8 +31987,10 @@ var NodeUtils = /*#__PURE__*/ function(UtilParser) {
                 node.type = type;
                 node.end = endLoc.index;
                 node.loc.end = endLoc;
-                if (this.options.ranges) node.range[1] = endLoc.index;
-                if (this.options.attachComment) this.processComment(node);
+                if (this.optionFlags & 64) node.range[1] = endLoc.index;
+                if (this.optionFlags & 2048) {
+                    this.processComment(node);
+                }
                 return node;
             }
         },
@@ -31839,7 +31999,7 @@ var NodeUtils = /*#__PURE__*/ function(UtilParser) {
             value: function resetStartLocation(node, startLoc) {
                 node.start = startLoc.index;
                 node.loc.start = startLoc;
-                if (this.options.ranges) node.range[0] = startLoc.index;
+                if (this.optionFlags & 64) node.range[0] = startLoc.index;
             }
         },
         {
@@ -31848,7 +32008,7 @@ var NodeUtils = /*#__PURE__*/ function(UtilParser) {
                 var endLoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.lastTokEndLoc;
                 node.end = endLoc.index;
                 node.loc.end = endLoc;
-                if (this.options.ranges) node.range[1] = endLoc.index;
+                if (this.optionFlags & 64) node.range[1] = endLoc.index;
             }
         },
         {
@@ -32477,31 +32637,63 @@ var flow$1 = function(superClass) {
                     return this.finishNode(node, "TypeParameterDeclaration");
                 }
             },
+            {
+                key: "flowInTopLevelContext",
+                value: function flowInTopLevelContext(cb) {
+                    if (this.curContext() !== types$T.brace) {
+                        var oldContext = this.state.context;
+                        this.state.context = [
+                            oldContext[0]
+                        ];
+                        try {
+                            return cb();
+                        } finally{
+                            this.state.context = oldContext;
+                        }
+                    } else {
+                        return cb();
+                    }
+                }
+            },
+            {
+                key: "flowParseTypeParameterInstantiationInExpression",
+                value: function flowParseTypeParameterInstantiationInExpression() {
+                    if (this.reScan_lt() !== 47) return;
+                    return this.flowParseTypeParameterInstantiation();
+                }
+            },
             {
                 key: "flowParseTypeParameterInstantiation",
                 value: function flowParseTypeParameterInstantiation() {
+                    var _this = this;
                     var node = this.startNode();
                     var oldInType = this.state.inType;
-                    node.params = [];
                     this.state.inType = true;
-                    this.expect(47);
-                    var oldNoAnonFunctionType = this.state.noAnonFunctionType;
-                    this.state.noAnonFunctionType = false;
-                    while(!this.match(48)){
-                        node.params.push(this.flowParseType());
-                        if (!this.match(48)) {
-                            this.expect(12);
+                    node.params = [];
+                    this.flowInTopLevelContext(function() {
+                        _this.expect(47);
+                        var oldNoAnonFunctionType = _this.state.noAnonFunctionType;
+                        _this.state.noAnonFunctionType = false;
+                        while(!_this.match(48)){
+                            node.params.push(_this.flowParseType());
+                            if (!_this.match(48)) {
+                                _this.expect(12);
+                            }
                         }
+                        _this.state.noAnonFunctionType = oldNoAnonFunctionType;
+                    });
+                    this.state.inType = oldInType;
+                    if (!this.state.inType && this.curContext() === types$T.brace) {
+                        this.reScan_lt_gt();
                     }
-                    this.state.noAnonFunctionType = oldNoAnonFunctionType;
                     this.expect(48);
-                    this.state.inType = oldInType;
                     return this.finishNode(node, "TypeParameterInstantiation");
                 }
             },
             {
                 key: "flowParseTypeParameterInstantiationCallOrNew",
                 value: function flowParseTypeParameterInstantiationCallOrNew() {
+                    if (this.reScan_lt() !== 47) return;
                     var node = this.startNode();
                     var oldInType = this.state.inType;
                     node.params = [];
@@ -33764,9 +33956,9 @@ var flow$1 = function(superClass) {
                 key: "parseClassSuper",
                 value: function parseClassSuper(node) {
                     _get(_get_prototype_of(FlowParserMixin.prototype), "parseClassSuper", this).call(this, node);
-                    if (node.superClass && this.match(47)) {
+                    if (node.superClass && (this.match(47) || this.match(51))) {
                         {
-                            node.superTypeArguments = this.flowParseTypeParameterInstantiation();
+                            node.superTypeArguments = this.flowParseTypeParameterInstantiationInExpression();
                         }
                     }
                     if (this.isContextual(113)) {
@@ -34175,12 +34367,12 @@ var flow$1 = function(superClass) {
                         this.next();
                         var node = this.startNodeAt(startLoc);
                         node.callee = base;
-                        node.typeArguments = this.flowParseTypeParameterInstantiation();
+                        node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
                         this.expect(10);
                         node.arguments = this.parseCallExpressionArguments(11);
                         node.optional = true;
                         return this.finishCallExpression(node, true);
-                    } else if (!noCalls && this.shouldParseTypes() && this.match(47)) {
+                    } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
                         var node1 = this.startNodeAt(startLoc);
                         node1.callee = base;
                         var result = this.tryParse(function() {
@@ -34730,6 +34922,17 @@ var flow$1 = function(superClass) {
                     return this.finishNode(node, "EnumDeclaration");
                 }
             },
+            {
+                key: "jsxParseOpeningElementAfterName",
+                value: function jsxParseOpeningElementAfterName(node) {
+                    if (this.shouldParseTypes()) {
+                        if (this.match(47) || this.match(51)) {
+                            node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
+                        }
+                    }
+                    return _get(_get_prototype_of(FlowParserMixin.prototype), "jsxParseOpeningElementAfterName", this).call(this, node);
+                }
+            },
             {
                 key: "isLookaheadToken_lt",
                 value: function isLookaheadToken_lt() {
@@ -34741,6 +34944,31 @@ var flow$1 = function(superClass) {
                     return false;
                 }
             },
+            {
+                key: "reScan_lt_gt",
+                value: function reScan_lt_gt() {
+                    var type = this.state.type;
+                    if (type === 47) {
+                        this.state.pos -= 1;
+                        this.readToken_lt();
+                    } else if (type === 48) {
+                        this.state.pos -= 1;
+                        this.readToken_gt();
+                    }
+                }
+            },
+            {
+                key: "reScan_lt",
+                value: function reScan_lt() {
+                    var type = this.state.type;
+                    if (type === 51) {
+                        this.state.pos -= 2;
+                        this.finishOp(47, 1);
+                        return 47;
+                    }
+                    return type;
+                }
+            },
             {
                 key: "maybeUnwrapTypeCastExpression",
                 value: function maybeUnwrapTypeCastExpression(node) {
@@ -36574,8 +36802,14 @@ var typescript$3 = function(superClass) {
                     this.expect(10);
                     if (!this.match(134)) {
                         this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
+                        {
+                            node.argument = this.tsParseNonConditionalType();
+                        }
+                    } else {
+                        {
+                            node.argument = this.tsParseLiteralTypeNode();
+                        }
                     }
-                    node.argument = _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseExprAtom", this).call(this);
                     if (this.eat(12) && !this.match(11)) {
                         node.options = _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseMaybeAssignAllowIn", this).call(this);
                         this.eat(12);
@@ -36587,7 +36821,9 @@ var typescript$3 = function(superClass) {
                         node.qualifier = this.tsParseEntityName();
                     }
                     if (this.match(47)) {
-                        node.typeParameters = this.tsParseTypeArguments();
+                        {
+                            node.typeArguments = this.tsParseTypeArguments();
+                        }
                     }
                     return this.finishNode(node, "TSImportType");
                 }
@@ -36649,7 +36885,9 @@ var typescript$3 = function(superClass) {
                         node.exprName = this.tsParseEntityName();
                     }
                     if (!this.hasPrecedingLineBreak() && this.match(47)) {
-                        node.typeParameters = this.tsParseTypeArguments();
+                        {
+                            node.typeArguments = this.tsParseTypeArguments();
+                        }
                     }
                     return this.finishNode(node, "TSTypeQuery");
                 }
@@ -37149,7 +37387,7 @@ var typescript$3 = function(superClass) {
                             return this.tsParseTupleType();
                         case 10:
                             {
-                                if (!this.options.createParenthesizedExpressions) {
+                                if (!(this.optionFlags & 512)) {
                                     var startLoc = this.state.startLoc;
                                     this.next();
                                     var type = this.tsParseType();
@@ -37531,10 +37769,12 @@ var typescript$3 = function(superClass) {
                     var delimitedList = this.tsParseDelimitedList("HeritageClauseElement", function() {
                         var node = _this.startNode();
                         node.expression = _this.tsParseEntityName();
-                        if (_this.match(47)) {
-                            node.typeParameters = _this.tsParseTypeArguments();
+                        {
+                            if (_this.match(47)) {
+                                node.typeArguments = _this.tsParseTypeArguments();
+                            }
+                            return _this.finishNode(node, token === "extends" ? "TSInterfaceHeritage" : "TSClassImplements");
                         }
-                        return _this.finishNode(node, token === "extends" ? "TSInterfaceHeritage" : "TSClassImplements");
                     });
                     if (!delimitedList.length) {
                         this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {
@@ -37589,16 +37829,20 @@ var typescript$3 = function(superClass) {
                 }
             },
             {
-                key: "tsInNoContext",
-                value: function tsInNoContext(cb) {
-                    var oldContext = this.state.context;
-                    this.state.context = [
-                        oldContext[0]
-                    ];
-                    try {
+                key: "tsInTopLevelContext",
+                value: function tsInTopLevelContext(cb) {
+                    if (this.curContext() !== types$T.brace) {
+                        var oldContext = this.state.context;
+                        this.state.context = [
+                            oldContext[0]
+                        ];
+                        try {
+                            return cb();
+                        } finally{
+                            this.state.context = oldContext;
+                        }
+                    } else {
                         return cb();
-                    } finally{
-                        this.state.context = oldContext;
                     }
                 }
             },
@@ -37686,10 +37930,20 @@ var typescript$3 = function(superClass) {
                     this.expectContextual(126);
                     node.id = this.parseIdentifier();
                     this.checkIdentifier(node.id, node.const ? 8971 : 8459);
+                    {
+                        node.body = this.tsParseEnumBody();
+                    }
+                    return this.finishNode(node, "TSEnumDeclaration");
+                }
+            },
+            {
+                key: "tsParseEnumBody",
+                value: function tsParseEnumBody() {
+                    var node = this.startNode();
                     this.expect(5);
                     node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
                     this.expect(8);
-                    return this.finishNode(node, "TSEnumDeclaration");
+                    return this.finishNode(node, "TSEnumBody");
                 }
             },
             {
@@ -37984,7 +38238,7 @@ var typescript$3 = function(superClass) {
                     var _this = this;
                     var node = this.startNode();
                     node.params = this.tsInType(function() {
-                        return _this.tsInNoContext(function() {
+                        return _this.tsInTopLevelContext(function() {
                             _this.expect(47);
                             return _this.tsParseDelimitedList("TypeParametersOrArguments", _this.tsParseType.bind(_this));
                         });
@@ -38192,7 +38446,9 @@ var typescript$3 = function(superClass) {
                             }
                             if (tokenIsTemplate(_this.state.type)) {
                                 var result2 = _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseTaggedTemplateExpression", _this).call(_this, base, startLoc, state);
-                                result2.typeParameters = typeArguments;
+                                {
+                                    result2.typeArguments = typeArguments;
+                                }
                                 return result2;
                             }
                             if (!noCalls && _this.eat(10)) {
@@ -38200,7 +38456,9 @@ var typescript$3 = function(superClass) {
                                 node2.callee = base;
                                 node2.arguments = _this.parseCallExpressionArguments(11);
                                 _this.tsCheckForInvalidTypeCasts(node2.arguments);
-                                node2.typeParameters = typeArguments;
+                                {
+                                    node2.typeArguments = typeArguments;
+                                }
                                 if (state.optionalChainMember) {
                                     node2.optional = isOptionalCall;
                                 }
@@ -38212,7 +38470,9 @@ var typescript$3 = function(superClass) {
                             }
                             var node = _this.startNodeAt(startLoc);
                             node.expression = base;
-                            node.typeParameters = typeArguments;
+                            {
+                                node.typeArguments = typeArguments;
+                            }
                             return _this.finishNode(node, "TSInstantiationExpression");
                         });
                         if (missingParenErrorLoc) {
@@ -38235,7 +38495,9 @@ var typescript$3 = function(superClass) {
                     _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseNewCallee", this).call(this, node);
                     var callee = node.callee;
                     if (callee.type === "TSInstantiationExpression" && !((_callee_extra = callee.extra) === null || _callee_extra === undefined ? undefined : _callee_extra.parenthesized)) {
-                        node.typeParameters = callee.typeParameters;
+                        {
+                            node.typeArguments = callee.typeArguments;
+                        }
                         node.callee = callee.expression;
                     }
                 }
@@ -39021,17 +39283,19 @@ var typescript$3 = function(superClass) {
             },
             {
                 key: "parseMaybeDecoratorArguments",
-                value: function parseMaybeDecoratorArguments(expr) {
+                value: function parseMaybeDecoratorArguments(expr, startLoc) {
                     if (this.match(47) || this.match(51)) {
                         var typeArguments = this.tsParseTypeArgumentsInExpression();
                         if (this.match(10)) {
-                            var call2 = _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseMaybeDecoratorArguments", this).call(this, expr);
-                            call2.typeParameters = typeArguments;
+                            var call2 = _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseMaybeDecoratorArguments", this).call(this, expr, startLoc);
+                            {
+                                call2.typeArguments = typeArguments;
+                            }
                             return call2;
                         }
                         this.unexpected(null, 10);
                     }
-                    return _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseMaybeDecoratorArguments", this).call(this, expr);
+                    return _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseMaybeDecoratorArguments", this).call(this, expr, startLoc);
                 }
             },
             {
@@ -39159,7 +39423,11 @@ var typescript$3 = function(superClass) {
                         var typeArguments = this.tsTryParseAndCatch(function() {
                             return _this.tsParseTypeArgumentsInExpression();
                         });
-                        if (typeArguments) node.typeParameters = typeArguments;
+                        if (typeArguments) {
+                            {
+                                node.typeArguments = typeArguments;
+                            }
+                        }
                     }
                     return _get(_get_prototype_of(TypeScriptParserMixin.prototype), "jsxParseOpeningElementAfterName", this).call(this, node);
                 }
@@ -39234,8 +39502,9 @@ var typescript$3 = function(superClass) {
                 value: function parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
                     var method = _get(_get_prototype_of(TypeScriptParserMixin.prototype), "parseMethod", this).call(this, node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
                     if (method.abstract) {
-                        var hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
-                        if (hasBody) {
+                        var hasEstreePlugin = this.hasPlugin("estree");
+                        var methodFn = hasEstreePlugin ? method.value : method;
+                        if (methodFn.body) {
                             var key = method.key;
                             this.raise(TSErrors.AbstractMethodHasImplementation, method, {
                                 methodName: key.type === "Identifier" && !method.computed ? key.name : "[".concat(this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end)), "]")
@@ -39846,71 +40115,6 @@ var mixinPlugins = {
     placeholders: placeholders
 };
 var mixinPluginNames = Object.keys(mixinPlugins);
-function createDefaultOptions() {
-    return {
-        sourceType: "script",
-        sourceFilename: undefined,
-        startIndex: 0,
-        startColumn: 0,
-        startLine: 1,
-        allowAwaitOutsideFunction: false,
-        allowReturnOutsideFunction: false,
-        allowNewTargetOutsideFunction: false,
-        allowImportExportEverywhere: false,
-        allowSuperOutsideMethod: false,
-        allowUndeclaredExports: false,
-        plugins: [],
-        strictMode: null,
-        ranges: false,
-        tokens: false,
-        createImportExpressions: true,
-        createParenthesizedExpressions: false,
-        errorRecovery: false,
-        attachComment: true,
-        annexB: true
-    };
-}
-function getOptions(opts) {
-    var options = createDefaultOptions();
-    if (opts == null) {
-        return options;
-    }
-    if (opts.annexB != null && opts.annexB !== false) {
-        throw new Error("The `annexB` option can only be set to `false`.");
-    }
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = Object.keys(options)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var key = _step.value;
-            if (opts[key] != null) options[key] = opts[key];
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    if (options.startLine === 1) {
-        if (opts.startIndex == null && options.startColumn > 0) {
-            options.startIndex = options.startColumn;
-        } else if (opts.startColumn == null && options.startIndex > 0) {
-            options.startColumn = options.startIndex;
-        }
-    } else if (opts.startColumn == null || opts.startIndex == null) {
-        {
-            throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
-        }
-    }
-    return options;
-}
 var ExpressionParser = /*#__PURE__*/ function(LValParser) {
     _inherits$1(ExpressionParser, LValParser);
     function ExpressionParser() {
@@ -39962,7 +40166,7 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
                 this.finalizeRemainingComments();
                 expr.comments = this.comments;
                 expr.errors = this.state.errors;
-                if (this.options.tokens) {
+                if (this.optionFlags & 128) {
                     expr.tokens = this.tokens;
                 }
                 return expr;
@@ -40584,7 +40788,7 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
                             return this.parseImportMetaProperty(node);
                         }
                         if (this.match(10)) {
-                            if (this.options.createImportExpressions) {
+                            if (this.optionFlags & 256) {
                                 return this.parseImportCall(node);
                             } else {
                                 return this.finishNode(node, "Import");
@@ -40853,9 +41057,9 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
             value: function parseSuper() {
                 var node = this.startNode();
                 this.next();
-                if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
+                if (this.match(10) && !this.scope.allowDirectSuper && !(this.optionFlags & 16)) {
                     this.raise(Errors.SuperNotAllowed, node);
-                } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
+                } else if (!this.scope.allowSuper && !(this.optionFlags & 16)) {
                     this.raise(Errors.UnexpectedSuper, node);
                 }
                 if (!this.match(10) && !this.match(0) && !this.match(16)) {
@@ -40921,7 +41125,7 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
                 } else if (this.isContextual(105) || this.isContextual(97)) {
                     var isSource = this.isContextual(105);
                     this.expectPlugin(isSource ? "sourcePhaseImports" : "deferredImportEvaluation");
-                    if (!this.options.createImportExpressions) {
+                    if (!(this.optionFlags & 256)) {
                         throw this.raise(Errors.DynamicImportPhaseRequiresImportExpressions, this.state.startLoc, {
                             phase: this.state.value
                         });
@@ -41074,7 +41278,7 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
         {
             key: "wrapParenthesis",
             value: function wrapParenthesis(startLoc, expression2) {
-                if (!this.options.createParenthesizedExpressions) {
+                if (!(this.optionFlags & 512)) {
                     this.addExtra(expression2, "parenthesized", true);
                     this.addExtra(expression2, "parenStart", startLoc.index);
                     this.takeSurroundingComments(expression2, startLoc.index, this.state.lastTokEndLoc.index);
@@ -41114,7 +41318,7 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
                     var meta = this.createIdentifier(this.startNodeAtNode(node), "new");
                     this.next();
                     var metaProp = this.parseMetaProperty(node, meta, "target");
-                    if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
+                    if (!this.scope.inNonArrowFunction && !this.scope.inClass && !(this.optionFlags & 4)) {
                         this.raise(Errors.UnexpectedNewTarget, metaProp);
                     }
                     return metaProp;
@@ -41730,7 +41934,7 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
         {
             key: "recordAwaitIfAllowed",
             value: function recordAwaitIfAllowed() {
-                var isAwaitAllowed = this.prodParam.hasAwait || this.options.allowAwaitOutsideFunction && !this.scope.inFunction;
+                var isAwaitAllowed = this.prodParam.hasAwait || this.optionFlags & 1 && !this.scope.inFunction;
                 if (isAwaitAllowed && !this.scope.inFunction) {
                     this.state.hasTopLevelAwait = true;
                 }
@@ -41745,7 +41949,7 @@ var ExpressionParser = /*#__PURE__*/ function(LValParser) {
                 if (this.eat(55)) {
                     this.raise(Errors.ObsoleteAwaitStar, node);
                 }
-                if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
+                if (!this.scope.inFunction && !(this.optionFlags & 1)) {
                     if (this.isAmbiguousAwait()) {
                         this.ambiguousScriptDifferentAst = true;
                     } else {
@@ -42041,7 +42245,7 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
             value: function parseTopLevel(file2, program3) {
                 file2.program = this.parseProgram(program3);
                 file2.comments = this.comments;
-                if (this.options.tokens) {
+                if (this.optionFlags & 128) {
                     file2.tokens = babel7CompatTokens(this.tokens, this.input, this.startIndex);
                 }
                 return this.finishNode(file2, "File");
@@ -42055,7 +42259,7 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
                 program3.interpreter = this.parseInterpreterDirective();
                 this.parseBlockBody(program3, true, true, end);
                 if (this.inModule) {
-                    if (!this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
+                    if (!(this.optionFlags & 32) && this.scope.undefinedExports.size > 0) {
                         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                         try {
                             for(var _iterator = Array.from(this.scope.undefinedExports)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
@@ -42341,7 +42545,7 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
                         }
                     case 82:
                         {
-                            if (!this.options.allowImportExportEverywhere && !topLevel) {
+                            if (!(this.optionFlags & 8) && !topLevel) {
                                 this.raise(Errors.UnexpectedImportExport, this.state.startLoc);
                             }
                             this.next();
@@ -42383,7 +42587,7 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
         {
             key: "assertModuleNodeAllowed",
             value: function assertModuleNodeAllowed(node) {
-                if (!this.options.allowImportExportEverywhere && !this.inModule) {
+                if (!(this.optionFlags & 8) && !this.inModule) {
                     this.raise(Errors.ImportOutsideModule, node);
                 }
             }
@@ -42399,12 +42603,13 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
             key: "maybeTakeDecorators",
             value: function maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
                 if (maybeDecorators) {
-                    if (classNode.decorators && classNode.decorators.length > 0) {
-                        var _classNode_decorators;
+                    var _classNode_decorators;
+                    if ((_classNode_decorators = classNode.decorators) === null || _classNode_decorators === undefined ? undefined : _classNode_decorators.length) {
+                        var _classNode_decorators1;
                         if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
                             this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);
                         }
-                        (_classNode_decorators = classNode.decorators).unshift.apply(_classNode_decorators, _to_consumable_array(maybeDecorators));
+                        (_classNode_decorators1 = classNode.decorators).unshift.apply(_classNode_decorators1, _to_consumable_array(maybeDecorators));
                     } else {
                         classNode.decorators = maybeDecorators;
                     }
@@ -42459,7 +42664,7 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
                         this.expect(11);
                         expr = this.wrapParenthesis(startLoc2, expr);
                         var paramsStartLoc = this.state.startLoc;
-                        node.expression = this.parseMaybeDecoratorArguments(expr);
+                        node.expression = this.parseMaybeDecoratorArguments(expr, startLoc2);
                         if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) {
                             this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);
                         }
@@ -42477,7 +42682,7 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
                             node2.computed = false;
                             expr = this.finishNode(node2, "MemberExpression");
                         }
-                        node.expression = this.parseMaybeDecoratorArguments(expr);
+                        node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);
                     }
                 } else {
                     node.expression = this.parseExprSubscripts();
@@ -42487,9 +42692,9 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
         },
         {
             key: "parseMaybeDecoratorArguments",
-            value: function parseMaybeDecoratorArguments(expr) {
+            value: function parseMaybeDecoratorArguments(expr, startLoc) {
                 if (this.eat(10)) {
-                    var node = this.startNodeAtNode(expr);
+                    var node = this.startNodeAt(startLoc);
                     node.callee = expr;
                     node.arguments = this.parseCallExpressionArguments(11);
                     this.toReferencedList(node.arguments);
@@ -42666,7 +42871,7 @@ var StatementParser = /*#__PURE__*/ function(ExpressionParser) {
         {
             key: "parseReturnStatement",
             value: function parseReturnStatement(node) {
-                if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
+                if (!this.prodParam.hasReturn && !(this.optionFlags & 2)) {
                     this.raise(Errors.IllegalReturn, this.state.startLoc);
                 }
                 this.next();
@@ -44294,6 +44499,47 @@ var Parser$1 = /*#__PURE__*/ function(StatementParser) {
         _this.plugins = pluginsMap;
         _this.filename = options.sourceFilename;
         _this.startIndex = options.startIndex;
+        var optionFlags = 0;
+        if (options.allowAwaitOutsideFunction) {
+            optionFlags |= 1;
+        }
+        if (options.allowReturnOutsideFunction) {
+            optionFlags |= 2;
+        }
+        if (options.allowImportExportEverywhere) {
+            optionFlags |= 8;
+        }
+        if (options.allowSuperOutsideMethod) {
+            optionFlags |= 16;
+        }
+        if (options.allowUndeclaredExports) {
+            optionFlags |= 32;
+        }
+        if (options.allowNewTargetOutsideFunction) {
+            optionFlags |= 4;
+        }
+        if (options.ranges) {
+            optionFlags |= 64;
+        }
+        if (options.tokens) {
+            optionFlags |= 128;
+        }
+        if (options.createImportExpressions) {
+            optionFlags |= 256;
+        }
+        if (options.createParenthesizedExpressions) {
+            optionFlags |= 512;
+        }
+        if (options.errorRecovery) {
+            optionFlags |= 1024;
+        }
+        if (options.attachComment) {
+            optionFlags |= 2048;
+        }
+        if (options.annexB) {
+            optionFlags |= 4096;
+        }
+        _this.optionFlags = optionFlags;
         return _this;
     }
     _create_class(Parser, [
@@ -46927,7 +47173,7 @@ function TSInferType$1(node, parent) {
 }
 function TSInstantiationExpression$1(node, parent) {
     var parentType = parent.type;
-    return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeParameters;
+    return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeArguments;
 }
 function BinaryExpression$1(node, parent, tokenContext, inForStatementInit) {
     return node.operator === "in" && inForStatementInit;
@@ -47538,7 +47784,9 @@ function childrenIterator(node) {
 }
 function TaggedTemplateExpression$1(node) {
     this.print(node.tag);
-    this.print(node.typeParameters);
+    {
+        this.print(node.typeArguments);
+    }
     this.print(node.quasi);
 }
 function TemplateElement$1() {
@@ -47614,7 +47862,6 @@ function NewExpression$1(node, parent) {
         return;
     }
     this.print(node.typeArguments);
-    this.print(node.typeParameters);
     if (node.optional) {
         this.token("?.");
     }
@@ -47673,7 +47920,6 @@ function OptionalMemberExpression(node) {
 }
 function OptionalCallExpression$1(node) {
     this.print(node.callee);
-    this.print(node.typeParameters);
     if (node.optional) {
         this.token("?.");
     }
@@ -47687,7 +47933,6 @@ function OptionalCallExpression$1(node) {
 function CallExpression$2(node) {
     this.print(node.callee);
     this.print(node.typeArguments);
-    this.print(node.typeParameters);
     this.tokenChar(40);
     var exit = this.enterDelimited();
     this.printList(node.arguments, this.shouldPrintTrailingComma(")"));
@@ -48830,14 +49075,6 @@ function BigIntLiteral(node) {
     }
     this.word(node.value + "n");
 }
-function DecimalLiteral(node) {
-    var raw = this.getPossibleRaw(node);
-    if (!this.format.minified && raw !== undefined) {
-        this.word(raw);
-        return;
-    }
-    this.word(node.value + "m");
-}
 var validTopicTokenSet = /* @__PURE__ */ new Set([
     "^^",
     "@@",
@@ -49593,7 +49830,9 @@ function spaceSeparator() {
 function JSXOpeningElement$1(node) {
     this.tokenChar(60);
     this.print(node.name);
-    this.print(node.typeParameters);
+    {
+        this.print(node.typeArguments);
+    }
     if (node.attributes.length > 0) {
         this.space();
         this.printJoin(node.attributes, undefined, undefined, spaceSeparator);
@@ -49871,8 +50110,9 @@ function TSTypeQuery$1(node) {
     this.word("typeof");
     this.space();
     this.print(node.exprName);
-    if (node.typeParameters) {
-        this.print(node.typeParameters);
+    var typeArguments = node.typeArguments;
+    if (typeArguments) {
+        this.print(typeArguments);
     }
 }
 function TSTypeLiteral$1(node) {
@@ -50010,7 +50250,7 @@ function TSLiteralType(node) {
 }
 function TSClassImplements(node) {
     this.print(node.expression);
-    this.print(node.typeParameters);
+    this.print(node.typeArguments);
 }
 function TSInterfaceDeclaration$1(node) {
     var declare = node.declare, id = node.id, typeParameters = node.typeParameters, extendz = node.extends, body = node.body;
@@ -50071,11 +50311,12 @@ function TSTypeAssertion(node) {
 }
 function TSInstantiationExpression(node) {
     this.print(node.expression);
-    this.print(node.typeParameters);
+    {
+        this.print(node.typeArguments);
+    }
 }
 function TSEnumDeclaration$1(node) {
-    var _this = this;
-    var declare = node.declare, isConst = node.const, id = node.id, members = node.members;
+    var declare = node.declare, isConst = node.const, id = node.id;
     if (declare) {
         this.word("declare");
         this.space();
@@ -50088,9 +50329,15 @@ function TSEnumDeclaration$1(node) {
     this.space();
     this.print(id);
     this.space();
+    {
+        this.print(node.body);
+    }
+}
+function TSEnumBody(node) {
+    var _this = this;
     printBraced(this, node, function() {
         var _this_shouldPrintTrailingComma;
-        return _this.printList(members, (_this_shouldPrintTrailingComma = _this.shouldPrintTrailingComma("}")) !== null && _this_shouldPrintTrailingComma !== undefined ? _this_shouldPrintTrailingComma : true, true, true);
+        return _this.printList(node.members, (_this_shouldPrintTrailingComma = _this.shouldPrintTrailingComma("}")) !== null && _this_shouldPrintTrailingComma !== undefined ? _this_shouldPrintTrailingComma : false, true, true);
     });
 }
 function TSEnumMember$1(node) {
@@ -50130,17 +50377,22 @@ function TSModuleBlock$1(node) {
     });
 }
 function TSImportType$1(node) {
-    var argument = node.argument, qualifier = node.qualifier, typeParameters = node.typeParameters;
+    var argument = node.argument, qualifier = node.qualifier, options = node.options;
     this.word("import");
     this.tokenChar(40);
     this.print(argument);
+    if (options) {
+        this.tokenChar(44);
+        this.print(options);
+    }
     this.tokenChar(41);
     if (qualifier) {
         this.tokenChar(46);
         this.print(qualifier);
     }
-    if (typeParameters) {
-        this.print(typeParameters);
+    var typeArguments = node.typeArguments;
+    if (typeArguments) {
+        this.print(typeArguments);
     }
 }
 function TSImportEqualsDeclaration(node) {
@@ -50303,7 +50555,6 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     ConditionalExpression: ConditionalExpression$2,
     ContinueStatement: ContinueStatement$1,
     DebuggerStatement: DebuggerStatement$1,
-    DecimalLiteral: DecimalLiteral,
     DeclareClass: DeclareClass,
     DeclareExportAllDeclaration: DeclareExportAllDeclaration,
     DeclareExportDeclaration: DeclareExportDeclaration,
@@ -50440,10 +50691,10 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     TSConstructorType: TSConstructorType$1,
     TSDeclareFunction: TSDeclareFunction$1,
     TSDeclareMethod: TSDeclareMethod$1,
+    TSEnumBody: TSEnumBody,
     TSEnumDeclaration: TSEnumDeclaration$1,
     TSEnumMember: TSEnumMember$1,
     TSExportAssignment: TSExportAssignment$1,
-    TSExpressionWithTypeArguments: TSClassImplements,
     TSExternalModuleReference: TSExternalModuleReference,
     TSFunctionType: TSFunctionType$1,
     TSImportEqualsDeclaration: TSImportEqualsDeclaration,
@@ -50541,7 +50792,7 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     tsPrintPropertyOrMethodName: tsPrintPropertyOrMethodName,
     tsPrintSignatureDeclarationBase: tsPrintSignatureDeclarationBase
 });
-var isExpression2 = lib_exports.isExpression, isFunction3 = lib_exports.isFunction, isStatement3 = lib_exports.isStatement, isClassBody2 = lib_exports.isClassBody, isTSInterfaceBody2 = lib_exports.isTSInterfaceBody, isTSEnumDeclaration2 = lib_exports.isTSEnumDeclaration;
+var isExpression2 = lib_exports.isExpression, isFunction3 = lib_exports.isFunction, isStatement3 = lib_exports.isStatement, isClassBody2 = lib_exports.isClassBody, isTSInterfaceBody2 = lib_exports.isTSInterfaceBody, isTSEnumMember2 = lib_exports.isTSEnumMember;
 var SCIENTIFIC_NOTATION = /e/i;
 var ZERO_DECIMAL_INTEGER = /\.0+$/;
 var HAS_NEWLINE = /[\n\r\u2028\u2029]/;
@@ -51426,7 +51677,7 @@ var Printer = /*#__PURE__*/ function() {
                         }
                         if (len === 1) {
                             var singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
-                            var shouldSkipNewline = singleLine && !isStatement3(node) && !isClassBody2(parent) && !isTSInterfaceBody2(parent) && !isTSEnumDeclaration2(parent);
+                            var shouldSkipNewline = singleLine && !isStatement3(node) && !isClassBody2(parent) && !isTSInterfaceBody2(parent) && !isTSEnumMember2(node);
                             if (type === 0) {
                                 this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction3(parent, {
                                     body: node
@@ -51947,7 +52198,7 @@ function verify$1(visitor) {
             }
             if (shouldIgnoreKey(nodeType)) continue;
             if (!TYPES2.includes(nodeType)) {
-                throw new Error("You gave us a visitor for the node type ".concat(nodeType, " but it's not a valid type in @babel/traverse ", "8.0.0-alpha.14"));
+                throw new Error("You gave us a visitor for the node type ".concat(nodeType, " but it's not a valid type in @babel/traverse ", "8.0.0-alpha.15"));
             }
             var visitors2 = visitor[nodeType];
             if ((typeof visitors2 === "undefined" ? "undefined" : _type_of(visitors2)) === "object") {
@@ -78506,11 +78757,17 @@ const isPrev$1 = (path) => {
 const isNextParent$5 = (path) => isNext$r(path.parentPath);
 const isLast$e = (path) => isParentProgram$1(path) && !isNext$r(path);
 
-is$3.isNextObject = (a) => a.getNextSibling().isObjectExpression();
-is$3.isPrevObject = (a) => a.getPrevSibling().isObjectExpression();
+is$3.isNextObject = (a) => a
+    .getNextSibling()
+    .isObjectExpression();
+is$3.isPrevObject = (a) => a
+    .getPrevSibling()
+    .isObjectExpression();
 
 is$3.isFirst = (path) => path.node === path.parentPath.node.body?.[0];
-is$3.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
+is$3.isPrevBody = (path) => path
+    .getPrevSibling()
+    .isBlockStatement();
 is$3.isNext = isNext$r;
 is$3.isPrev = isPrev$1;
 is$3.isNextParent = isNextParent$5;
@@ -78606,15 +78863,15 @@ is$3.satisfy = (conditions) => (path) => {
     return false;
 };
 
-const parseNode$2 = (path) => path.node || path;
+const parseNode$3 = (path) => path.node || path;
 
 is$3.hasCoupleTrailingComments = (path) => {
-    const node = parseNode$2(path);
+    const node = parseNode$3(path);
     return node?.trailingComments?.length > 1;
 };
 
 is$3.hasTrailingComment = (path) => {
-    const node = parseNode$2(path);
+    const node = parseNode$3(path);
     return node.trailingComments?.length;
 };
 
@@ -78844,9 +79101,7 @@ const isFnParam = (path) => {
     if (!parentPath.isFunction())
         return false;
     
-    return parentPath
-        .get('params')
-        .includes(path);
+    return parentPath.get('params').includes(path);
 };
 
 function isSameLine(path, loc) {
@@ -78996,9 +79251,7 @@ comment.parseComments = parseComments$7;
 
 const {parseComments: parseComments$6} = comment;
 
-function parseParams(path) {
-    return path.get('params');
-}
+const parseParams = (path) => path.get('params');
 
 params.printParams = (path, printer, semantics, customization = {}) => {
     const {extra, typeParameters} = path.node;
@@ -79442,7 +79695,7 @@ unaryExpressions$1.UnaryExpression = unaryExpression;
 unaryExpressions$1.UpdateExpression = unaryExpression;
 
 unaryExpressions$1.AwaitExpression = maybeParens$b((path, {print}) => {
-    printUnary(path, 'await', {
+    printUnary('await', {
         print,
     });
 });
@@ -79459,7 +79712,7 @@ unaryExpressions$1.YieldExpression = maybeParens$b((path, {print, maybe}) => {
 unaryExpressions$1.ThrowStatement = (path, {print, indent, maybe}) => {
     indent();
     
-    printUnary(path, 'throw', {
+    printUnary('throw', {
         print,
     });
     
@@ -79468,7 +79721,7 @@ unaryExpressions$1.ThrowStatement = (path, {print, indent, maybe}) => {
     maybe.print.breakline(isNext$m(path));
 };
 
-function printUnary(path, name, {print}) {
+function printUnary(name, {print}) {
     print(`${name} `);
     print('__argument');
 }
@@ -79633,16 +79886,14 @@ const isIfUp = (path) => {
     if (!ifPath)
         return is;
     
-    ifPath
-        .get('test')
-        .traverse({
-            MemberExpression(currentPath) {
-                if (path === currentPath) {
-                    is = true;
-                    path.stop();
-                }
-            },
-        });
+    ifPath.get('test').traverse({
+        MemberExpression(currentPath) {
+            if (path === currentPath) {
+                is = true;
+                path.stop();
+            }
+        },
+    });
     
     return is;
 };
@@ -79728,9 +79979,7 @@ const classVisitor = maybeDecorators$2((path, printer, semantics) => {
     
     if (node.implements) {
         print(' implements ');
-        path
-            .get('implements')
-            .forEach(print);
+        path.get('implements').forEach(print);
     }
     
     print.space();
@@ -79801,7 +80050,7 @@ const CallExpression$1 = maybeParens$9((path, {indent, print, maybe, traverse})
     const isParentCall = tooLong$1(args) && path.parentPath.isCallExpression();
     
     const callee = path.get('callee');
-    const typeParameters = path.get('typeParameters');
+    const typeParameters = path.get('typeArguments');
     
     traverse(callee);
     
@@ -79897,7 +80146,7 @@ newExpression.NewExpression = {
         const {print, maybe} = printer;
         print('new ');
         print('__callee');
-        print('__typeParameters');
+        print('__typeArguments');
         
         const args = path.get('arguments');
         maybePrintOpenBrace(path, printer, semantics);
@@ -80075,9 +80324,7 @@ const notLastArgInsideCall = (path) => {
     if (isCoupleLines$8(path))
         return false;
     
-    return path !== parentPath
-        .get('arguments')
-        .at(-1);
+    return path !== parentPath.get('arguments').at(-1);
 };
 
 const ONE_LINE$2 = true;
@@ -80940,11 +81187,15 @@ const {entries: entries$a} = Object;
 const isOneDeclaration = ({node}) => node.declarations.length === 1;
 
 remove$2.remove = (path) => {
-    const programBlock = path.scope.getProgramParent().block;
+    const {scope} = path;
     const prev = getPrevSibling(path);
     
-    if (path.scope.block === programBlock && !prev.node)
-        programBlock.comments = getComments(path);
+    if (scope) {
+        const programBlock = scope.getProgramParent().block;
+        
+        if (scope.block === programBlock && !prev.node)
+            programBlock.comments = getComments(path);
+    }
     
     if (!path.parentPath.isArrayPattern()) {
         path.remove();
@@ -81346,7 +81597,16 @@ var replaceWith$6 = {};
 const {maybeBody} = maybeBody$2;
 const {assign: assign$b} = Object;
 
+const parseNode$2 = (a) => {
+    if (a.node)
+        return a.node;
+    
+    return a;
+};
+
 replaceWith$6.replaceWith = (path, node) => {
+    node = parseNode$2(node);
+    
     if (path?.parentPath?.isExpressionStatement() && !path.parentPath.isProgram())
         path = path.parentPath;
     
@@ -81734,13 +81994,9 @@ function isNumbers(elements) {
     return false;
 }
 
-function isLastArg({parentPath}) {
-    return !parentPath.isCallExpression();
-}
+const isLastArg = ({parentPath}) => !parentPath.isCallExpression();
 
-function isParentProperty(path) {
-    return path.find(isObjectProperty);
-}
+const isParentProperty = (path) => path.find(isObjectProperty);
 
 newline.isIncreaseIndent = isIncreaseIndent$1;
 function isIncreaseIndent$1(path) {
@@ -81913,9 +82169,7 @@ const isSpreadBeforeObject = (a) => {
     if (prev.getPrevSibling().isObjectExpression())
         return false;
     
-    return prev
-        .get('argument')
-        .isCallExpression();
+    return prev.get('argument').isCallExpression();
 };
 
 const isNextSimple = (a) => {
@@ -83010,9 +83264,7 @@ const isNextAssign = (path) => {
     if (parentPath.isBlockStatement() && parentPath.node.body.length < 3)
         return false;
     
-    return nextPath
-        .get('expression')
-        .isAssignmentExpression();
+    return nextPath.get('expression').isAssignmentExpression();
 };
 
 var ifStatement = {};
@@ -84201,9 +84453,7 @@ program.Program = (path, printer, semantics) => {
         maybe.write.newline(body.length);
     }
     
-    path
-        .get('body')
-        .forEach(traverse);
+    path.get('body').forEach(traverse);
     
     if (directives.length && !body.length)
         return;
@@ -84507,8 +84757,14 @@ const {
 
 const {markAfter: markAfter$2} = mark;
 const {maybeDeclare: maybeDeclare$3} = maybeDeclare$6;
-const isNextType = (a) => a.getNextSibling().isTSTypeAliasDeclaration();
-const isNextExport = (a) => a.getNextSibling().isExportDeclaration();
+
+const isNextType = (a) => a
+    .getNextSibling()
+    .isTSTypeAliasDeclaration();
+
+const isNextExport = (a) => a
+    .getNextSibling()
+    .isExportDeclaration();
 
 tsTypeAliasDeclaration.TSTypeAliasDeclaration = {
     beforeIf: (path) => !path.parentPath.isExportDeclaration(),
@@ -84804,9 +85060,7 @@ tsInterfaceDeclaration.TSInterfaceDeclaration = {
         
         if (node.extends) {
             print(' extends ');
-            path
-                .get('extends')
-                .map(print);
+            path.get('extends').map(print);
         }
         
         print('__typeParameters');
@@ -85001,7 +85255,7 @@ tsEnumDeclaration.TSEnumDeclaration = {
         indent.inc();
         print.newline();
         
-        for (const member of path.get('members')) {
+        for (const member of path.get('body.members')) {
             traverse(member);
             print(',');
             print.newline();
@@ -85442,7 +85696,7 @@ var typescript$1 = {
     },
     TSInstantiationExpression(path, {print}) {
         print('__expression');
-        print('__typeParameters');
+        print('__typeArguments');
     },
     TSAnyKeyword(path, {write}) {
         write('any');
@@ -85471,7 +85725,7 @@ var typescript$1 = {
     },
     TSClassImplements(path, {print}) {
         print('__expression');
-        print('__typeParameters');
+        print('__typeArguments');
     },
     TSInterfaceHeritage(path, {print}) {
         print('__expression');
@@ -85535,22 +85789,16 @@ jsxElement.JSXElement = {
             write.newline();
         }
     },
-    print(path, {print, traverse, indent}) {
-        const insideFn = path.parentPath.isArrowFunctionExpression();
-        const insideCall = path.parentPath.parentPath.isCallExpression();
-        
-        if (insideFn && insideCall)
-            indent.inc();
+    print(path, {print, traverse, maybe}) {
+        const needIndent = isNeedIndent(path);
+        maybe.indent.inc(needIndent);
         
         print('__openingElement');
-        path
-            .get('children')
-            .map(traverse);
+        path.get('children').map(traverse);
         
         print('__closingElement');
         
-        if (insideFn && insideCall)
-            indent.dec();
+        maybe.indent.dec(needIndent);
     },
     after(path, {write, indent, maybe}) {
         const {leadingComments} = path.node;
@@ -85581,6 +85829,19 @@ function condition$1(path) {
     return path.parentPath.isVariableDeclarator();
 }
 
+function isNeedIndent(path) {
+    const attributesCount = path.node.openingElement.attributes.length;
+    
+    if (attributesCount > 2)
+        return false;
+    
+    const insideFn = path.parentPath.isArrowFunctionExpression();
+    const insideJSX = path.parentPath.isJSXElement();
+    const insideCall = path.parentPath.parentPath.isCallExpression();
+    
+    return insideJSX || insideFn && insideCall;
+}
+
 var jsxAttribute = {};
 
 const {isCoupleLines: isCoupleLines$2} = is$3;
@@ -85664,9 +85925,7 @@ jsxFragment.JSXFragment = {
     },
     print(path, {print, traverse}) {
         print('__openingFragment');
-        path
-            .get('children')
-            .map(traverse);
+        path.get('children').map(traverse);
         print('__closingFragment');
     },
     after(path, {write, indent}) {
@@ -85959,35 +86218,31 @@ overrides.parseOverrides = (overrides = {}) => {
     };
 };
 
-function initFormat(format) {
-    return {
-        indent: '    ',
-        newline: '\n',
-        space: ' ',
-        splitter: '\n',
-        quote: `'`,
-        endOfFile: '\n',
-        ...format,
-    };
-}
+const initFormat = (format) => ({
+    indent: '    ',
+    newline: '\n',
+    space: ' ',
+    splitter: '\n',
+    quote: `'`,
+    endOfFile: '\n',
+    ...format,
+});
 
-function initSemantics(semantics = {}) {
-    return {
-        comments: true,
-        maxPropertiesInOneLine: 2,
-        maxPropertiesLengthInOneLine: 15,
-        maxSpecifiersInOneLine: 2,
-        maxElementsInOneLine: 5,
-        maxLogicalsInOneLine: 3,
-        maxVariablesInOneLine: 4,
-        maxTypesInOneLine: 3,
-        trailingComma: true,
-        encodeSingleQuote: true,
-        encodeDoubleQuote: false,
-        ...semantics,
-        roundBraces: parseRoundBraces(semantics),
-    };
-}
+const initSemantics = (semantics = {}) => ({
+    comments: true,
+    maxPropertiesInOneLine: 2,
+    maxPropertiesLengthInOneLine: 15,
+    maxSpecifiersInOneLine: 2,
+    maxElementsInOneLine: 5,
+    maxLogicalsInOneLine: 3,
+    maxVariablesInOneLine: 4,
+    maxTypesInOneLine: 3,
+    trailingComma: true,
+    encodeSingleQuote: true,
+    encodeDoubleQuote: false,
+    ...semantics,
+    roundBraces: parseRoundBraces(semantics),
+});
 
 const fullstore$2 = fullstore$3;
 
@@ -86467,7 +86722,9 @@ const {isArray: isArray$d} = Array;
 
 const maybeArray$7 = (a) => isArray$d(a) ? a : [a, {}];
 
-const btoa$1 = (a) => Buffer.from(a, 'binary').toString('base64');
+const btoa$1 = (a) => Buffer
+    .from(a, 'binary')
+    .toString('base64');
 
 const addSourceMap = (sourceMapName, {code, map}) => !sourceMapName ? code : `${code}\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa$1(stringify$7(map))}\n`;
 const fixStrictMode = (a) => a.replace(`\n\n\n'use strict'`, `\n\n'use strict'`);
@@ -86758,16 +87015,14 @@ ts.convertTSAbstractMethodDefinition = (path) => {
     path.replaceWith(newNode);
 };
 
-function createPrivateName(node) {
-    return {
-        type: 'PrivateName',
-        id: {
-            ...node,
-            type: 'Identifier',
-        },
-        loc: node.loc,
-    };
-}
+const createPrivateName = (node) => ({
+    type: 'PrivateName',
+    id: {
+        ...node,
+        type: 'Identifier',
+    },
+    loc: node.loc,
+});
 
 var comments = {};
 
@@ -86803,9 +87058,7 @@ comments.convertProgramComments = (comments) => {
     return comments;
 };
 
-function getCommentType({type}) {
-    return `Comment${type}`;
-}
+const getCommentType = ({type}) => `Comment${type}`;
 
 function getCommentGroup({trailing, leading}) {
     if (trailing)
@@ -114173,22 +114426,20 @@ var parse$5 = (source, options) => {
     });
 };
 
-function getParser({parser = 'babel', isTS, isFlow, isJSX, printer}) {
-    return {
-        parse(source) {
-            const ast = toBabel(customParser(source, parser, {
-                isTS,
-                isFlow,
-                isJSX,
-            }));
-            
-            if (printer === 'recast')
-                moveOutDirectives(ast);
-            
-            return ast;
-        },
-    };
-}
+const getParser = ({parser = 'babel', isTS, isFlow, isJSX, printer}) => ({
+    parse(source) {
+        const ast = toBabel(customParser(source, parser, {
+            isTS,
+            isFlow,
+            isJSX,
+        }));
+        
+        if (printer === 'recast')
+            moveOutDirectives(ast);
+        
+        return ast;
+    },
+});
 
 parse$5.default;
 
@@ -116361,17 +116612,15 @@ var superFind$1 = function superFind({rule, find, ast, options, template}) {
     ];
 };
 
-function traverse$8({rule, options, template}) {
-    return (ast, visitor) => {
-        const templateVisitors = merge$1(template({
-            rule,
-            visitor,
-            options,
-        }));
-        
-        return babelTraverse$1(ast, templateVisitors);
-    };
-}
+const traverse$8 = ({rule, options, template}) => (ast, visitor) => {
+    const templateVisitors = merge$1(template({
+        rule,
+        visitor,
+        options,
+    }));
+    
+    return babelTraverse$1(ast, templateVisitors);
+};
 
 const log$5 = browserExports('putout:runner:include');
 const maybeArray$4 = maybeArray_1;
@@ -116886,6 +117135,7 @@ is$2.parseTemplate = (tmpl, {program} = {}) => {
 };
 
 is$2.isInsideTypeReference = (path) => path.isIdentifier() && path.parentPath?.isTSTypeReference();
+is$2.isInsideTypeParameter = (path) => path.isIdentifier() && path.parentPath?.isTSTypeParameter();
 
 const jessy = jessy$1;
 const nessy = nessy$1;
@@ -116903,6 +117153,7 @@ const {
     isImportsStr,
     isExportsStr,
     isInsideTypeReference,
+    isInsideTypeParameter,
     isBodyStr,
 } = is$2;
 
@@ -116958,6 +117209,9 @@ function findVarsWays$2(node) {
             if (isInsideTypeReference(path))
                 return;
             
+            if (isInsideTypeParameter(path))
+                return;
+            
             const {node} = path;
             
             if (isJSXAttribute(path.parentPath) && path.parentPath.node.name === node)
@@ -117332,7 +117586,11 @@ function compareTemplateElements(node, template) {
 }
 
 function linkNodes(node, template, {add, templateStore}) {
-    const is = node && (isLinkedNode$1(template) || isLinkedArgs(template) || isLinkedId$1(node, template) || isLinkedBool(node, template));
+    const is = node
+        && (isLinkedNode$1(template)
+        || isLinkedArgs(template)
+        || isLinkedId$1(node, template)
+        || isLinkedBool(node, template));
     
     if (is)
         return link({
@@ -117634,8 +117892,10 @@ function findKey(path, parent) {
 }
 
 const wraptile = wraptile$1;
-const findPath = findPath$1;
+
 const {types: types$9} = bundle;
+const findPath = findPath$1;
+
 const {isProgram: isProgram$2} = types$9;
 const name = '__putout_runner_replace';
 const hasWatermark = (watermark) => (path) => path.node?.[name]?.has(watermark);
@@ -117956,6 +118216,8 @@ const {template: template$4} = parser$6;
 const {isESM, insertAfter} = operate;
 const {compare: compare$2} = compare$5;
 
+const {types: types$7} = bundle;
+
 const {
     addDeclarationForESLint,
     checkDeclarationForESLint,
@@ -117963,7 +118225,6 @@ const {
     setModuleType,
 } = record;
 
-const {types: types$7} = bundle;
 const {
     isImportDeclaration,
     isVariableDeclaration,
@@ -117972,11 +118233,17 @@ const {
 const {keys} = Object;
 const isString$3 = (a) => typeof a === 'string';
 
-const getLastVarPath = (bodyPath) => bodyPath.filter(isVariableDeclaration).pop();
+const getLastVarPath = (bodyPath) => bodyPath
+    .filter(isVariableDeclaration)
+    .pop();
+
 const isLast = (insertionPath, bodyPath) => bodyPath.at(-1) === insertionPath;
 const isLocalImport = (path) => path.node.source.value.includes('.');
 
-const cutName = (a) => a.split('.').shift();
+const cutName = (a) => a
+    .split('.')
+    .shift();
+
 const parseType = (path) => isESM(path) ? 'esm' : 'commonjs';
 
 const TS_EXCLUDE = [
@@ -118284,6 +118551,9 @@ const getRegExp = (wildcard) => {
 };
 
 filesystem.getParentDirectory = (filePath) => {
+    if (!filePath.parentPath)
+        return null;
+    
     const {parentPath} = filePath.parentPath.parentPath;
     
     if (isProgram$1(parentPath))
@@ -118486,9 +118756,7 @@ filesystem.createFile = (dirPath, name, content) => {
     
     dirPathFiles.node.value.elements.push(ObjectExpression$1(properties));
     
-    const filePath = dirPathFiles
-        .get('value.elements')
-        .at(-1);
+    const filePath = dirPathFiles.get('value.elements').at(-1);
     
     if (isString$2(content))
         writeFileContent$1(filePath, content);
@@ -118496,9 +118764,7 @@ filesystem.createFile = (dirPath, name, content) => {
     return filePath;
 };
 
-function getFiles$1(dirPath) {
-    return getProperty$2(dirPath, 'files');
-}
+const getFiles$1 = (dirPath) => getProperty$2(dirPath, 'files');
 
 filesystem.createDirectory = (dirPath, name) => {
     const dirPathFiles = getFiles$1(dirPath);
@@ -118517,9 +118783,7 @@ filesystem.createDirectory = (dirPath, name) => {
     
     maybeFS.createDirectory(filename);
     
-    return dirPathFiles
-        .get('value.elements')
-        .at(-1);
+    return dirPathFiles.get('value.elements').at(-1);
 };
 
 filesystem.readFileContent = (filePath) => {
@@ -118574,8 +118838,9 @@ filesystem.start = maybeFS.start;
 
 var convertSimpleFilesystemToFilesystem = {};
 
-const {types: types$5} = bundle;
 const {basename, dirname} = require$$0$2;
+const {types: types$5} = bundle;
+
 const {
     createDirectory,
     getFileType: getFileType$1,
@@ -119028,27 +119293,25 @@ template$3.exports = ({rule, visitor, options}) => {
 
 template$3.exports._log = log;
 
-function wrapWithCheck({rule, nodesInclude, nodesExclude, fn}) {
-    return (path) => {
-        log(rule, path);
-        
-        if (nodesExclude.length && compareAny$1(path, nodesExclude))
-            return;
-        
-        if (nodesInclude.length && !compareAll(path, nodesInclude))
-            return;
-        
-        if (!isFn(fn))
-            throw Error(`☝️ Looks like provided visitor is not a function: ${stringify(fn)}. More on using Traverser: https://git.io/JqcMn`);
-        
-        const [e] = tryCatch$1(fn, path);
-        
-        if (e) {
-            e.rule = rule;
-            throw e;
-        }
-    };
-}
+const wrapWithCheck = ({rule, nodesInclude, nodesExclude, fn}) => (path) => {
+    log(rule, path);
+    
+    if (nodesExclude.length && compareAny$1(path, nodesExclude))
+        return;
+    
+    if (nodesInclude.length && !compareAll(path, nodesInclude))
+        return;
+    
+    if (!isFn(fn))
+        throw Error(`☝️ Looks like provided visitor is not a function: ${stringify(fn)}. More on using Traverser: https://git.io/JqcMn`);
+    
+    const [e] = tryCatch$1(fn, path);
+    
+    if (e) {
+        e.rule = rule;
+        throw e;
+    }
+};
 
 var templateExports = template$3.exports;
 
@@ -119641,25 +119904,23 @@ lib.runPlugins = ({ast, shebang, fix, fixCount, plugins, progress = createProgre
 
 lib.getPosition = getPosition;
 
-function run({ast, fix, shebang, pluginsFind, pluginsTraverse, template, merge}) {
-    return [
-        ...runWithoutMerge({
-            ast,
-            fix,
-            shebang,
-            template,
-            pluginsFind,
-        }),
-        ...runWithMerge({
-            ast,
-            fix,
-            shebang,
-            template,
-            pluginsTraverse,
-            merge,
-        }),
-    ];
-}
+const run = ({ast, fix, shebang, pluginsFind, pluginsTraverse, template, merge}) => [
+    ...runWithoutMerge({
+        ast,
+        fix,
+        shebang,
+        template,
+        pluginsFind,
+    }),
+    ...runWithMerge({
+        ast,
+        fix,
+        shebang,
+        template,
+        pluginsTraverse,
+        merge,
+    }),
+];
 
 function runWithMerge({ast, fix, shebang, template, pluginsTraverse, merge}) {
     const {entries, visitor} = merge(pluginsTraverse, {
@@ -128190,11 +128451,11 @@ matchFiles.matchFiles = (options) => {
     };
 };
 
-function fix$1(inputFile, {dirPath, mainPath, matchInputFilename, outputFilename, matchedJS, matchedAST, options}) {
+function fix$1(inputFile, {dirPath, matchInputFilename, outputFilename, matchedJS, matchedAST, options}) {
     transform$1(matchedAST, matchedJS, options);
     
     const matchedJSON = magicPrint(outputFilename, matchedAST);
-    const outputFile = getOutputFile(mainPath, {
+    const outputFile = getOutputFile({
         dirPath,
         matchInputFilename,
         outputFilename,
@@ -128227,7 +128488,6 @@ const createScan = ({files, exclude}) => (mainPath, {push, progress, options}) =
                 continue;
             
             allFiles.push({
-                mainPath,
                 dirPath,
                 matchInputFilename,
                 rawOptions,
@@ -128248,7 +128508,6 @@ const createScan = ({files, exclude}) => (mainPath, {push, progress, options}) =
             inputFilename,
             outputFilename,
             rawOptions,
-            mainPath,
         } = current;
         
         progress({
@@ -128269,7 +128528,6 @@ const createScan = ({files, exclude}) => (mainPath, {push, progress, options}) =
         
         push(inputFile, {
             dirPath,
-            mainPath,
             matchInputFilename,
             
             outputFilename,
@@ -128318,7 +128576,7 @@ function check$1(files) {
     }
 }
 
-function getOutputFile(path, {dirPath, matchInputFilename, outputFilename, inputFile}) {
+function getOutputFile({dirPath, matchInputFilename, outputFilename, inputFile}) {
     if (matchInputFilename === outputFilename)
         return inputFile;