@putout/babel 5.2.5 → 5.2.7

package/bundle/index.js

@@ -676,9 +676,6 @@ __export(lib_exports, {
     PROPERTY_TYPES: () => PROPERTY_TYPES,
     PUREISH_TYPES: () => PUREISH_TYPES,
     ParenthesizedExpression: () => ParenthesizedExpression,
-    PipelineBareFunction: () => PipelineBareFunction,
-    PipelinePrimaryTopicReference: () => PipelinePrimaryTopicReference,
-    PipelineTopicExpression: () => PipelineTopicExpression,
     Placeholder: () => Placeholder,
     PrivateName: () => PrivateName,
     Program: () => Program,
@@ -992,9 +989,6 @@ __export(lib_exports, {
     assertParenthesizedExpression: () => assertParenthesizedExpression,
     assertPattern: () => assertPattern,
     assertPatternLike: () => assertPatternLike,
-    assertPipelineBareFunction: () => assertPipelineBareFunction,
-    assertPipelinePrimaryTopicReference: () => assertPipelinePrimaryTopicReference,
-    assertPipelineTopicExpression: () => assertPipelineTopicExpression,
     assertPlaceholder: () => assertPlaceholder,
     assertPrivate: () => assertPrivate,
     assertPrivateName: () => assertPrivateName,
@@ -1409,9 +1403,6 @@ __export(lib_exports, {
     isParenthesizedExpression: () => isParenthesizedExpression,
     isPattern: () => isPattern,
     isPatternLike: () => isPatternLike,
-    isPipelineBareFunction: () => isPipelineBareFunction,
-    isPipelinePrimaryTopicReference: () => isPipelinePrimaryTopicReference,
-    isPipelineTopicExpression: () => isPipelineTopicExpression,
     isPlaceholder: () => isPlaceholder,
     isPlaceholderType: () => isPlaceholderType,
     isPrivate: () => isPrivate,
@@ -1596,9 +1587,6 @@ __export(lib_exports, {
     optionalIndexedAccessType: () => optionalIndexedAccessType,
     optionalMemberExpression: () => optionalMemberExpression,
     parenthesizedExpression: () => parenthesizedExpression,
-    pipelineBareFunction: () => pipelineBareFunction,
-    pipelinePrimaryTopicReference: () => pipelinePrimaryTopicReference,
-    pipelineTopicExpression: () => pipelineTopicExpression,
     placeholder: () => placeholder,
     prependToMemberExpression: () => prependToMemberExpression,
     privateName: () => privateName,
@@ -4102,16 +4090,6 @@ function isClassProperty(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isClassAccessorProperty(node, opts) {
-    if (!node)
-        return false;
-    
-    if (node.type !== 'ClassAccessorProperty')
-        return false;
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
 function isClassPrivateProperty(node, opts) {
     if (!node)
         return false;
@@ -5002,6 +4980,16 @@ function isBindExpression(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
+function isClassAccessorProperty(node, opts) {
+    if (!node)
+        return false;
+    
+    if (node.type !== 'ClassAccessorProperty')
+        return false;
+    
+    return opts == null || shallowEqual(node, opts);
+}
+
 function isDecorator(node, opts) {
     if (!node)
         return false;
@@ -5052,36 +5040,6 @@ function isTopicReference(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isPipelineTopicExpression(node, opts) {
-    if (!node)
-        return false;
-    
-    if (node.type !== 'PipelineTopicExpression')
-        return false;
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
-function isPipelineBareFunction(node, opts) {
-    if (!node)
-        return false;
-    
-    if (node.type !== 'PipelineBareFunction')
-        return false;
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
-function isPipelinePrimaryTopicReference(node, opts) {
-    if (!node)
-        return false;
-    
-    if (node.type !== 'PipelinePrimaryTopicReference')
-        return false;
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
 function isVoidPattern(node, opts) {
     if (!node)
         return false;
@@ -5860,7 +5818,6 @@ function isStandardized(node, opts) {
     case 'OptionalMemberExpression':    
     case 'OptionalCallExpression':    
     case 'ClassProperty':    
-    case 'ClassAccessorProperty':    
     case 'ClassPrivateProperty':    
     case 'ClassPrivateMethod':    
     case 'PrivateName':    
@@ -5935,9 +5892,6 @@ function isExpression(node, opts) {
     case 'DoExpression':    
     case 'ModuleExpression':    
     case 'TopicReference':    
-    case 'PipelineTopicExpression':    
-    case 'PipelineBareFunction':    
-    case 'PipelinePrimaryTopicReference':    
     case 'TSInstantiationExpression':    
     case 'TSAsExpression':    
     case 'TSSatisfiesExpression':    
@@ -6629,8 +6583,8 @@ function isProperty(node, opts) {
     switch(node.type) {
     case 'ObjectProperty':    
     case 'ClassProperty':    
-    case 'ClassAccessorProperty':    
-    case 'ClassPrivateProperty':
+    case 'ClassPrivateProperty':    
+    case 'ClassAccessorProperty':
         break;
     
     default:
@@ -6756,22 +6710,6 @@ function isModuleSpecifier(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isAccessor(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'ClassAccessorProperty':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
 function isPrivate(node, opts) {
     if (!node)
         return false;
@@ -6885,6 +6823,22 @@ function isMiscellaneous(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
+function isAccessor(node, opts) {
+    if (!node)
+        return false;
+    
+    switch(node.type) {
+    case 'ClassAccessorProperty':
+        break;
+    
+    default:
+        return false;
+    }
+    
+    
+    return opts == null || shallowEqual(node, opts);
+}
+
 function isTypeScript(node, opts) {
     if (!node)
         return false;
@@ -7387,6 +7341,14 @@ function validateOptional(validate4) {
     };
 }
 
+function validateDefault(validate4, defaultValue) {
+    return {
+        validate: validate4,
+        default: defaultValue,
+        optional: false,
+    };
+}
+
 function validateOptionalType(...typeNames) {
     return {
         validate: assertNodeType(...typeNames),
@@ -7627,6 +7589,12 @@ function defineAliasedType(...aliases) {
 
 function defineType$5(type, opts = {}) {
     const inherits3 = opts.inherits && store[opts.inherits] || {};
+    const visitor = opts.visitor || inherits3.visitor || [];
+    const aliases = opts.aliases || inherits3.aliases || [];
+    const builder = opts.builder
+        || inherits3.builder
+        || opts.visitor
+        || [];
     let fields = opts.fields;
     
     if (!fields) {
@@ -7653,13 +7621,6 @@ function defineType$5(type, opts = {}) {
         }
     }
     
-    const visitor = opts.visitor || inherits3.visitor || [];
-    const aliases = opts.aliases || inherits3.aliases || [];
-    const builder = opts.builder
-        || inherits3.builder
-        || opts.visitor
-        || [];
-    
     for (const k of Object.keys(opts)) {
         if (!validTypeOpts.has(k)) {
             throw new Error(`Unknown type option "${k}" on ${type}`);
@@ -7677,12 +7638,13 @@ function defineType$5(type, opts = {}) {
     for (const key of Object.keys(fields)) {
         const field = fields[key];
         
-        if (field.default !== void 0 && !builder.includes(key)) {
-            field.optional = true;
+        if (field.default === null) {
+            field.optional ??= true;
         }
         
         if (field.default === void 0) {
             field.default = null;
+            field.optional ??= false;
         } else if (!field.validate && field.default != null) {
             field.validate = assertValueType(getType(field.default));
         }
@@ -7743,6 +7705,7 @@ var utils = /* @__PURE__ */Object.freeze({
     defineAliasedType,
     validate: validate$2,
     validateArrayOfType,
+    validateDefault,
     validateOptional,
     validateOptionalType,
     validateType,
@@ -8982,6 +8945,17 @@ defineType$4('ArrowFunctionExpression', {
     ],
     fields: {
         ...functionCommon(),
+        generator: {
+            default: null,
+            optional: true,
+            validate: Object.assign((node, key, val) => {
+                if (val) {
+                    throw new TypeError('ArrowFunctionExpression cannot be a generator');
+                }
+            }, {
+                type: 'boolean',
+            }),
+        },
         ...functionTypeAnnotationCommon(),
         expression: {
             validate: assertValueType('boolean'),
@@ -9124,12 +9098,7 @@ var importAttributes = {
 };
 
 defineType$4('ExportAllDeclaration', {
-    builder: ['source'],
-    visitor: [
-        'source',
-        'attributes',
-        'assertions',
-    ],
+    visitor: ['source', 'attributes'],
     aliases: [
         'Statement',
         'Declaration',
@@ -9162,6 +9131,7 @@ defineType$4('ExportNamedDeclaration', {
         'declaration',
         'specifiers',
         'source',
+        'attributes',
     ],
     visitor: [
         'declaration',
@@ -9291,7 +9261,11 @@ defineType$4('ForOfStatement', {
     },
 });
 defineType$4('ImportDeclaration', {
-    builder: ['specifiers', 'source'],
+    builder: [
+        'specifiers',
+        'source',
+        'attributes',
+    ],
     visitor: [
         'specifiers',
         'source',
@@ -9411,6 +9385,7 @@ defineType$4('MetaProperty', {
 var classMethodOrPropertyCommon = () => ({
     abstract: {
         validate: assertValueType('boolean'),
+        default: false,
         optional: true,
     },
     accessibility: {
@@ -9421,6 +9396,8 @@ var classMethodOrPropertyCommon = () => ({
         default: false,
     },
     override: {
+        optional: true,
+        validate: assertValueType('boolean'),
         default: false,
     },
     computed: {
@@ -9774,66 +9751,6 @@ defineType$4('ClassProperty', {
         },
     },
 });
-defineType$4('ClassAccessorProperty', {
-    visitor: [
-        'decorators',
-        'key',
-        'typeAnnotation',
-        'value',
-    ],
-    builder: [
-        'key',
-        'value',
-        'typeAnnotation',
-        'decorators',
-        'computed',
-        'static',
-    ],
-    aliases: ['Property', 'Accessor'],
-    ...classMethodOrPropertyUnionShapeCommon(true),
-    fields: {
-        ...classMethodOrPropertyCommon(),
-        key: {
-            validate: chain((function() {
-                const normal = assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'PrivateName');
-                const computed = assertNodeType('Expression');
-                
-                return function(node, key, val) {
-                    const validator = node.computed ? computed : normal;
-                    validator(node, key, val);
-                };
-            })(), assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'Expression', 'PrivateName')),
-        },
-        value: {
-            validate: assertNodeType('Expression'),
-            optional: true,
-        },
-        definite: {
-            validate: assertValueType('boolean'),
-            optional: true,
-        },
-        typeAnnotation: {
-            validate: assertNodeType('TypeAnnotation', 'TSTypeAnnotation'),
-            optional: true,
-        },
-        decorators: {
-            validate: arrayOfType('Decorator'),
-            optional: true,
-        },
-        readonly: {
-            validate: assertValueType('boolean'),
-            optional: true,
-        },
-        declare: {
-            validate: assertValueType('boolean'),
-            optional: true,
-        },
-        variance: {
-            validate: assertNodeType('Variance'),
-            optional: true,
-        },
-    },
-});
 defineType$4('ClassPrivateProperty', {
     visitor: [
         'decorators',
@@ -10306,7 +10223,7 @@ defineType$3('ObjectTypeCallProperty', {
     aliases: ['UserWhitespacable'],
     fields: {
         value: validateType('FlowType'),
-        static: validate$2(assertValueType('boolean')),
+        static: validateDefault(assertValueType('boolean'), false),
     },
 });
 defineType$3('ObjectTypeIndexer', {
@@ -10327,7 +10244,7 @@ defineType$3('ObjectTypeIndexer', {
         id: validateOptionalType('Identifier'),
         key: validateType('FlowType'),
         value: validateType('FlowType'),
-        static: validate$2(assertValueType('boolean')),
+        static: validateDefault(assertValueType('boolean'), false),
         variance: validateOptionalType('Variance'),
     },
 });
@@ -10341,12 +10258,16 @@ defineType$3('ObjectTypeProperty', {
     fields: {
         key: validateType('Identifier', 'StringLiteral'),
         value: validateType('FlowType'),
-        kind: validate$2(assertOneOf('init', 'get', 'set')),
-        static: validate$2(assertValueType('boolean')),
-        proto: validate$2(assertValueType('boolean')),
-        optional: validate$2(assertValueType('boolean')),
+        kind: {
+            validate: assertOneOf('init', 'get', 'set'),
+            default: 'init',
+            optional: false,
+        },
+        static: validateDefault(assertValueType('boolean'), false),
+        proto: validateDefault(assertValueType('boolean'), false),
+        optional: validateDefault(assertValueType('boolean'), false),
         variance: validateOptionalType('Variance'),
-        method: validate$2(assertValueType('boolean')),
+        method: validateDefault(assertValueType('boolean'), false),
     },
 });
 defineType$3('ObjectTypeSpreadProperty', {
@@ -10445,6 +10366,12 @@ defineType$3('TypeCastExpression', {
     },
 });
 defineType$3('TypeParameter', {
+    builder: [
+        'name',
+        'bound',
+        'default',
+        'variance',
+    ],
     visitor: [
         'bound',
         'default',
@@ -10493,31 +10420,33 @@ defineType$3('EnumDeclaration', {
         body: validateType('EnumBooleanBody', 'EnumNumberBody', 'EnumStringBody', 'EnumSymbolBody'),
     },
 });
+var enumBodyBase = {
+    explicitType: validateDefault(assertValueType('boolean'), false),
+    hasUnknownMembers: validateDefault(assertValueType('boolean'), false),
+};
+
 defineType$3('EnumBooleanBody', {
     aliases: ['EnumBody'],
     visitor: ['members'],
     fields: {
-        explicitType: validate$2(assertValueType('boolean')),
+        ...enumBodyBase,
         members: validateArrayOfType('EnumBooleanMember'),
-        hasUnknownMembers: validate$2(assertValueType('boolean')),
     },
 });
 defineType$3('EnumNumberBody', {
     aliases: ['EnumBody'],
     visitor: ['members'],
     fields: {
-        explicitType: validate$2(assertValueType('boolean')),
+        ...enumBodyBase,
         members: validateArrayOfType('EnumNumberMember'),
-        hasUnknownMembers: validate$2(assertValueType('boolean')),
     },
 });
 defineType$3('EnumStringBody', {
     aliases: ['EnumBody'],
     visitor: ['members'],
     fields: {
-        explicitType: validate$2(assertValueType('boolean')),
+        ...enumBodyBase,
         members: validateArrayOfType('EnumStringMember', 'EnumDefaultedMember'),
-        hasUnknownMembers: validate$2(assertValueType('boolean')),
     },
 });
 defineType$3('EnumSymbolBody', {
@@ -10525,12 +10454,11 @@ defineType$3('EnumSymbolBody', {
     visitor: ['members'],
     fields: {
         members: validateArrayOfType('EnumDefaultedMember'),
-        hasUnknownMembers: validate$2(assertValueType('boolean')),
+        hasUnknownMembers: validateDefault(assertValueType('boolean'), false),
     },
 });
 defineType$3('EnumBooleanMember', {
     aliases: ['EnumMember'],
-    builder: ['id'],
     visitor: ['id', 'init'],
     fields: {
         id: validateType('Identifier'),
@@ -10574,7 +10502,7 @@ defineType$3('OptionalIndexedAccessType', {
     fields: {
         objectType: validateType('FlowType'),
         indexType: validateType('FlowType'),
-        optional: validate$2(assertValueType('boolean')),
+        optional: validateDefault(assertValueType('boolean'), false),
     },
 });
 var defineType$2 = defineAliasedType('JSX');
@@ -10816,6 +10744,66 @@ defineType$5('BindExpression', {
         },
     },
 });
+defineType$5('ClassAccessorProperty', {
+    visitor: [
+        'decorators',
+        'key',
+        'typeAnnotation',
+        'value',
+    ],
+    builder: [
+        'key',
+        'value',
+        'typeAnnotation',
+        'decorators',
+        'computed',
+        'static',
+    ],
+    aliases: ['Property', 'Accessor'],
+    ...classMethodOrPropertyUnionShapeCommon(true),
+    fields: {
+        ...classMethodOrPropertyCommon(),
+        key: {
+            validate: chain((function() {
+                const normal = assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'PrivateName');
+                const computed = assertNodeType('Expression');
+                
+                return function(node, key, val) {
+                    const validator = node.computed ? computed : normal;
+                    validator(node, key, val);
+                };
+            })(), assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'Expression', 'PrivateName')),
+        },
+        value: {
+            validate: assertNodeType('Expression'),
+            optional: true,
+        },
+        definite: {
+            validate: assertValueType('boolean'),
+            optional: true,
+        },
+        typeAnnotation: {
+            validate: assertNodeType('TypeAnnotation', 'TSTypeAnnotation'),
+            optional: true,
+        },
+        decorators: {
+            validate: arrayOfType('Decorator'),
+            optional: true,
+        },
+        readonly: {
+            validate: assertValueType('boolean'),
+            optional: true,
+        },
+        declare: {
+            validate: assertValueType('boolean'),
+            optional: true,
+        },
+        variance: {
+            validate: assertNodeType('Variance'),
+            optional: true,
+        },
+    },
+});
 defineType$5('Decorator', {
     visitor: ['expression'],
     fields: {
@@ -10859,29 +10847,6 @@ defineType$5('ModuleExpression', {
 defineType$5('TopicReference', {
     aliases: ['Expression'],
 });
-defineType$5('PipelineTopicExpression', {
-    builder: ['expression'],
-    visitor: ['expression'],
-    fields: {
-        expression: {
-            validate: assertNodeType('Expression'),
-        },
-    },
-    aliases: ['Expression'],
-});
-defineType$5('PipelineBareFunction', {
-    builder: ['callee'],
-    visitor: ['callee'],
-    fields: {
-        callee: {
-            validate: assertNodeType('Expression'),
-        },
-    },
-    aliases: ['Expression'],
-});
-defineType$5('PipelinePrimaryTopicReference', {
-    aliases: ['Expression'],
-});
 defineType$5('VoidPattern', {
     aliases: [
         'Pattern',
@@ -11015,6 +10980,7 @@ defineType('TSMethodSignature', {
         ...namedTypeElementCommon(),
         kind: {
             validate: assertOneOf('method', 'get', 'set'),
+            default: 'method',
         },
     },
 });
@@ -11403,15 +11369,12 @@ defineType('TSModuleDeclaration', {
     visitor: ['id', 'body'],
     fields: {
         kind: {
-            validate: assertOneOf('global', 'module', 'namespace'),
+            validate: assertOneOf('global', 'namespace'),
+            default: 'namespace',
         },
         declare: validateOptional(bool),
         id: {
             validate: chain(assertNodeType('TSEntityName', 'StringLiteral'), Object.assign(function(node, key, val) {
-                if (node.kind === 'module' && !is('StringLiteral', val)) {
-                    throw new TypeError(`TSModuleDeclaration of kind 'module' must have a StringLiteral id.`);
-                }
-                
                 if (node.kind === 'namespace' && is('StringLiteral', val)) {
                     throw new TypeError(`TSModuleDeclaration of kind 'namespace' cannot have a StringLiteral id.`);
                 }
@@ -12331,7 +12294,7 @@ function arrowFunctionExpression(params, body, async = false) {
         params,
         body,
         async,
-        expression: null,
+        expression: body.type !== 'BlockStatement',
     };
     
     const defs = NODE_FIELDS.ArrowFunctionExpression;
@@ -12386,15 +12349,16 @@ function classDeclaration(id = null, superClass = null, body, decorators = null)
     return node;
 }
 
-function exportAllDeclaration(source) {
+function exportAllDeclaration(source, attributes = null) {
     const node = {
         type: 'ExportAllDeclaration',
         source,
-        assertions: null,
+        attributes,
     };
     
     const defs = NODE_FIELDS.ExportAllDeclaration;
     validate(defs.source, node, 'source', source, 1);
+    validate(defs.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -12409,18 +12373,20 @@ function exportDefaultDeclaration(declaration) {
     return node;
 }
 
-function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
+function exportNamedDeclaration(declaration = null, specifiers = [], source = null, attributes = null) {
     const node = {
         type: 'ExportNamedDeclaration',
         declaration,
         specifiers,
         source,
+        attributes,
     };
     
     const defs = NODE_FIELDS.ExportNamedDeclaration;
     validate(defs.declaration, node, 'declaration', declaration, 1);
     validate(defs.specifiers, node, 'specifiers', specifiers, 1);
     validate(defs.source, node, 'source', source, 1);
+    validate(defs.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -12454,16 +12420,18 @@ function forOfStatement(left, right, body, _await = false) {
     return node;
 }
 
-function importDeclaration(specifiers, source) {
+function importDeclaration(specifiers, source, attributes = null) {
     const node = {
         type: 'ImportDeclaration',
         specifiers,
         source,
+        attributes,
     };
     
     const defs = NODE_FIELDS.ImportDeclaration;
     validate(defs.specifiers, node, 'specifiers', specifiers, 1);
     validate(defs.source, node, 'source', source, 1);
+    validate(defs.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -12725,27 +12693,6 @@ function classProperty(key, value = null, typeAnnotation2 = null, decorators = n
     return node;
 }
 
-function classAccessorProperty(key, value = null, typeAnnotation2 = null, decorators = null, computed = false, _static = false) {
-    const node = {
-        type: 'ClassAccessorProperty',
-        key,
-        value,
-        typeAnnotation: typeAnnotation2,
-        decorators,
-        computed,
-        static: _static,
-    };
-    
-    const defs = NODE_FIELDS.ClassAccessorProperty;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.value, node, 'value', value, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
-    validate(defs.decorators, node, 'decorators', decorators, 1);
-    validate(defs.computed, node, 'computed', computed);
-    validate(defs.static, node, 'static', _static);
-    return node;
-}
-
 function classPrivateProperty(key, value = null, decorators = null, _static = false) {
     const node = {
         type: 'ClassPrivateProperty',
@@ -12771,6 +12718,9 @@ function classPrivateMethod(kind = 'method', key, params, body, _static = false)
         params,
         body,
         static: _static,
+        async: false,
+        computed: false,
+        generator: false,
     };
     
     const defs = NODE_FIELDS.ClassPrivateMethod;
@@ -13214,7 +13164,7 @@ function objectTypeCallProperty(value) {
     const node = {
         type: 'ObjectTypeCallProperty',
         value,
-        static: null,
+        static: false,
     };
     
     const defs = NODE_FIELDS.ObjectTypeCallProperty;
@@ -13229,7 +13179,7 @@ function objectTypeIndexer(id = null, key, value, variance2 = null) {
         key,
         value,
         variance: variance2,
-        static: null,
+        static: false,
     };
     
     const defs = NODE_FIELDS.ObjectTypeIndexer;
@@ -13246,11 +13196,11 @@ function objectTypeProperty(key, value, variance2 = null) {
         key,
         value,
         variance: variance2,
-        kind: null,
-        method: null,
-        optional: null,
-        proto: null,
-        static: null,
+        kind: 'init',
+        method: false,
+        optional: false,
+        proto: false,
+        static: false,
     };
     
     const defs = NODE_FIELDS.ObjectTypeProperty;
@@ -13391,16 +13341,17 @@ function typeCastExpression(expression2, typeAnnotation2) {
     return node;
 }
 
-function typeParameter(bound = null, _default = null, variance2 = null) {
+function typeParameter(name, bound = null, _default = null, variance2 = null) {
     const node = {
         type: 'TypeParameter',
+        name,
         bound,
         default: _default,
         variance: variance2,
-        name: null,
     };
     
     const defs = NODE_FIELDS.TypeParameter;
+    validate(defs.name, node, 'name', name);
     validate(defs.bound, node, 'bound', bound, 1);
     validate(defs.default, node, 'default', _default, 1);
     validate(defs.variance, node, 'variance', variance2, 1);
@@ -13474,8 +13425,8 @@ function enumBooleanBody(members) {
     const node = {
         type: 'EnumBooleanBody',
         members,
-        explicitType: null,
-        hasUnknownMembers: null,
+        explicitType: false,
+        hasUnknownMembers: false,
     };
     
     const defs = NODE_FIELDS.EnumBooleanBody;
@@ -13487,8 +13438,8 @@ function enumNumberBody(members) {
     const node = {
         type: 'EnumNumberBody',
         members,
-        explicitType: null,
-        hasUnknownMembers: null,
+        explicitType: false,
+        hasUnknownMembers: false,
     };
     
     const defs = NODE_FIELDS.EnumNumberBody;
@@ -13500,8 +13451,8 @@ function enumStringBody(members) {
     const node = {
         type: 'EnumStringBody',
         members,
-        explicitType: null,
-        hasUnknownMembers: null,
+        explicitType: false,
+        hasUnknownMembers: false,
     };
     
     const defs = NODE_FIELDS.EnumStringBody;
@@ -13513,7 +13464,7 @@ function enumSymbolBody(members) {
     const node = {
         type: 'EnumSymbolBody',
         members,
-        hasUnknownMembers: null,
+        hasUnknownMembers: false,
     };
     
     const defs = NODE_FIELDS.EnumSymbolBody;
@@ -13521,15 +13472,16 @@ function enumSymbolBody(members) {
     return node;
 }
 
-function enumBooleanMember(id) {
+function enumBooleanMember(id, init) {
     const node = {
         type: 'EnumBooleanMember',
         id,
-        init: null,
+        init,
     };
     
     const defs = NODE_FIELDS.EnumBooleanMember;
     validate(defs.id, node, 'id', id, 1);
+    validate(defs.init, node, 'init', init, 1);
     return node;
 }
 
@@ -13588,7 +13540,7 @@ function optionalIndexedAccessType(objectType, indexType) {
         type: 'OptionalIndexedAccessType',
         objectType,
         indexType,
-        optional: null,
+        optional: false,
     };
     
     const defs = NODE_FIELDS.OptionalIndexedAccessType;
@@ -13808,6 +13760,27 @@ function bindExpression(object, callee) {
     return node;
 }
 
+function classAccessorProperty(key, value = null, typeAnnotation2 = null, decorators = null, computed = false, _static = false) {
+    const node = {
+        type: 'ClassAccessorProperty',
+        key,
+        value,
+        typeAnnotation: typeAnnotation2,
+        decorators,
+        computed,
+        static: _static,
+    };
+    
+    const defs = NODE_FIELDS.ClassAccessorProperty;
+    validate(defs.key, node, 'key', key, 1);
+    validate(defs.value, node, 'value', value, 1);
+    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    validate(defs.decorators, node, 'decorators', decorators, 1);
+    validate(defs.computed, node, 'computed', computed);
+    validate(defs.static, node, 'static', _static);
+    return node;
+}
+
 function decorator(expression2) {
     const node = {
         type: 'Decorator',
@@ -13860,34 +13833,6 @@ function topicReference() {
     };
 }
 
-function pipelineTopicExpression(expression2) {
-    const node = {
-        type: 'PipelineTopicExpression',
-        expression: expression2,
-    };
-    
-    const defs = NODE_FIELDS.PipelineTopicExpression;
-    validate(defs.expression, node, 'expression', expression2, 1);
-    return node;
-}
-
-function pipelineBareFunction(callee) {
-    const node = {
-        type: 'PipelineBareFunction',
-        callee,
-    };
-    
-    const defs = NODE_FIELDS.PipelineBareFunction;
-    validate(defs.callee, node, 'callee', callee, 1);
-    return node;
-}
-
-function pipelinePrimaryTopicReference() {
-    return {
-        type: 'PipelinePrimaryTopicReference',
-    };
-}
-
 function voidPattern() {
     return {
         type: 'VoidPattern',
@@ -13912,6 +13857,8 @@ function tsDeclareFunction(id = null, typeParameters = null, params, returnType
         typeParameters,
         params,
         returnType,
+        async: false,
+        generator: false,
     };
     
     const defs = NODE_FIELDS.TSDeclareFunction;
@@ -13930,6 +13877,11 @@ function tsDeclareMethod(decorators = null, key, typeParameters = null, params,
         typeParameters,
         params,
         returnType,
+        async: false,
+        computed: false,
+        generator: false,
+        kind: 'method',
+        static: false,
     };
     
     const defs = NODE_FIELDS.TSDeclareMethod;
@@ -13989,6 +13941,7 @@ function tsPropertySignature(key, typeAnnotation2 = null) {
         type: 'TSPropertySignature',
         key,
         typeAnnotation: typeAnnotation2,
+        computed: false,
     };
     
     const defs = NODE_FIELDS.TSPropertySignature;
@@ -14004,7 +13957,8 @@ function tsMethodSignature(key, typeParameters = null, params, returnType = null
         typeParameters,
         params,
         returnType,
-        kind: null,
+        computed: false,
+        kind: 'method',
     };
     
     const defs = NODE_FIELDS.TSMethodSignature;
@@ -14544,7 +14498,7 @@ function tsModuleDeclaration(id, body) {
         type: 'TSModuleDeclaration',
         id,
         body,
-        kind: null,
+        kind: 'namespace',
     };
     
     const defs = NODE_FIELDS.TSModuleDeclaration;
@@ -14841,9 +14795,6 @@ var b = /* @__PURE__ */Object.freeze({
     optionalIndexedAccessType,
     optionalMemberExpression,
     parenthesizedExpression,
-    pipelineBareFunction,
-    pipelinePrimaryTopicReference,
-    pipelineTopicExpression,
     placeholder,
     privateName,
     program,
@@ -15052,7 +15003,6 @@ var ExportNamespaceSpecifier = alias('exportNamespaceSpecifier');
 var OptionalMemberExpression = alias('optionalMemberExpression');
 var OptionalCallExpression = alias('optionalCallExpression');
 var ClassProperty = alias('classProperty');
-var ClassAccessorProperty = alias('classAccessorProperty');
 var ClassPrivateProperty = alias('classPrivateProperty');
 var ClassPrivateMethod = alias('classPrivateMethod');
 var PrivateName = alias('privateName');
@@ -15142,14 +15092,12 @@ var Placeholder = alias('placeholder');
 var V8IntrinsicIdentifier = alias('v8IntrinsicIdentifier');
 var ArgumentPlaceholder = alias('argumentPlaceholder');
 var BindExpression = alias('bindExpression');
+var ClassAccessorProperty = alias('classAccessorProperty');
 var Decorator = alias('decorator');
 var DoExpression = alias('doExpression');
 var ExportDefaultSpecifier = alias('exportDefaultSpecifier');
 var ModuleExpression = alias('moduleExpression');
 var TopicReference = alias('topicReference');
-var PipelineTopicExpression = alias('pipelineTopicExpression');
-var PipelineBareFunction = alias('pipelineBareFunction');
-var PipelinePrimaryTopicReference = alias('pipelinePrimaryTopicReference');
 var VoidPattern = alias('voidPattern');
 var TSParameterProperty = alias('tsParameterProperty');
 var TSDeclareFunction = alias('tsDeclareFunction');
@@ -15632,10 +15580,6 @@ function assertClassProperty(node, opts) {
     assert('ClassProperty', node, opts);
 }
 
-function assertClassAccessorProperty(node, opts) {
-    assert('ClassAccessorProperty', node, opts);
-}
-
 function assertClassPrivateProperty(node, opts) {
     assert('ClassPrivateProperty', node, opts);
 }
@@ -15992,6 +15936,10 @@ function assertBindExpression(node, opts) {
     assert('BindExpression', node, opts);
 }
 
+function assertClassAccessorProperty(node, opts) {
+    assert('ClassAccessorProperty', node, opts);
+}
+
 function assertDecorator(node, opts) {
     assert('Decorator', node, opts);
 }
@@ -16012,18 +15960,6 @@ function assertTopicReference(node, opts) {
     assert('TopicReference', node, opts);
 }
 
-function assertPipelineTopicExpression(node, opts) {
-    assert('PipelineTopicExpression', node, opts);
-}
-
-function assertPipelineBareFunction(node, opts) {
-    assert('PipelineBareFunction', node, opts);
-}
-
-function assertPipelinePrimaryTopicReference(node, opts) {
-    assert('PipelinePrimaryTopicReference', node, opts);
-}
-
 function assertVoidPattern(node, opts) {
     assert('VoidPattern', node, opts);
 }
@@ -16440,10 +16376,6 @@ function assertModuleSpecifier(node, opts) {
     assert('ModuleSpecifier', node, opts);
 }
 
-function assertAccessor(node, opts) {
-    assert('Accessor', node, opts);
-}
-
 function assertPrivate(node, opts) {
     assert('Private', node, opts);
 }
@@ -16484,6 +16416,10 @@ function assertMiscellaneous(node, opts) {
     assert('Miscellaneous', node, opts);
 }
 
+function assertAccessor(node, opts) {
+    assert('Accessor', node, opts);
+}
+
 function assertTypeScript(node, opts) {
     assert('TypeScript', node, opts);
 }
@@ -16846,7 +16782,7 @@ function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
         };
         
         if (withoutLoc) {
-            ret.loc = null;
+            ret.loc = void 0;
         }
         
         commentsCache.set(comment, ret);
@@ -16965,7 +16901,6 @@ var CLASS_TYPES = FLIPPED_ALIAS_KEYS['Class'];
 var IMPORTOREXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS['ImportOrExportDeclaration'];
 var EXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS['ExportDeclaration'];
 var MODULESPECIFIER_TYPES = FLIPPED_ALIAS_KEYS['ModuleSpecifier'];
-var ACCESSOR_TYPES = FLIPPED_ALIAS_KEYS['Accessor'];
 var PRIVATE_TYPES = FLIPPED_ALIAS_KEYS['Private'];
 var FLOW_TYPES = FLIPPED_ALIAS_KEYS['Flow'];
 var FLOWTYPE_TYPES = FLIPPED_ALIAS_KEYS['FlowType'];
@@ -16976,6 +16911,7 @@ var ENUMBODY_TYPES = FLIPPED_ALIAS_KEYS['EnumBody'];
 var ENUMMEMBER_TYPES = FLIPPED_ALIAS_KEYS['EnumMember'];
 var JSX_TYPES = FLIPPED_ALIAS_KEYS['JSX'];
 var MISCELLANEOUS_TYPES = FLIPPED_ALIAS_KEYS['Miscellaneous'];
+var ACCESSOR_TYPES = FLIPPED_ALIAS_KEYS['Accessor'];
 var TYPESCRIPT_TYPES = FLIPPED_ALIAS_KEYS['TypeScript'];
 var TSTYPEELEMENT_TYPES = FLIPPED_ALIAS_KEYS['TSTypeElement'];
 var TSTYPE_TYPES = FLIPPED_ALIAS_KEYS['TSType'];
@@ -17558,6 +17494,8 @@ function getObjectMemberKey(node) {
     if (!node.computed || isLiteral(node.key)) {
         return node.key;
     }
+    
+    return null;
 }
 
 function getFunctionName(node, parent) {
@@ -17580,7 +17518,7 @@ function getFunctionName(node, parent) {
             prefix2 = 'get ';
         else if (node.kind === 'set')
             prefix2 = 'set ';
-    } else if (isVariableDeclarator(parent, {init: node})) {
+    } else if (isVariableDeclarator(parent) && parent.init === node) {
         id = parent.id;
     } else if (isAssignmentExpression(parent, {operator: '=', right: node})) {
         id = parent.left;
@@ -21060,7 +20998,7 @@ function isWhitespace(code2) {
     }
 }
 
-var JsxErrors = ParseErrorEnum`jsx`({
+var JsxErrorTemplates = {
     AttributeIsEmpty: 'JSX attributes must only be assigned a non-empty expression.',
     MissingClosingTagElement: ({openingTagName}) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
     MissingClosingTagFragment: 'Expected corresponding JSX closing tag for <>.',
@@ -21069,7 +21007,9 @@ var JsxErrors = ParseErrorEnum`jsx`({
     UnsupportedJsxValue: 'JSX value should be either an expression or a quoted JSX text.',
     UnterminatedJsxContent: 'Unterminated JSX contents.',
     UnwrappedAdjacentJSXElements: 'Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?',
-});
+};
+
+var JsxErrors = ParseErrorEnum`jsx`(JsxErrorTemplates);
 
 function isFragment(object) {
     return object ? object.type === 'JSXOpeningFragment' || object.type === 'JSXClosingFragment' : false;
@@ -25000,7 +24940,7 @@ function assert2(x) {
     }
 }
 
-var TSErrors = ParseErrorEnum`typescript`({
+var TSErrorTemplates = {
     AbstractMethodHasImplementation: ({methodName}) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
     AbstractPropertyHasInitializer: ({propertyName}) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
     AccessorCannotBeOptional: 'An \'accessor\' property cannot be declared optional.',
@@ -25066,7 +25006,9 @@ var TSErrors = ParseErrorEnum`typescript`({
     UnsupportedParameterPropertyKind: 'A parameter property may not be declared using a binding pattern.',
     UnsupportedSignatureParameterKind: ({type}) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,
     UsingDeclarationInAmbientContext: (kind) => `'${kind}' declarations are not allowed in ambient contexts.`,
-});
+};
+
+var TSErrors = ParseErrorEnum`typescript`(TSErrorTemplates);
 
 function keywordTypeFromName(value) {
     switch(value) {
@@ -27759,8 +27701,18 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     parseClassSuper(node) {
         super.parseClassSuper(node);
         
-        if (node.superClass && (this.match(43) || this.match(47))) {
-            node.superTypeArguments = this.tsParseTypeArgumentsInExpression();
+        if (node.superClass) {
+            if (node.superClass.type === 'TSInstantiationExpression') {
+                const tsInstantiationExpression2 = node.superClass;
+                const superClass2 = tsInstantiationExpression2.expression;
+                this.takeSurroundingComments(superClass2, superClass2.start, superClass2.end);
+                const superTypeArguments = tsInstantiationExpression2.typeArguments;
+                this.takeSurroundingComments(superTypeArguments, superTypeArguments.start, superTypeArguments.end);
+                node.superClass = superClass2;
+                node.superTypeArguments = superTypeArguments;
+            } else if (this.match(43) || this.match(47)) {
+                node.superTypeArguments = this.tsParseTypeArgumentsInExpression();
+            }
         }
         
         if (this.eatContextual(109)) {
@@ -27801,12 +27753,12 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         }
     }
     
-    parseAsyncArrowFromCallExpression(node, call2) {
+    parseAsyncArrowFromCallExpression(node, call) {
         if (this.match(10)) {
             node.returnType = this.tsParseTypeAnnotation();
         }
         
-        return super.parseAsyncArrowFromCallExpression(node, call2);
+        return super.parseAsyncArrowFromCallExpression(node, call);
     }
     
     parseMaybeAssign(refExpressionErrors, afterLeftParse) {
@@ -28064,10 +28016,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             const typeArguments = this.tsParseTypeArgumentsInExpression();
             
             if (this.match(6)) {
-                const call2 = super.parseMaybeDecoratorArguments(expr, startLoc);
+                const call = super.parseMaybeDecoratorArguments(expr, startLoc);
                 
-                call2.typeArguments = typeArguments;
-                return call2;
+                call.typeArguments = typeArguments;
+                return call;
             }
             
             this.unexpected(null, 6);
@@ -28627,10 +28579,12 @@ function isUncomputedMemberExpressionChain(expression2) {
     return isUncomputedMemberExpressionChain(expression2.object);
 }
 
-var PlaceholderErrors = ParseErrorEnum`placeholders`({
+var PlaceholderErrorTemplates = {
     ClassNameIsRequired: 'A class name is required.',
     UnexpectedSpace: 'Unexpected space in placeholder.',
-});
+};
+
+var PlaceholderErrors = ParseErrorEnum`placeholders`(PlaceholderErrorTemplates);
 
 var placeholders = (superClass) => class PlaceholdersParserMixin extends superClass {
     parsePlaceholder(expectedNode) {
@@ -29688,17 +29642,17 @@ var ExpressionParser = class extends LValParser {
         return this.match(15) && !this.canInsertSemicolon();
     }
     
-    parseAsyncArrowFromCallExpression(node, call2) {
-        this.resetPreviousNodeTrailingComments(call2);
+    parseAsyncArrowFromCallExpression(node, call) {
+        this.resetPreviousNodeTrailingComments(call);
         this.expect(15);
-        this.parseArrowExpression(node, call2.arguments, true, call2.extra?.trailingCommaLoc);
+        this.parseArrowExpression(node, call.arguments, true, call.extra?.trailingCommaLoc);
         
-        if (call2.innerComments) {
-            setInnerComments(node, call2.innerComments);
+        if (call.innerComments) {
+            setInnerComments(node, call.innerComments);
         }
         
-        if (call2.callee.trailingComments) {
-            setInnerComments(node, call2.callee.trailingComments);
+        if (call.callee.trailingComments) {
+            setInnerComments(node, call.callee.trailingComments);
         }
         
         return node;
@@ -33395,7 +33349,7 @@ var Parser = class extends StatementParser {
         const program3 = this.startNode();
         
         this.nextToken();
-        file2.errors = null;
+        file2.errors = [];
         const result = this.parseTopLevel(file2, program3);
         
         result.errors = this.state.errors;
@@ -34207,7 +34161,7 @@ function highlight(text) {
 
 var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 
-function getMarkerLines(loc, source, opts) {
+function getMarkerLines(loc, source, opts, startLineBaseZero) {
     const startLoc = {
         column: 0,
         line: -1,
@@ -34221,9 +34175,9 @@ function getMarkerLines(loc, source, opts) {
     
     const {linesAbove = 2, linesBelow = 3} = opts || {};
     
-    const startLine = startLoc.line;
+    const startLine = startLoc.line - startLineBaseZero;
     const startColumn = startLoc.column;
-    const endLine = endLoc.line;
+    const endLine = endLoc.line - startLineBaseZero;
     const endColumn = endLoc.column;
     let start = Math.max(startLine - (linesAbove + 1), 0);
     let end = Math.min(source.length, endLine + linesBelow);
@@ -34283,6 +34237,7 @@ function getMarkerLines(loc, source, opts) {
 
 function codeFrameColumns(rawLines, loc, opts = {}) {
     const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+    const startLineBaseZero = (opts.startLine || 1) - 1;
     const defs = getDefs(shouldHighlight);
     const lines = rawLines.split(NEWLINE);
     
@@ -34290,10 +34245,10 @@ function codeFrameColumns(rawLines, loc, opts = {}) {
         start,
         end,
         markerLines,
-    } = getMarkerLines(loc, lines, opts);
+    } = getMarkerLines(loc, lines, opts, startLineBaseZero);
     
     const hasColumns = loc.start && typeof loc.start.column === 'number';
-    const numberMaxWidth = String(end).length;
+    const numberMaxWidth = String(end + startLineBaseZero).length;
     const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
     
     let frame = highlightedLines
@@ -34301,7 +34256,7 @@ function codeFrameColumns(rawLines, loc, opts = {}) {
         .slice(start, end)
         .map((line, index3) => {
         const number = start + 1 + index3;
-        const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+        const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
         const gutter = ` ${paddedNumber} |`;
         const hasMarker = markerLines[number];
         const lastMarkerLine = !markerLines[number + 1];
@@ -34961,28 +34916,18 @@ function createTemplateBuilder(formatter, defaultOpts) {
 }
 
 function extendedTrace(fn) {
-    let rootStack = '';
+    const rootErr = new Error();
     
-    try {
-        throw new Error();
-    } catch(error) {
-        if (error.stack) {
-            rootStack = error.stack
-                .split('\n')
-                .slice(3)
-                .join('\n');
-        }
-    }
-
-
-        
     return (arg) => {
         try {
             return fn(arg);
         } catch(err) {
             err.stack += `
     =============
-${rootStack}`;
+${rootErr.stack
+                .split('\n')
+                .slice(3)
+                .join('\n')}`;
             throw err;
         }
     };
@@ -36438,7 +36383,7 @@ var PRECEDENCE = /* @__PURE__ */new Map([
 ]);
 
 function isTSTypeExpression(nodeId) {
-    return nodeId === 156 || nodeId === 201 || nodeId === 209;
+    return nodeId === 153 || nodeId === 198 || nodeId === 206;
 }
 
 var isClassExtendsClause = (node, parent, parentId) => {
@@ -36456,10 +36401,10 @@ var hasPostfixPart = (node, parent, parentId) => {
     case 112:
         return parent.callee === node;
     
-    case 222:
+    case 219:
         return parent.tag === node;
     
-    case 191:
+    case 188:
         return true;
     }
     
@@ -36471,7 +36416,7 @@ function NullableTypeAnnotation$1(node, parent, parentId) {
 }
 
 function FunctionTypeAnnotation$1(node, parent, parentId, tokenContext) {
-    return parentId === 239
+    return parentId === 236
         || parentId === 90
         || parentId === 4
         || (tokenContext & 8) > 0;
@@ -36498,7 +36443,7 @@ function BinaryLike(node, parent, parentId, nodeType) {
         return true;
     }
     
-    if (hasPostfixPart(node, parent, parentId) || parentId === 238 || parentId === 145 || parentId === 8) {
+    if (hasPostfixPart(node, parent, parentId) || parentId === 235 || parentId === 142 || parentId === 8) {
         return true;
     }
     
@@ -36510,8 +36455,8 @@ function BinaryLike(node, parent, parentId, nodeType) {
         parentPos = PRECEDENCE.get(parent.operator);
         break;
     
-    case 156:    
-    case 201:
+    case 153:    
+    case 198:
         parentPos = 7;
     }
     
@@ -36538,7 +36483,7 @@ function UnionTypeAnnotation$1(node, parent, parentId) {
     case 4:    
     case 115:    
     case 90:    
-    case 239:
+    case 236:
         return true;
     }
     
@@ -36563,18 +36508,18 @@ function TSAsExpression$1(node, parent, parentId) {
 
 function TSConditionalType$1(node, parent, parentId) {
     switch(parentId) {
-    case 155:    
-    case 195:    
-    case 211:    
-    case 212:    
-    case 181:    
-    case 219:
+    case 152:    
+    case 192:    
+    case 208:    
+    case 209:    
+    case 178:    
+    case 216:
         return true;
     
-    case 175:
+    case 172:
         return parent.objectType === node;
     
-    case 161:
+    case 158:
         return parent.checkType === node || parent.extendsType === node;
     }
     
@@ -36583,13 +36528,13 @@ function TSConditionalType$1(node, parent, parentId) {
 
 function TSUnionType$1(node, parent, parentId) {
     switch(parentId) {
-    case 181:    
-    case 211:    
-    case 155:    
-    case 195:
+    case 178:    
+    case 208:    
+    case 152:    
+    case 192:
         return true;
     
-    case 175:
+    case 172:
         return parent.objectType === node;
     }
     
@@ -36597,7 +36542,7 @@ function TSUnionType$1(node, parent, parentId) {
 }
 
 function TSIntersectionType$1(node, parent, parentId) {
-    return parentId === 211 || TSTypeOperator$1(node, parent, parentId);
+    return parentId === 208 || TSTypeOperator$1(node, parent, parentId);
 }
 
 function TSInferType$1(node, parent, parentId) {
@@ -36605,7 +36550,7 @@ function TSInferType$1(node, parent, parentId) {
         return true;
     }
     
-    if ((parentId === 181 || parentId === 219) && node.typeParameter.constraint != null) {
+    if ((parentId === 178 || parentId === 216) && node.typeParameter.constraint != null) {
         return true;
     }
     
@@ -36614,11 +36559,11 @@ function TSInferType$1(node, parent, parentId) {
 
 function TSTypeOperator$1(node, parent, parentId) {
     switch(parentId) {
-    case 155:    
-    case 195:
+    case 152:    
+    case 192:
         return true;
     
-    case 175:
+    case 172:
         if (parent.objectType === node) {
             return true;
         }
@@ -36632,7 +36577,7 @@ function TSInstantiationExpression$1(node, parent, parentId) {
     case 17:    
     case 130:    
     case 112:    
-    case 177:
+    case 174:
         return parent.typeArguments != null;
     }
     
@@ -36643,8 +36588,8 @@ function TSFunctionType$1(node, parent, parentId) {
     if (TSUnionType$1(node, parent, parentId))
         return true;
     
-    return parentId === 219
-        || parentId === 161
+    return parentId === 216
+        || parentId === 158
         && (parent.checkType === node
         || parent.extendsType === node);
 }
@@ -36661,7 +36606,7 @@ function LogicalExpression2(node, parent, parentId) {
 }
 
 function SequenceExpression$1(node, parent, parentId) {
-    if (parentId === 144 || parentId === 133 || parentId === 108 && parent.property === node || parentId === 132 && parent.property === node || parentId === 224) {
+    if (parentId === 141 || parentId === 133 || parentId === 108 && parent.property === node || parentId === 132 && parent.property === node || parentId === 221) {
         return false;
     }
     
@@ -36683,8 +36628,8 @@ function SequenceExpression$1(node, parent, parentId) {
 function YieldExpression$1(node, parent, parentId) {
     return parentId === 10
         || parentId === 107
-        || parentId === 238
-        || parentId === 145
+        || parentId === 235
+        || parentId === 142
         || hasPostfixPart(node, parent, parentId)
         || parentId === 8
         && isYieldExpression2(node)
@@ -36712,8 +36657,8 @@ function FunctionExpression$1(node, parent, parentId, tokenContext) {
 
 function ConditionalExpression$1(node, parent, parentId) {
     switch(parentId) {
-    case 238:    
-    case 145:    
+    case 235:    
+    case 142:    
     case 10:    
     case 107:    
     case 8:
@@ -38968,18 +38913,6 @@ function TopicReference2() {
     }
 }
 
-function PipelineTopicExpression2(node) {
-    this.print(node.expression);
-}
-
-function PipelineBareFunction2(node) {
-    this.print(node.callee);
-}
-
-function PipelinePrimaryTopicReference2() {
-    this.tokenChar(35);
-}
-
 function VoidPattern2() {
     this.word('void');
 }
@@ -40251,9 +40184,6 @@ var generatorFunctions = /* @__PURE__ */Object.freeze({
     OptionalIndexedAccessType: OptionalIndexedAccessType2,
     OptionalMemberExpression: OptionalMemberExpression2,
     ParenthesizedExpression: ParenthesizedExpression2,
-    PipelineBareFunction: PipelineBareFunction2,
-    PipelinePrimaryTopicReference: PipelinePrimaryTopicReference2,
-    PipelineTopicExpression: PipelineTopicExpression2,
     Placeholder: Placeholder2,
     PrivateName: PrivateName2,
     Program: Program2,
@@ -41241,9 +41171,9 @@ var Printer = class {
         if (!shouldPrintParens && parenthesized && node.leadingComments?.length && node.leadingComments[0].type === 'CommentBlock') {
             switch(parentId) {
             case 65:            
-            case 243:            
+            case 240:            
             case 6:            
-            case 143:
+            case 140:
                 break;
             
             case 17:            
@@ -41301,7 +41231,7 @@ var Printer = class {
         }
         
         this._printLeadingComments(node, parent);
-        this.exactSource(nodeId === 139 || nodeId === 66 ? null : loc, printMethod.bind(this, node, parent));
+        this.exactSource(nodeId === 136 || nodeId === 66 ? null : loc, printMethod.bind(this, node, parent));
         
         if (shouldPrintParens) {
             this._printTrailingComments(node, parent);
@@ -42120,6 +42050,180 @@ var virtualTypes = /* @__PURE__ */Object.freeze({
     Var,
 });
 
+var TraversalContext = class {
+    constructor(opts, state) {
+        this.state = state;
+        this.opts = opts;
+    }
+    
+    queue = null;
+    priorityQueue = null;
+    maybeQueue(path, notPriority) {
+        if (this.queue) {
+            if (notPriority) {
+                this.queue.push(path);
+            } else {
+                this.priorityQueue.push(path);
+            }
+        }
+    }
+};
+
+var {VISITOR_KEYS: VISITOR_KEYS$4} = lib_exports;
+
+function _visitPaths(ctx, paths) {
+    ctx.queue = paths;
+    ctx.priorityQueue = [];
+    const visited =     /* @__PURE__ */new Set();
+    let stop2 = false;
+    let visitIndex = 0;
+    
+    for (; visitIndex < paths.length;) {
+        const path = paths[visitIndex];
+        visitIndex++;
+        resync.call(path);
+        
+        if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== ctx) {
+            pushContext.call(path, ctx);
+        }
+        
+        if (path.key === null)
+            continue;
+        
+        const {node} = path;
+        
+        if (visited.has(node))
+            continue;
+        
+        if (node)
+            visited.add(node);
+        
+        if (_visit(ctx, path)) {
+            stop2 = true;
+            break;
+        }
+        
+        if (ctx.priorityQueue.length) {
+            stop2 = _visitPaths(ctx, ctx.priorityQueue);
+            ctx.priorityQueue = [];
+            ctx.queue = paths;
+            
+            if (stop2)
+                break;
+        }
+    }
+    
+    for (let i = 0; i < visitIndex; i++) {
+        popContext.call(paths[i]);
+    }
+    
+    ctx.queue = null;
+    
+    return stop2;
+}
+
+function _visit(ctx, path) {
+    const node = path.node;
+    
+    if (!node) {
+        return false;
+    }
+    
+    const opts = ctx.opts;
+    const denylist = opts.denylist;
+    
+    if (denylist?.includes(node.type)) {
+        return false;
+    }
+    
+    if (opts.shouldSkip?.(path)) {
+        return false;
+    }
+    
+    if (path.shouldSkip)
+        return path.shouldStop;
+    
+    if (_call.call(path, opts.enter))
+        return path.shouldStop;
+    
+    if (path.node) {
+        if (_call.call(path, opts[node.type]?.enter))
+            return path.shouldStop;
+    }
+    
+    path.shouldStop = traverseNode(path.node, opts, path.scope, ctx.state, path, path.skipKeys);
+    
+    if (path.node) {
+        if (_call.call(path, opts.exit))
+            return true;
+    }
+    
+    if (path.node) {
+        _call.call(path, opts[node.type]?.exit);
+    }
+    
+    return path.shouldStop;
+}
+
+function traverseNode(node, opts, scope2, state, path, skipKeys, visitSelf) {
+    const keys2 = VISITOR_KEYS$4[node.type];
+    
+    if (!keys2?.length)
+        return false;
+    
+    const ctx = new TraversalContext(opts, state);
+    
+    if (visitSelf) {
+        if (skipKeys?.[path.parentKey])
+            return false;
+        
+        return _visitPaths(ctx, [path]);
+    }
+    
+    const hub = path == null ? node.type === 'Program' || node.type === 'File' ? new Hub() : void 0 : path.hub;
+    
+    for (const key of keys2) {
+        if (skipKeys?.[key])
+            continue;
+        
+        const prop = node[key];
+        
+        if (!prop)
+            continue;
+        
+        if (Array.isArray(prop)) {
+            if (!prop.length)
+                continue;
+            
+            const paths = [];
+            
+            for (let i = 0; i < prop.length; i++) {
+                const childPath = NodePath_Final.get({
+                    parentPath: path,
+                    parent: node,
+                    container: prop,
+                    key: i,
+                    listKey: key,
+                    hub,
+                });
+                
+                paths.push(childPath);
+            }
+            
+            if (_visitPaths(ctx, paths))
+                return true;
+        } else {
+            if (_visitPaths(ctx, [
+                NodePath_Final.get({parentPath: path, parent: node, container: node, key, listKey: null, hub}),
+            ])) {
+                return true;
+            }
+        }
+    }
+    
+    return false;
+}
+
 var {
     isBinding: isBinding2,
     isBlockScoped: nodeIsBlockScoped,
@@ -42724,7 +42828,7 @@ var Renamer = class {
     }
 };
 
-var {VISITOR_KEYS: VISITOR_KEYS$5} = lib_exports;
+var {VISITOR_KEYS: VISITOR_KEYS$3} = lib_exports;
 
 function traverseForScope(path, visitors2, state) {
     const exploded = explode$1(visitors2);
@@ -42752,8 +42856,8 @@ function traverseForScope(path, visitors2, state) {
         const visitor = exploded[node.type];
         
         if (visitor?.enter) {
-            for (const visit2 of visitor.enter) {
-                visit2.call(state, path2, state);
+            for (const visit of visitor.enter) {
+                visit.call(state, path2, state);
             }
         }
         
@@ -42761,7 +42865,7 @@ function traverseForScope(path, visitors2, state) {
             return;
         }
         
-        const keys2 = VISITOR_KEYS$5[node.type];
+        const keys2 = VISITOR_KEYS$3[node.type];
         
         if (!keys2?.length) {
             return;
@@ -42784,8 +42888,8 @@ function traverseForScope(path, visitors2, state) {
         }
         
         if (visitor?.exit) {
-            for (const visit2 of visitor.exit) {
-                visit2.call(state, path2, state);
+            for (const visit of visitor.exit) {
+                visit.call(state, path2, state);
             }
         }
     }
@@ -43798,8 +43902,8 @@ collectorVisitor]);
             const typeVisitors = scopeVisitor[path.type];
             
             if (typeVisitors) {
-                for (const visit2 of typeVisitors.enter) {
-                    visit2.call(state, path, state);
+                for (const visit of typeVisitors.enter) {
+                    visit.call(state, path, state);
                 }
             }
         }
@@ -44111,7 +44215,7 @@ collectorVisitor]);
     }
 };
 
-var {VISITOR_KEYS: VISITOR_KEYS$4} = lib_exports;
+var {VISITOR_KEYS: VISITOR_KEYS$2} = lib_exports;
 
 function findParent(callback) {
     let path = this;
@@ -44159,7 +44263,7 @@ function getStatementParent() {
 function getEarliestCommonAncestorFrom(paths) {
     return this.getDeepestCommonAncestorFrom(paths, function(deepest, i, ancestries) {
         let earliest;
-        const keys2 = VISITOR_KEYS$4[deepest.type];
+        const keys2 = VISITOR_KEYS$2[deepest.type];
         
         for (const ancestry of ancestries) {
             const path = ancestry[i + 1];
@@ -46020,7 +46124,7 @@ function _evaluate(path, state) {
             const object = callee.get('object');
             const property = callee.get('property');
             
-            if (object.isIdentifier() && property.isIdentifier() && isValidObjectCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
+            if (object.isIdentifier() && property.isIdentifier() && isValidObjectCallee(object.node.name) && !isInvalidMethod(property.node.name) && !path.scope.getBinding(object.node.name)) {
                 context = global[object.node.name];
                 const key = property.node.name;
                 
@@ -46381,20 +46485,20 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
                 args.push(value);
             }
             
-            const call2 = callExpression2(identifier3(superBinding), args);
+            const call = callExpression2(identifier3(superBinding), args);
             
             if (isCall) {
                 superParentPath.unshiftContainer('arguments', thisExpression2());
-                superProp.replaceWith(memberExpression2(call2, identifier3('call')));
+                superProp.replaceWith(memberExpression2(call, identifier3('call')));
                 thisPaths.push(superParentPath.get('arguments.0'));
             } else if (isAssignment) {
-                superParentPath.replaceWith(call2);
+                superParentPath.replaceWith(call);
             } else if (isTaggedTemplate) {
                 thisPaths.push(superProp
-                    .replaceWith(callExpression2(memberExpression2(call2, identifier3('bind'), false), [thisExpression2()]))[0]
+                    .replaceWith(callExpression2(memberExpression2(call, identifier3('bind'), false), [thisExpression2()]))[0]
                     .get('arguments.0'));
             } else {
-                superProp.replaceWith(call2);
+                superProp.replaceWith(call);
             }
 
         });
@@ -46784,7 +46888,7 @@ function ensureFunctionName(supportUnicodeId) {
         params.push(scope2.generateUidIdentifier('x'));
     }
     
-    const call2 = index.expression.ast`
+    const call = index.expression.ast`
     (function (${key}) {
       function ${id}(${params}) {
         return ${cloneNode3(key)}.apply(this, arguments);
@@ -46799,7 +46903,7 @@ function ensureFunctionName(supportUnicodeId) {
   `;
     
     return this
-        .replaceWith(call2)[0]
+        .replaceWith(call)[0]
         .get('arguments.0');
 }
 
@@ -46810,7 +46914,7 @@ function getFunctionArity(node) {
 
 var {
     STATEMENT_OR_BLOCK_KEYS: STATEMENT_OR_BLOCK_KEYS2,
-    VISITOR_KEYS: VISITOR_KEYS$3,
+    VISITOR_KEYS: VISITOR_KEYS$12,
     isBlockStatement: isBlockStatement2,
     isExpression: isExpression3,
     isIdentifier: isIdentifier4,
@@ -47056,7 +47160,7 @@ function _guessExecutionStatusRelativeToCached(base, target, cache2) {
         return divergence.target.key > divergence.this.key ? 'before' : 'after';
     }
     
-    const keys2 = VISITOR_KEYS$3[commonPath.type];
+    const keys2 = VISITOR_KEYS$12[commonPath.type];
     
     const keyPosition = {
         this: keys2.indexOf(divergence.this.parentKey),
@@ -47994,7 +48098,6 @@ var methods = {
     isConstantExpression,
     isInStrictMode,
     isDenylisted,
-    visit,
     skip,
     skipKey,
     stop,
@@ -48048,325 +48151,6 @@ for (const type of Object.keys(virtualTypes)) {
         TYPES.push(type);
 }
 
-var {VISITOR_KEYS: VISITOR_KEYS$2} = lib_exports;
-
-var TraversalContext = class {
-    constructor(scope2, opts, state, parentPath) {
-        this.parentPath = parentPath;
-        this.scope = scope2;
-        this.state = state;
-        this.opts = opts;
-    }
-    
-    queue = null;
-    priorityQueue = null;
-    shouldVisit(node) {
-        const opts = this.opts;
-        
-        if (opts.enter || opts.exit)
-            return true;
-        
-        if (opts[node.type])
-            return true;
-        
-        const keys2 = VISITOR_KEYS$2[node.type];
-        
-        if (!keys2?.length)
-            return false;
-        
-        for (const key of keys2) {
-            if (node[key]) {
-                return true;
-            }
-        }
-        
-        return false;
-    }
-    
-    create(node, container, key, listKey) {
-        return NodePath_Final.get({
-            parentPath: this.parentPath,
-            parent: node,
-            container,
-            key,
-            listKey,
-        });
-    }
-    
-    maybeQueue(path, notPriority) {
-        if (this.queue) {
-            if (notPriority) {
-                this.queue.push(path);
-            } else {
-                this.priorityQueue.push(path);
-            }
-        }
-    }
-    
-    visitMultiple(container, parent, listKey) {
-        if (container.length === 0)
-            return false;
-        
-        const queue = [];
-        
-        for (let key = 0; key < container.length; key++) {
-            const node = container[key];
-            
-            if (node && this.shouldVisit(node)) {
-                queue.push(this.create(parent, container, key, listKey));
-            }
-        }
-        
-        return this.visitQueue(queue);
-    }
-    
-    visitSingle(node, key) {
-        if (this.shouldVisit(node[key])) {
-            return this.visitQueue([this.create(node, node, key)]);
-        } else {
-            return false;
-        }
-    }
-    
-    visitQueue(queue) {
-        this.queue = queue;
-        this.priorityQueue = [];
-        const visited =         /* @__PURE__ */new WeakSet();
-        let stop2 = false;
-        let visitIndex = 0;
-        
-        for (; visitIndex < queue.length;) {
-            const path = queue[visitIndex];
-            visitIndex++;
-            resync.call(path);
-            
-            if (path.key === null)
-                continue;
-            
-            if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
-                pushContext.call(path, this);
-            }
-            
-            const {node} = path;
-            
-            if (visited.has(node))
-                continue;
-            
-            if (node)
-                visited.add(node);
-            
-            if (path.visit()) {
-                stop2 = true;
-                break;
-            }
-            
-            if (this.priorityQueue.length) {
-                stop2 = this.visitQueue(this.priorityQueue);
-                this.priorityQueue = [];
-                this.queue = queue;
-                
-                if (stop2)
-                    break;
-            }
-        }
-        
-        for (let i = 0; i < visitIndex; i++) {
-            if (queue[i].key === null)
-                continue;
-            
-            popContext.call(queue[i]);
-        }
-        
-        this.queue = null;
-        
-        return stop2;
-    }
-    
-    visit(node, key) {
-        const nodes = node[key];
-        
-        if (!nodes)
-            return false;
-        
-        if (Array.isArray(nodes)) {
-            return this.visitMultiple(nodes, node, key);
-        } else {
-            return this.visitSingle(node, key);
-        }
-    }
-};
-
-var {VISITOR_KEYS: VISITOR_KEYS$12} = lib_exports;
-
-function _visitPaths(ctx, paths) {
-    ctx.queue = paths;
-    ctx.priorityQueue = [];
-    const visited =     /* @__PURE__ */new Set();
-    let stop2 = false;
-    let visitIndex = 0;
-    
-    for (; visitIndex < paths.length;) {
-        const path = paths[visitIndex];
-        visitIndex++;
-        resync.call(path);
-        
-        if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== ctx) {
-            pushContext.call(path, ctx);
-        }
-        
-        if (path.key === null)
-            continue;
-        
-        const {node} = path;
-        
-        if (visited.has(node))
-            continue;
-        
-        if (node)
-            visited.add(node);
-        
-        if (_visit(ctx, path)) {
-            stop2 = true;
-            break;
-        }
-        
-        if (ctx.priorityQueue.length) {
-            stop2 = _visitPaths(ctx, ctx.priorityQueue);
-            ctx.priorityQueue = [];
-            ctx.queue = paths;
-            
-            if (stop2)
-                break;
-        }
-    }
-    
-    for (let i = 0; i < visitIndex; i++) {
-        popContext.call(paths[i]);
-    }
-    
-    ctx.queue = null;
-    
-    return stop2;
-}
-
-function _visit(ctx, path) {
-    const node = path.node;
-    
-    if (!node) {
-        return false;
-    }
-    
-    const opts = ctx.opts;
-    const denylist = opts.denylist;
-    
-    if (denylist?.includes(node.type)) {
-        return false;
-    }
-    
-    if (opts.shouldSkip?.(path)) {
-        return false;
-    }
-    
-    if (path.shouldSkip)
-        return path.shouldStop;
-    
-    if (_call.call(path, opts.enter))
-        return path.shouldStop;
-    
-    if (path.node) {
-        if (_call.call(path, opts[node.type]?.enter))
-            return path.shouldStop;
-    }
-    
-    path.shouldStop = traverseNode(path.node, opts, path.scope, ctx.state, path, path.skipKeys);
-    
-    if (path.node) {
-        if (_call.call(path, opts.exit))
-            return true;
-    }
-    
-    if (path.node) {
-        _call.call(path, opts[node.type]?.exit);
-    }
-    
-    return path.shouldStop;
-}
-
-function traverseNode(node, opts, scope2, state, path, skipKeys, visitSelf) {
-    const keys2 = VISITOR_KEYS$12[node.type];
-    
-    if (!keys2?.length)
-        return false;
-    
-    const ctx = new TraversalContext(scope2, opts, state, path);
-    
-    if (visitSelf) {
-        if (skipKeys?.[path.parentKey])
-            return false;
-        
-        return _visitPaths(ctx, [path]);
-    }
-    
-    const hub = path == null ? node.type === 'Program' || node.type === 'File' ? new Hub() : void 0 : path.hub;
-    
-    for (const key of keys2) {
-        if (skipKeys?.[key])
-            continue;
-        
-        const prop = node[key];
-        
-        if (!prop)
-            continue;
-        
-        if (Array.isArray(prop)) {
-            if (!prop.length)
-                continue;
-            
-            const paths = [];
-            
-            for (let i = 0; i < prop.length; i++) {
-                const childPath = NodePath_Final.get({
-                    parentPath: path,
-                    parent: node,
-                    container: prop,
-                    key: i,
-                    listKey: key,
-                    hub,
-                });
-                
-                paths.push(childPath);
-            }
-            
-            if (_visitPaths(ctx, paths))
-                return true;
-        } else {
-            if (_visitPaths(ctx, [
-                NodePath_Final.get({parentPath: path, parent: node, container: node, key, listKey: null, hub}),
-            ])) {
-                return true;
-            }
-        }
-    }
-    
-    return false;
-}
-
-function call(key) {
-    const opts = this.opts;
-    this.debug(key);
-    
-    if (this.node) {
-        if (_call.call(this, opts[key]))
-            return true;
-    }
-    
-    if (this.node) {
-        return _call.call(this, opts[this.node.type]?.[key]);
-    }
-    
-    return false;
-}
-
 function _call(fns) {
     if (!fns)
         return false;
@@ -48404,42 +48188,6 @@ function isDenylisted() {
     return !!this.opts.denylist?.includes(this.node.type);
 }
 
-function restoreContext(path, context) {
-    if (path.context !== context) {
-        path.context = context;
-        path.state = context.state;
-        path.opts = context.opts;
-    }
-}
-
-function visit() {
-    if (!this.node) {
-        return false;
-    }
-    
-    if (this.isDenylisted()) {
-        return false;
-    }
-    
-    if (this.opts.shouldSkip?.(this)) {
-        return false;
-    }
-    
-    const currentContext = this.context;
-    
-    if (this.shouldSkip || call.call(this, 'enter')) {
-        this.debug('Skip...');
-        return this.shouldStop;
-    }
-    
-    restoreContext(this, currentContext);
-    this.debug('Recursing into...');
-    this.shouldStop = traverseNode(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
-    restoreContext(this, currentContext);
-    call.call(this, 'exit');
-    return this.shouldStop;
-}
-
 function skip() {
     this.shouldSkip = true;
 }