@putout/babel 5.2.6 → 5.2.8

package/bundle/index.js

@@ -40,91 +40,6 @@ isNodeMode || !mod || !mod.__esModule ? __defProp(target, 'default', {
     enumerable: true,
 }) : target, mod));
 
-// ../babel-babel/node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS({
-    '../babel-babel/node_modules/picocolors/picocolors.js'(exports, module) {
-        var p = process || {};
-        var argv = p.argv || [];
-        var env = p.env || {};
-        var isColorSupported2 = !(!!env.NO_COLOR || argv.includes('--no-color'))
-            && (!!env.FORCE_COLOR
-            || argv.includes('--color')
-            || p.platform === 'win32'
-            || (p.stdout || {}).isTTY
-            && env.TERM !== 'dumb'
-            || !!env.CI);
-        
-        var formatter = (open, close, replace = open) => (input) => {
-            let string = '' + input, index3 = string.indexOf(close, open.length);
-            return ~index3 ? open + replaceClose(string, close, replace, index3) + close : open + string + close;
-        };
-        
-        var replaceClose = (string, close, replace, index3) => {
-            let result = '', cursor = 0;
-            
-            do {
-                result += string.substring(cursor, index3) + replace;
-                cursor = index3 + close.length;
-                index3 = string.indexOf(close, cursor);
-            } while (~index3)
-            
-            return result + string.substring(cursor);
-        };
-        
-        var createColors2 = (enabled2 = isColorSupported2) => {
-            let f = enabled2 ? formatter : () => String;
-            
-            return {
-                isColorSupported: enabled2,
-                reset: f('\x1B[0m', '\x1B[0m'),
-                bold: f('\x1B[1m', '\x1B[22m', '\x1B[22m\x1B[1m'),
-                dim: f('\x1B[2m', '\x1B[22m', '\x1B[22m\x1B[2m'),
-                italic: f('\x1B[3m', '\x1B[23m'),
-                underline: f('\x1B[4m', '\x1B[24m'),
-                inverse: f('\x1B[7m', '\x1B[27m'),
-                hidden: f('\x1B[8m', '\x1B[28m'),
-                strikethrough: f('\x1B[9m', '\x1B[29m'),
-                black: f('\x1B[30m', '\x1B[39m'),
-                red: f('\x1B[31m', '\x1B[39m'),
-                green: f('\x1B[32m', '\x1B[39m'),
-                yellow: f('\x1B[33m', '\x1B[39m'),
-                blue: f('\x1B[34m', '\x1B[39m'),
-                magenta: f('\x1B[35m', '\x1B[39m'),
-                cyan: f('\x1B[36m', '\x1B[39m'),
-                white: f('\x1B[37m', '\x1B[39m'),
-                gray: f('\x1B[90m', '\x1B[39m'),
-                bgBlack: f('\x1B[40m', '\x1B[49m'),
-                bgRed: f('\x1B[41m', '\x1B[49m'),
-                bgGreen: f('\x1B[42m', '\x1B[49m'),
-                bgYellow: f('\x1B[43m', '\x1B[49m'),
-                bgBlue: f('\x1B[44m', '\x1B[49m'),
-                bgMagenta: f('\x1B[45m', '\x1B[49m'),
-                bgCyan: f('\x1B[46m', '\x1B[49m'),
-                bgWhite: f('\x1B[47m', '\x1B[49m'),
-                blackBright: f('\x1B[90m', '\x1B[39m'),
-                redBright: f('\x1B[91m', '\x1B[39m'),
-                greenBright: f('\x1B[92m', '\x1B[39m'),
-                yellowBright: f('\x1B[93m', '\x1B[39m'),
-                blueBright: f('\x1B[94m', '\x1B[39m'),
-                magentaBright: f('\x1B[95m', '\x1B[39m'),
-                cyanBright: f('\x1B[96m', '\x1B[39m'),
-                whiteBright: f('\x1B[97m', '\x1B[39m'),
-                bgBlackBright: f('\x1B[100m', '\x1B[49m'),
-                bgRedBright: f('\x1B[101m', '\x1B[49m'),
-                bgGreenBright: f('\x1B[102m', '\x1B[49m'),
-                bgYellowBright: f('\x1B[103m', '\x1B[49m'),
-                bgBlueBright: f('\x1B[104m', '\x1B[49m'),
-                bgMagentaBright: f('\x1B[105m', '\x1B[49m'),
-                bgCyanBright: f('\x1B[106m', '\x1B[49m'),
-                bgWhiteBright: f('\x1B[107m', '\x1B[49m'),
-            };
-        };
-        
-        module.exports = createColors2();
-        module.exports.createColors = createColors2;
-    },
-});
-
 // ../babel-babel/node_modules/jsesc/jsesc.js
 var require_jsesc = __commonJS({
     '../babel-babel/node_modules/jsesc/jsesc.js'(exports, module) {
@@ -676,9 +591,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 +904,6 @@ __export(lib_exports, {
     assertParenthesizedExpression: () => assertParenthesizedExpression,
     assertPattern: () => assertPattern,
     assertPatternLike: () => assertPatternLike,
-    assertPipelineBareFunction: () => assertPipelineBareFunction,
-    assertPipelinePrimaryTopicReference: () => assertPipelinePrimaryTopicReference,
-    assertPipelineTopicExpression: () => assertPipelineTopicExpression,
     assertPlaceholder: () => assertPlaceholder,
     assertPrivate: () => assertPrivate,
     assertPrivateName: () => assertPrivateName,
@@ -1409,9 +1318,6 @@ __export(lib_exports, {
     isParenthesizedExpression: () => isParenthesizedExpression,
     isPattern: () => isPattern,
     isPatternLike: () => isPatternLike,
-    isPipelineBareFunction: () => isPipelineBareFunction,
-    isPipelinePrimaryTopicReference: () => isPipelinePrimaryTopicReference,
-    isPipelineTopicExpression: () => isPipelineTopicExpression,
     isPlaceholder: () => isPlaceholder,
     isPlaceholderType: () => isPlaceholderType,
     isPrivate: () => isPrivate,
@@ -1596,9 +1502,6 @@ __export(lib_exports, {
     optionalIndexedAccessType: () => optionalIndexedAccessType,
     optionalMemberExpression: () => optionalMemberExpression,
     parenthesizedExpression: () => parenthesizedExpression,
-    pipelineBareFunction: () => pipelineBareFunction,
-    pipelinePrimaryTopicReference: () => pipelinePrimaryTopicReference,
-    pipelineTopicExpression: () => pipelineTopicExpression,
     placeholder: () => placeholder,
     prependToMemberExpression: () => prependToMemberExpression,
     privateName: () => privateName,
@@ -4102,16 +4005,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 +4895,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 +4955,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 +5733,6 @@ function isStandardized(node, opts) {
     case 'OptionalMemberExpression':    
     case 'OptionalCallExpression':    
     case 'ClassProperty':    
-    case 'ClassAccessorProperty':    
     case 'ClassPrivateProperty':    
     case 'ClassPrivateMethod':    
     case 'PrivateName':    
@@ -5935,9 +5807,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 +6498,8 @@ function isProperty(node, opts) {
     switch(node.type) {
     case 'ObjectProperty':    
     case 'ClassProperty':    
-    case 'ClassAccessorProperty':    
-    case 'ClassPrivateProperty':
+    case 'ClassPrivateProperty':    
+    case 'ClassAccessorProperty':
         break;
     
     default:
@@ -6756,22 +6625,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 +6738,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;
@@ -9177,6 +9046,7 @@ defineType$4('ExportNamedDeclaration', {
         'declaration',
         'specifiers',
         'source',
+        'attributes',
     ],
     visitor: [
         'declaration',
@@ -9306,7 +9176,11 @@ defineType$4('ForOfStatement', {
     },
 });
 defineType$4('ImportDeclaration', {
-    builder: ['specifiers', 'source'],
+    builder: [
+        'specifiers',
+        'source',
+        'attributes',
+    ],
     visitor: [
         'specifiers',
         'source',
@@ -9792,66 +9666,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',
@@ -10845,6 +10659,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: {
@@ -10888,29 +10762,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',
@@ -11677,8 +11528,8 @@ function arrayExpression(elements) {
         elements,
     };
     
-    const defs = NODE_FIELDS.ArrayExpression;
-    validate(defs.elements, node, 'elements', elements, 1);
+    const defs2 = NODE_FIELDS.ArrayExpression;
+    validate(defs2.elements, node, 'elements', elements, 1);
     return node;
 }
 
@@ -11690,10 +11541,10 @@ function assignmentExpression(operator, left, right) {
         right,
     };
     
-    const defs = NODE_FIELDS.AssignmentExpression;
-    validate(defs.operator, node, 'operator', operator);
-    validate(defs.left, node, 'left', left, 1);
-    validate(defs.right, node, 'right', right, 1);
+    const defs2 = NODE_FIELDS.AssignmentExpression;
+    validate(defs2.operator, node, 'operator', operator);
+    validate(defs2.left, node, 'left', left, 1);
+    validate(defs2.right, node, 'right', right, 1);
     return node;
 }
 
@@ -11705,10 +11556,10 @@ function binaryExpression(operator, left, right) {
         right,
     };
     
-    const defs = NODE_FIELDS.BinaryExpression;
-    validate(defs.operator, node, 'operator', operator);
-    validate(defs.left, node, 'left', left, 1);
-    validate(defs.right, node, 'right', right, 1);
+    const defs2 = NODE_FIELDS.BinaryExpression;
+    validate(defs2.operator, node, 'operator', operator);
+    validate(defs2.left, node, 'left', left, 1);
+    validate(defs2.right, node, 'right', right, 1);
     return node;
 }
 
@@ -11718,8 +11569,8 @@ function interpreterDirective(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.InterpreterDirective;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.InterpreterDirective;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -11729,8 +11580,8 @@ function directive(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.Directive;
-    validate(defs.value, node, 'value', value, 1);
+    const defs2 = NODE_FIELDS.Directive;
+    validate(defs2.value, node, 'value', value, 1);
     return node;
 }
 
@@ -11740,8 +11591,8 @@ function directiveLiteral(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.DirectiveLiteral;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.DirectiveLiteral;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -11752,9 +11603,9 @@ function blockStatement(body, directives = []) {
         directives,
     };
     
-    const defs = NODE_FIELDS.BlockStatement;
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.directives, node, 'directives', directives, 1);
+    const defs2 = NODE_FIELDS.BlockStatement;
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.directives, node, 'directives', directives, 1);
     return node;
 }
 
@@ -11764,8 +11615,8 @@ function breakStatement(label = null) {
         label,
     };
     
-    const defs = NODE_FIELDS.BreakStatement;
-    validate(defs.label, node, 'label', label, 1);
+    const defs2 = NODE_FIELDS.BreakStatement;
+    validate(defs2.label, node, 'label', label, 1);
     return node;
 }
 
@@ -11776,9 +11627,9 @@ function callExpression(callee, _arguments) {
         arguments: _arguments,
     };
     
-    const defs = NODE_FIELDS.CallExpression;
-    validate(defs.callee, node, 'callee', callee, 1);
-    validate(defs.arguments, node, 'arguments', _arguments, 1);
+    const defs2 = NODE_FIELDS.CallExpression;
+    validate(defs2.callee, node, 'callee', callee, 1);
+    validate(defs2.arguments, node, 'arguments', _arguments, 1);
     return node;
 }
 
@@ -11789,9 +11640,9 @@ function catchClause(param = null, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.CatchClause;
-    validate(defs.param, node, 'param', param, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.CatchClause;
+    validate(defs2.param, node, 'param', param, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -11803,10 +11654,10 @@ function conditionalExpression(test, consequent, alternate) {
         alternate,
     };
     
-    const defs = NODE_FIELDS.ConditionalExpression;
-    validate(defs.test, node, 'test', test, 1);
-    validate(defs.consequent, node, 'consequent', consequent, 1);
-    validate(defs.alternate, node, 'alternate', alternate, 1);
+    const defs2 = NODE_FIELDS.ConditionalExpression;
+    validate(defs2.test, node, 'test', test, 1);
+    validate(defs2.consequent, node, 'consequent', consequent, 1);
+    validate(defs2.alternate, node, 'alternate', alternate, 1);
     return node;
 }
 
@@ -11816,8 +11667,8 @@ function continueStatement(label = null) {
         label,
     };
     
-    const defs = NODE_FIELDS.ContinueStatement;
-    validate(defs.label, node, 'label', label, 1);
+    const defs2 = NODE_FIELDS.ContinueStatement;
+    validate(defs2.label, node, 'label', label, 1);
     return node;
 }
 
@@ -11834,9 +11685,9 @@ function doWhileStatement(test, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.DoWhileStatement;
-    validate(defs.test, node, 'test', test, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.DoWhileStatement;
+    validate(defs2.test, node, 'test', test, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -11852,8 +11703,8 @@ function expressionStatement(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.ExpressionStatement;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.ExpressionStatement;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -11865,10 +11716,10 @@ function file(program3, comments = null, tokens = null) {
         tokens,
     };
     
-    const defs = NODE_FIELDS.File;
-    validate(defs.program, node, 'program', program3, 1);
-    validate(defs.comments, node, 'comments', comments, 1);
-    validate(defs.tokens, node, 'tokens', tokens);
+    const defs2 = NODE_FIELDS.File;
+    validate(defs2.program, node, 'program', program3, 1);
+    validate(defs2.comments, node, 'comments', comments, 1);
+    validate(defs2.tokens, node, 'tokens', tokens);
     return node;
 }
 
@@ -11880,10 +11731,10 @@ function forInStatement(left, right, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.ForInStatement;
-    validate(defs.left, node, 'left', left, 1);
-    validate(defs.right, node, 'right', right, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.ForInStatement;
+    validate(defs2.left, node, 'left', left, 1);
+    validate(defs2.right, node, 'right', right, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -11896,11 +11747,11 @@ function forStatement(init = null, test = null, update = null, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.ForStatement;
-    validate(defs.init, node, 'init', init, 1);
-    validate(defs.test, node, 'test', test, 1);
-    validate(defs.update, node, 'update', update, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.ForStatement;
+    validate(defs2.init, node, 'init', init, 1);
+    validate(defs2.test, node, 'test', test, 1);
+    validate(defs2.update, node, 'update', update, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -11914,12 +11765,12 @@ function functionDeclaration(id = null, params, body, generator = false, async =
         async,
     };
     
-    const defs = NODE_FIELDS.FunctionDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.generator, node, 'generator', generator);
-    validate(defs.async, node, 'async', async);
+    const defs2 = NODE_FIELDS.FunctionDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.generator, node, 'generator', generator);
+    validate(defs2.async, node, 'async', async);
     return node;
 }
 
@@ -11933,12 +11784,12 @@ function functionExpression(id = null, params, body, generator = false, async =
         async,
     };
     
-    const defs = NODE_FIELDS.FunctionExpression;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.generator, node, 'generator', generator);
-    validate(defs.async, node, 'async', async);
+    const defs2 = NODE_FIELDS.FunctionExpression;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.generator, node, 'generator', generator);
+    validate(defs2.async, node, 'async', async);
     return node;
 }
 
@@ -11948,8 +11799,8 @@ function identifier(name) {
         name,
     };
     
-    const defs = NODE_FIELDS.Identifier;
-    validate(defs.name, node, 'name', name);
+    const defs2 = NODE_FIELDS.Identifier;
+    validate(defs2.name, node, 'name', name);
     return node;
 }
 
@@ -11961,10 +11812,10 @@ function ifStatement(test, consequent, alternate = null) {
         alternate,
     };
     
-    const defs = NODE_FIELDS.IfStatement;
-    validate(defs.test, node, 'test', test, 1);
-    validate(defs.consequent, node, 'consequent', consequent, 1);
-    validate(defs.alternate, node, 'alternate', alternate, 1);
+    const defs2 = NODE_FIELDS.IfStatement;
+    validate(defs2.test, node, 'test', test, 1);
+    validate(defs2.consequent, node, 'consequent', consequent, 1);
+    validate(defs2.alternate, node, 'alternate', alternate, 1);
     return node;
 }
 
@@ -11975,9 +11826,9 @@ function labeledStatement(label, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.LabeledStatement;
-    validate(defs.label, node, 'label', label, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.LabeledStatement;
+    validate(defs2.label, node, 'label', label, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -11987,8 +11838,8 @@ function stringLiteral(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.StringLiteral;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.StringLiteral;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -11998,8 +11849,8 @@ function numericLiteral(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.NumericLiteral;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.NumericLiteral;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -12015,8 +11866,8 @@ function booleanLiteral(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.BooleanLiteral;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.BooleanLiteral;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -12027,9 +11878,9 @@ function regExpLiteral(pattern, flags = '') {
         flags,
     };
     
-    const defs = NODE_FIELDS.RegExpLiteral;
-    validate(defs.pattern, node, 'pattern', pattern);
-    validate(defs.flags, node, 'flags', flags);
+    const defs2 = NODE_FIELDS.RegExpLiteral;
+    validate(defs2.pattern, node, 'pattern', pattern);
+    validate(defs2.flags, node, 'flags', flags);
     return node;
 }
 
@@ -12041,10 +11892,10 @@ function logicalExpression(operator, left, right) {
         right,
     };
     
-    const defs = NODE_FIELDS.LogicalExpression;
-    validate(defs.operator, node, 'operator', operator);
-    validate(defs.left, node, 'left', left, 1);
-    validate(defs.right, node, 'right', right, 1);
+    const defs2 = NODE_FIELDS.LogicalExpression;
+    validate(defs2.operator, node, 'operator', operator);
+    validate(defs2.left, node, 'left', left, 1);
+    validate(defs2.right, node, 'right', right, 1);
     return node;
 }
 
@@ -12056,10 +11907,10 @@ function memberExpression(object, property, computed = false) {
         computed,
     };
     
-    const defs = NODE_FIELDS.MemberExpression;
-    validate(defs.object, node, 'object', object, 1);
-    validate(defs.property, node, 'property', property, 1);
-    validate(defs.computed, node, 'computed', computed);
+    const defs2 = NODE_FIELDS.MemberExpression;
+    validate(defs2.object, node, 'object', object, 1);
+    validate(defs2.property, node, 'property', property, 1);
+    validate(defs2.computed, node, 'computed', computed);
     return node;
 }
 
@@ -12070,9 +11921,9 @@ function newExpression(callee, _arguments) {
         arguments: _arguments,
     };
     
-    const defs = NODE_FIELDS.NewExpression;
-    validate(defs.callee, node, 'callee', callee, 1);
-    validate(defs.arguments, node, 'arguments', _arguments, 1);
+    const defs2 = NODE_FIELDS.NewExpression;
+    validate(defs2.callee, node, 'callee', callee, 1);
+    validate(defs2.arguments, node, 'arguments', _arguments, 1);
     return node;
 }
 
@@ -12085,11 +11936,11 @@ function program(body, directives = [], sourceType = 'script', interpreter = nul
         interpreter,
     };
     
-    const defs = NODE_FIELDS.Program;
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.directives, node, 'directives', directives, 1);
-    validate(defs.sourceType, node, 'sourceType', sourceType);
-    validate(defs.interpreter, node, 'interpreter', interpreter, 1);
+    const defs2 = NODE_FIELDS.Program;
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.directives, node, 'directives', directives, 1);
+    validate(defs2.sourceType, node, 'sourceType', sourceType);
+    validate(defs2.interpreter, node, 'interpreter', interpreter, 1);
     return node;
 }
 
@@ -12099,8 +11950,8 @@ function objectExpression(properties) {
         properties,
     };
     
-    const defs = NODE_FIELDS.ObjectExpression;
-    validate(defs.properties, node, 'properties', properties, 1);
+    const defs2 = NODE_FIELDS.ObjectExpression;
+    validate(defs2.properties, node, 'properties', properties, 1);
     return node;
 }
 
@@ -12116,14 +11967,14 @@ function objectMethod(kind, key, params, body, computed = false, generator = fal
         async,
     };
     
-    const defs = NODE_FIELDS.ObjectMethod;
-    validate(defs.kind, node, 'kind', kind);
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.computed, node, 'computed', computed);
-    validate(defs.generator, node, 'generator', generator);
-    validate(defs.async, node, 'async', async);
+    const defs2 = NODE_FIELDS.ObjectMethod;
+    validate(defs2.kind, node, 'kind', kind);
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.computed, node, 'computed', computed);
+    validate(defs2.generator, node, 'generator', generator);
+    validate(defs2.async, node, 'async', async);
     return node;
 }
 
@@ -12136,11 +11987,11 @@ function objectProperty(key, value, computed = false, shorthand = false) {
         shorthand,
     };
     
-    const defs = NODE_FIELDS.ObjectProperty;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.value, node, 'value', value, 1);
-    validate(defs.computed, node, 'computed', computed);
-    validate(defs.shorthand, node, 'shorthand', shorthand);
+    const defs2 = NODE_FIELDS.ObjectProperty;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.value, node, 'value', value, 1);
+    validate(defs2.computed, node, 'computed', computed);
+    validate(defs2.shorthand, node, 'shorthand', shorthand);
     return node;
 }
 
@@ -12150,8 +12001,8 @@ function restElement(argument) {
         argument,
     };
     
-    const defs = NODE_FIELDS.RestElement;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.RestElement;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -12161,8 +12012,8 @@ function returnStatement(argument = null) {
         argument,
     };
     
-    const defs = NODE_FIELDS.ReturnStatement;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.ReturnStatement;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -12172,8 +12023,8 @@ function sequenceExpression(expressions) {
         expressions,
     };
     
-    const defs = NODE_FIELDS.SequenceExpression;
-    validate(defs.expressions, node, 'expressions', expressions, 1);
+    const defs2 = NODE_FIELDS.SequenceExpression;
+    validate(defs2.expressions, node, 'expressions', expressions, 1);
     return node;
 }
 
@@ -12183,8 +12034,8 @@ function parenthesizedExpression(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.ParenthesizedExpression;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.ParenthesizedExpression;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -12195,9 +12046,9 @@ function switchCase(test = null, consequent) {
         consequent,
     };
     
-    const defs = NODE_FIELDS.SwitchCase;
-    validate(defs.test, node, 'test', test, 1);
-    validate(defs.consequent, node, 'consequent', consequent, 1);
+    const defs2 = NODE_FIELDS.SwitchCase;
+    validate(defs2.test, node, 'test', test, 1);
+    validate(defs2.consequent, node, 'consequent', consequent, 1);
     return node;
 }
 
@@ -12208,9 +12059,9 @@ function switchStatement(discriminant, cases) {
         cases,
     };
     
-    const defs = NODE_FIELDS.SwitchStatement;
-    validate(defs.discriminant, node, 'discriminant', discriminant, 1);
-    validate(defs.cases, node, 'cases', cases, 1);
+    const defs2 = NODE_FIELDS.SwitchStatement;
+    validate(defs2.discriminant, node, 'discriminant', discriminant, 1);
+    validate(defs2.cases, node, 'cases', cases, 1);
     return node;
 }
 
@@ -12226,8 +12077,8 @@ function throwStatement(argument) {
         argument,
     };
     
-    const defs = NODE_FIELDS.ThrowStatement;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.ThrowStatement;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -12239,10 +12090,10 @@ function tryStatement(block, handler = null, finalizer = null) {
         finalizer,
     };
     
-    const defs = NODE_FIELDS.TryStatement;
-    validate(defs.block, node, 'block', block, 1);
-    validate(defs.handler, node, 'handler', handler, 1);
-    validate(defs.finalizer, node, 'finalizer', finalizer, 1);
+    const defs2 = NODE_FIELDS.TryStatement;
+    validate(defs2.block, node, 'block', block, 1);
+    validate(defs2.handler, node, 'handler', handler, 1);
+    validate(defs2.finalizer, node, 'finalizer', finalizer, 1);
     return node;
 }
 
@@ -12254,10 +12105,10 @@ function unaryExpression(operator, argument, prefix2 = true) {
         prefix: prefix2,
     };
     
-    const defs = NODE_FIELDS.UnaryExpression;
-    validate(defs.operator, node, 'operator', operator);
-    validate(defs.argument, node, 'argument', argument, 1);
-    validate(defs.prefix, node, 'prefix', prefix2);
+    const defs2 = NODE_FIELDS.UnaryExpression;
+    validate(defs2.operator, node, 'operator', operator);
+    validate(defs2.argument, node, 'argument', argument, 1);
+    validate(defs2.prefix, node, 'prefix', prefix2);
     return node;
 }
 
@@ -12269,10 +12120,10 @@ function updateExpression(operator, argument, prefix2 = false) {
         prefix: prefix2,
     };
     
-    const defs = NODE_FIELDS.UpdateExpression;
-    validate(defs.operator, node, 'operator', operator);
-    validate(defs.argument, node, 'argument', argument, 1);
-    validate(defs.prefix, node, 'prefix', prefix2);
+    const defs2 = NODE_FIELDS.UpdateExpression;
+    validate(defs2.operator, node, 'operator', operator);
+    validate(defs2.argument, node, 'argument', argument, 1);
+    validate(defs2.prefix, node, 'prefix', prefix2);
     return node;
 }
 
@@ -12283,9 +12134,9 @@ function variableDeclaration(kind, declarations) {
         declarations,
     };
     
-    const defs = NODE_FIELDS.VariableDeclaration;
-    validate(defs.kind, node, 'kind', kind);
-    validate(defs.declarations, node, 'declarations', declarations, 1);
+    const defs2 = NODE_FIELDS.VariableDeclaration;
+    validate(defs2.kind, node, 'kind', kind);
+    validate(defs2.declarations, node, 'declarations', declarations, 1);
     return node;
 }
 
@@ -12296,9 +12147,9 @@ function variableDeclarator(id, init = null) {
         init,
     };
     
-    const defs = NODE_FIELDS.VariableDeclarator;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.init, node, 'init', init, 1);
+    const defs2 = NODE_FIELDS.VariableDeclarator;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.init, node, 'init', init, 1);
     return node;
 }
 
@@ -12309,9 +12160,9 @@ function whileStatement(test, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.WhileStatement;
-    validate(defs.test, node, 'test', test, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.WhileStatement;
+    validate(defs2.test, node, 'test', test, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -12322,9 +12173,9 @@ function withStatement(object, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.WithStatement;
-    validate(defs.object, node, 'object', object, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.WithStatement;
+    validate(defs2.object, node, 'object', object, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -12335,9 +12186,9 @@ function assignmentPattern(left, right) {
         right,
     };
     
-    const defs = NODE_FIELDS.AssignmentPattern;
-    validate(defs.left, node, 'left', left, 1);
-    validate(defs.right, node, 'right', right, 1);
+    const defs2 = NODE_FIELDS.AssignmentPattern;
+    validate(defs2.left, node, 'left', left, 1);
+    validate(defs2.right, node, 'right', right, 1);
     return node;
 }
 
@@ -12347,8 +12198,8 @@ function arrayPattern(elements) {
         elements,
     };
     
-    const defs = NODE_FIELDS.ArrayPattern;
-    validate(defs.elements, node, 'elements', elements, 1);
+    const defs2 = NODE_FIELDS.ArrayPattern;
+    validate(defs2.elements, node, 'elements', elements, 1);
     return node;
 }
 
@@ -12361,10 +12212,10 @@ function arrowFunctionExpression(params, body, async = false) {
         expression: body.type !== 'BlockStatement',
     };
     
-    const defs = NODE_FIELDS.ArrowFunctionExpression;
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.async, node, 'async', async);
+    const defs2 = NODE_FIELDS.ArrowFunctionExpression;
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.async, node, 'async', async);
     return node;
 }
 
@@ -12374,8 +12225,8 @@ function classBody(body) {
         body,
     };
     
-    const defs = NODE_FIELDS.ClassBody;
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.ClassBody;
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -12388,11 +12239,11 @@ function classExpression(id = null, superClass = null, body, decorators = null)
         decorators,
     };
     
-    const defs = NODE_FIELDS.ClassExpression;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.superClass, node, 'superClass', superClass, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.decorators, node, 'decorators', decorators, 1);
+    const defs2 = NODE_FIELDS.ClassExpression;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.superClass, node, 'superClass', superClass, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.decorators, node, 'decorators', decorators, 1);
     return node;
 }
 
@@ -12405,11 +12256,11 @@ function classDeclaration(id = null, superClass = null, body, decorators = null)
         decorators,
     };
     
-    const defs = NODE_FIELDS.ClassDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.superClass, node, 'superClass', superClass, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.decorators, node, 'decorators', decorators, 1);
+    const defs2 = NODE_FIELDS.ClassDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.superClass, node, 'superClass', superClass, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.decorators, node, 'decorators', decorators, 1);
     return node;
 }
 
@@ -12420,9 +12271,9 @@ function exportAllDeclaration(source, attributes = null) {
         attributes,
     };
     
-    const defs = NODE_FIELDS.ExportAllDeclaration;
-    validate(defs.source, node, 'source', source, 1);
-    validate(defs.attributes, node, 'attributes', attributes, 1);
+    const defs2 = NODE_FIELDS.ExportAllDeclaration;
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -12432,23 +12283,25 @@ function exportDefaultDeclaration(declaration) {
         declaration,
     };
     
-    const defs = NODE_FIELDS.ExportDefaultDeclaration;
-    validate(defs.declaration, node, 'declaration', declaration, 1);
+    const defs2 = NODE_FIELDS.ExportDefaultDeclaration;
+    validate(defs2.declaration, node, 'declaration', declaration, 1);
     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);
+    const defs2 = NODE_FIELDS.ExportNamedDeclaration;
+    validate(defs2.declaration, node, 'declaration', declaration, 1);
+    validate(defs2.specifiers, node, 'specifiers', specifiers, 1);
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -12459,9 +12312,9 @@ function exportSpecifier(local, exported) {
         exported,
     };
     
-    const defs = NODE_FIELDS.ExportSpecifier;
-    validate(defs.local, node, 'local', local, 1);
-    validate(defs.exported, node, 'exported', exported, 1);
+    const defs2 = NODE_FIELDS.ExportSpecifier;
+    validate(defs2.local, node, 'local', local, 1);
+    validate(defs2.exported, node, 'exported', exported, 1);
     return node;
 }
 
@@ -12474,24 +12327,26 @@ function forOfStatement(left, right, body, _await = false) {
         await: _await,
     };
     
-    const defs = NODE_FIELDS.ForOfStatement;
-    validate(defs.left, node, 'left', left, 1);
-    validate(defs.right, node, 'right', right, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.await, node, 'await', _await);
+    const defs2 = NODE_FIELDS.ForOfStatement;
+    validate(defs2.left, node, 'left', left, 1);
+    validate(defs2.right, node, 'right', right, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.await, node, 'await', _await);
     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);
+    const defs2 = NODE_FIELDS.ImportDeclaration;
+    validate(defs2.specifiers, node, 'specifiers', specifiers, 1);
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -12501,8 +12356,8 @@ function importDefaultSpecifier(local) {
         local,
     };
     
-    const defs = NODE_FIELDS.ImportDefaultSpecifier;
-    validate(defs.local, node, 'local', local, 1);
+    const defs2 = NODE_FIELDS.ImportDefaultSpecifier;
+    validate(defs2.local, node, 'local', local, 1);
     return node;
 }
 
@@ -12512,8 +12367,8 @@ function importNamespaceSpecifier(local) {
         local,
     };
     
-    const defs = NODE_FIELDS.ImportNamespaceSpecifier;
-    validate(defs.local, node, 'local', local, 1);
+    const defs2 = NODE_FIELDS.ImportNamespaceSpecifier;
+    validate(defs2.local, node, 'local', local, 1);
     return node;
 }
 
@@ -12524,9 +12379,9 @@ function importSpecifier(local, imported) {
         imported,
     };
     
-    const defs = NODE_FIELDS.ImportSpecifier;
-    validate(defs.local, node, 'local', local, 1);
-    validate(defs.imported, node, 'imported', imported, 1);
+    const defs2 = NODE_FIELDS.ImportSpecifier;
+    validate(defs2.local, node, 'local', local, 1);
+    validate(defs2.imported, node, 'imported', imported, 1);
     return node;
 }
 
@@ -12537,9 +12392,9 @@ function importExpression(source, options = null) {
         options,
     };
     
-    const defs = NODE_FIELDS.ImportExpression;
-    validate(defs.source, node, 'source', source, 1);
-    validate(defs.options, node, 'options', options, 1);
+    const defs2 = NODE_FIELDS.ImportExpression;
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.options, node, 'options', options, 1);
     return node;
 }
 
@@ -12550,9 +12405,9 @@ function metaProperty(meta, property) {
         property,
     };
     
-    const defs = NODE_FIELDS.MetaProperty;
-    validate(defs.meta, node, 'meta', meta, 1);
-    validate(defs.property, node, 'property', property, 1);
+    const defs2 = NODE_FIELDS.MetaProperty;
+    validate(defs2.meta, node, 'meta', meta, 1);
+    validate(defs2.property, node, 'property', property, 1);
     return node;
 }
 
@@ -12569,15 +12424,15 @@ function classMethod(kind = 'method', key, params, body, computed = false, _stat
         async,
     };
     
-    const defs = NODE_FIELDS.ClassMethod;
-    validate(defs.kind, node, 'kind', kind);
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.computed, node, 'computed', computed);
-    validate(defs.static, node, 'static', _static);
-    validate(defs.generator, node, 'generator', generator);
-    validate(defs.async, node, 'async', async);
+    const defs2 = NODE_FIELDS.ClassMethod;
+    validate(defs2.kind, node, 'kind', kind);
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.computed, node, 'computed', computed);
+    validate(defs2.static, node, 'static', _static);
+    validate(defs2.generator, node, 'generator', generator);
+    validate(defs2.async, node, 'async', async);
     return node;
 }
 
@@ -12587,8 +12442,8 @@ function objectPattern(properties) {
         properties,
     };
     
-    const defs = NODE_FIELDS.ObjectPattern;
-    validate(defs.properties, node, 'properties', properties, 1);
+    const defs2 = NODE_FIELDS.ObjectPattern;
+    validate(defs2.properties, node, 'properties', properties, 1);
     return node;
 }
 
@@ -12598,8 +12453,8 @@ function spreadElement(argument) {
         argument,
     };
     
-    const defs = NODE_FIELDS.SpreadElement;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.SpreadElement;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -12616,9 +12471,9 @@ function taggedTemplateExpression(tag, quasi) {
         quasi,
     };
     
-    const defs = NODE_FIELDS.TaggedTemplateExpression;
-    validate(defs.tag, node, 'tag', tag, 1);
-    validate(defs.quasi, node, 'quasi', quasi, 1);
+    const defs2 = NODE_FIELDS.TaggedTemplateExpression;
+    validate(defs2.tag, node, 'tag', tag, 1);
+    validate(defs2.quasi, node, 'quasi', quasi, 1);
     return node;
 }
 
@@ -12629,9 +12484,9 @@ function templateElement(value, tail = false) {
         tail,
     };
     
-    const defs = NODE_FIELDS.TemplateElement;
-    validate(defs.value, node, 'value', value);
-    validate(defs.tail, node, 'tail', tail);
+    const defs2 = NODE_FIELDS.TemplateElement;
+    validate(defs2.value, node, 'value', value);
+    validate(defs2.tail, node, 'tail', tail);
     return node;
 }
 
@@ -12642,9 +12497,9 @@ function templateLiteral(quasis, expressions) {
         expressions,
     };
     
-    const defs = NODE_FIELDS.TemplateLiteral;
-    validate(defs.quasis, node, 'quasis', quasis, 1);
-    validate(defs.expressions, node, 'expressions', expressions, 1);
+    const defs2 = NODE_FIELDS.TemplateLiteral;
+    validate(defs2.quasis, node, 'quasis', quasis, 1);
+    validate(defs2.expressions, node, 'expressions', expressions, 1);
     return node;
 }
 
@@ -12655,9 +12510,9 @@ function yieldExpression(argument = null, delegate = false) {
         delegate,
     };
     
-    const defs = NODE_FIELDS.YieldExpression;
-    validate(defs.argument, node, 'argument', argument, 1);
-    validate(defs.delegate, node, 'delegate', delegate);
+    const defs2 = NODE_FIELDS.YieldExpression;
+    validate(defs2.argument, node, 'argument', argument, 1);
+    validate(defs2.delegate, node, 'delegate', delegate);
     return node;
 }
 
@@ -12667,8 +12522,8 @@ function awaitExpression(argument) {
         argument,
     };
     
-    const defs = NODE_FIELDS.AwaitExpression;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.AwaitExpression;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -12684,8 +12539,8 @@ function bigIntLiteral(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.BigIntLiteral;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.BigIntLiteral;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -12695,8 +12550,8 @@ function exportNamespaceSpecifier(exported) {
         exported,
     };
     
-    const defs = NODE_FIELDS.ExportNamespaceSpecifier;
-    validate(defs.exported, node, 'exported', exported, 1);
+    const defs2 = NODE_FIELDS.ExportNamespaceSpecifier;
+    validate(defs2.exported, node, 'exported', exported, 1);
     return node;
 }
 
@@ -12709,11 +12564,11 @@ function optionalMemberExpression(object, property, computed = false, optional)
         optional,
     };
     
-    const defs = NODE_FIELDS.OptionalMemberExpression;
-    validate(defs.object, node, 'object', object, 1);
-    validate(defs.property, node, 'property', property, 1);
-    validate(defs.computed, node, 'computed', computed);
-    validate(defs.optional, node, 'optional', optional);
+    const defs2 = NODE_FIELDS.OptionalMemberExpression;
+    validate(defs2.object, node, 'object', object, 1);
+    validate(defs2.property, node, 'property', property, 1);
+    validate(defs2.computed, node, 'computed', computed);
+    validate(defs2.optional, node, 'optional', optional);
     return node;
 }
 
@@ -12725,10 +12580,10 @@ function optionalCallExpression(callee, _arguments, optional) {
         optional,
     };
     
-    const defs = NODE_FIELDS.OptionalCallExpression;
-    validate(defs.callee, node, 'callee', callee, 1);
-    validate(defs.arguments, node, 'arguments', _arguments, 1);
-    validate(defs.optional, node, 'optional', optional);
+    const defs2 = NODE_FIELDS.OptionalCallExpression;
+    validate(defs2.callee, node, 'callee', callee, 1);
+    validate(defs2.arguments, node, 'arguments', _arguments, 1);
+    validate(defs2.optional, node, 'optional', optional);
     return node;
 }
 
@@ -12743,34 +12598,13 @@ function classProperty(key, value = null, typeAnnotation2 = null, decorators = n
         static: _static,
     };
     
-    const defs = NODE_FIELDS.ClassProperty;
-    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 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);
+    const defs2 = NODE_FIELDS.ClassProperty;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.value, node, 'value', value, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    validate(defs2.decorators, node, 'decorators', decorators, 1);
+    validate(defs2.computed, node, 'computed', computed);
+    validate(defs2.static, node, 'static', _static);
     return node;
 }
 
@@ -12783,11 +12617,11 @@ function classPrivateProperty(key, value = null, decorators = null, _static = fa
         static: _static,
     };
     
-    const defs = NODE_FIELDS.ClassPrivateProperty;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.value, node, 'value', value, 1);
-    validate(defs.decorators, node, 'decorators', decorators, 1);
-    validate(defs.static, node, 'static', _static);
+    const defs2 = NODE_FIELDS.ClassPrivateProperty;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.value, node, 'value', value, 1);
+    validate(defs2.decorators, node, 'decorators', decorators, 1);
+    validate(defs2.static, node, 'static', _static);
     return node;
 }
 
@@ -12804,12 +12638,12 @@ function classPrivateMethod(kind = 'method', key, params, body, _static = false)
         generator: false,
     };
     
-    const defs = NODE_FIELDS.ClassPrivateMethod;
-    validate(defs.kind, node, 'kind', kind);
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.static, node, 'static', _static);
+    const defs2 = NODE_FIELDS.ClassPrivateMethod;
+    validate(defs2.kind, node, 'kind', kind);
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.static, node, 'static', _static);
     return node;
 }
 
@@ -12819,8 +12653,8 @@ function privateName(id) {
         id,
     };
     
-    const defs = NODE_FIELDS.PrivateName;
-    validate(defs.id, node, 'id', id, 1);
+    const defs2 = NODE_FIELDS.PrivateName;
+    validate(defs2.id, node, 'id', id, 1);
     return node;
 }
 
@@ -12830,8 +12664,8 @@ function staticBlock(body) {
         body,
     };
     
-    const defs = NODE_FIELDS.StaticBlock;
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.StaticBlock;
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -12842,9 +12676,9 @@ function importAttribute(key, value) {
         value,
     };
     
-    const defs = NODE_FIELDS.ImportAttribute;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.value, node, 'value', value, 1);
+    const defs2 = NODE_FIELDS.ImportAttribute;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.value, node, 'value', value, 1);
     return node;
 }
 
@@ -12860,8 +12694,8 @@ function arrayTypeAnnotation(elementType) {
         elementType,
     };
     
-    const defs = NODE_FIELDS.ArrayTypeAnnotation;
-    validate(defs.elementType, node, 'elementType', elementType, 1);
+    const defs2 = NODE_FIELDS.ArrayTypeAnnotation;
+    validate(defs2.elementType, node, 'elementType', elementType, 1);
     return node;
 }
 
@@ -12877,8 +12711,8 @@ function booleanLiteralTypeAnnotation(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.BooleanLiteralTypeAnnotation;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.BooleanLiteralTypeAnnotation;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -12895,9 +12729,9 @@ function classImplements(id, typeParameters = null) {
         typeParameters,
     };
     
-    const defs = NODE_FIELDS.ClassImplements;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
+    const defs2 = NODE_FIELDS.ClassImplements;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
     return node;
 }
 
@@ -12910,11 +12744,11 @@ function declareClass(id, typeParameters = null, _extends = null, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.DeclareClass;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.extends, node, 'extends', _extends, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.DeclareClass;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.extends, node, 'extends', _extends, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -12924,8 +12758,8 @@ function declareFunction(id) {
         id,
     };
     
-    const defs = NODE_FIELDS.DeclareFunction;
-    validate(defs.id, node, 'id', id, 1);
+    const defs2 = NODE_FIELDS.DeclareFunction;
+    validate(defs2.id, node, 'id', id, 1);
     return node;
 }
 
@@ -12938,11 +12772,11 @@ function declareInterface(id, typeParameters = null, _extends = null, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.DeclareInterface;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.extends, node, 'extends', _extends, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.DeclareInterface;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.extends, node, 'extends', _extends, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -12954,10 +12788,10 @@ function declareModule(id, body, kind = null) {
         kind,
     };
     
-    const defs = NODE_FIELDS.DeclareModule;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.kind, node, 'kind', kind);
+    const defs2 = NODE_FIELDS.DeclareModule;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.kind, node, 'kind', kind);
     return node;
 }
 
@@ -12967,8 +12801,8 @@ function declareModuleExports(typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.DeclareModuleExports;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.DeclareModuleExports;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -12980,10 +12814,10 @@ function declareTypeAlias(id, typeParameters = null, right) {
         right,
     };
     
-    const defs = NODE_FIELDS.DeclareTypeAlias;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.right, node, 'right', right, 1);
+    const defs2 = NODE_FIELDS.DeclareTypeAlias;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.right, node, 'right', right, 1);
     return node;
 }
 
@@ -12995,10 +12829,10 @@ function declareOpaqueType(id, typeParameters = null, supertype = null) {
         supertype,
     };
     
-    const defs = NODE_FIELDS.DeclareOpaqueType;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.supertype, node, 'supertype', supertype, 1);
+    const defs2 = NODE_FIELDS.DeclareOpaqueType;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.supertype, node, 'supertype', supertype, 1);
     return node;
 }
 
@@ -13008,8 +12842,8 @@ function declareVariable(id) {
         id,
     };
     
-    const defs = NODE_FIELDS.DeclareVariable;
-    validate(defs.id, node, 'id', id, 1);
+    const defs2 = NODE_FIELDS.DeclareVariable;
+    validate(defs2.id, node, 'id', id, 1);
     return node;
 }
 
@@ -13022,11 +12856,11 @@ function declareExportDeclaration(declaration = null, specifiers = null, source
         attributes,
     };
     
-    const defs = NODE_FIELDS.DeclareExportDeclaration;
-    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);
+    const defs2 = NODE_FIELDS.DeclareExportDeclaration;
+    validate(defs2.declaration, node, 'declaration', declaration, 1);
+    validate(defs2.specifiers, node, 'specifiers', specifiers, 1);
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -13037,9 +12871,9 @@ function declareExportAllDeclaration(source, attributes = null) {
         attributes,
     };
     
-    const defs = NODE_FIELDS.DeclareExportAllDeclaration;
-    validate(defs.source, node, 'source', source, 1);
-    validate(defs.attributes, node, 'attributes', attributes, 1);
+    const defs2 = NODE_FIELDS.DeclareExportAllDeclaration;
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.attributes, node, 'attributes', attributes, 1);
     return node;
 }
 
@@ -13049,8 +12883,8 @@ function declaredPredicate(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.DeclaredPredicate;
-    validate(defs.value, node, 'value', value, 1);
+    const defs2 = NODE_FIELDS.DeclaredPredicate;
+    validate(defs2.value, node, 'value', value, 1);
     return node;
 }
 
@@ -13069,11 +12903,11 @@ function functionTypeAnnotation(typeParameters = null, params, rest = null, retu
         returnType,
     };
     
-    const defs = NODE_FIELDS.FunctionTypeAnnotation;
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.rest, node, 'rest', rest, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.FunctionTypeAnnotation;
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.rest, node, 'rest', rest, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -13084,9 +12918,9 @@ function functionTypeParam(name = null, typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.FunctionTypeParam;
-    validate(defs.name, node, 'name', name, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.FunctionTypeParam;
+    validate(defs2.name, node, 'name', name, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -13097,9 +12931,9 @@ function genericTypeAnnotation(id, typeParameters = null) {
         typeParameters,
     };
     
-    const defs = NODE_FIELDS.GenericTypeAnnotation;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
+    const defs2 = NODE_FIELDS.GenericTypeAnnotation;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
     return node;
 }
 
@@ -13116,9 +12950,9 @@ function interfaceExtends(id, typeParameters = null) {
         typeParameters,
     };
     
-    const defs = NODE_FIELDS.InterfaceExtends;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
+    const defs2 = NODE_FIELDS.InterfaceExtends;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
     return node;
 }
 
@@ -13131,11 +12965,11 @@ function interfaceDeclaration(id, typeParameters = null, _extends = null, body)
         body,
     };
     
-    const defs = NODE_FIELDS.InterfaceDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.extends, node, 'extends', _extends, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.InterfaceDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.extends, node, 'extends', _extends, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -13146,9 +12980,9 @@ function interfaceTypeAnnotation(_extends = null, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.InterfaceTypeAnnotation;
-    validate(defs.extends, node, 'extends', _extends, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.InterfaceTypeAnnotation;
+    validate(defs2.extends, node, 'extends', _extends, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -13158,8 +12992,8 @@ function intersectionTypeAnnotation(types2) {
         types: types2,
     };
     
-    const defs = NODE_FIELDS.IntersectionTypeAnnotation;
-    validate(defs.types, node, 'types', types2, 1);
+    const defs2 = NODE_FIELDS.IntersectionTypeAnnotation;
+    validate(defs2.types, node, 'types', types2, 1);
     return node;
 }
 
@@ -13181,8 +13015,8 @@ function nullableTypeAnnotation(typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.NullableTypeAnnotation;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.NullableTypeAnnotation;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -13192,8 +13026,8 @@ function numberLiteralTypeAnnotation(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.NumberLiteralTypeAnnotation;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.NumberLiteralTypeAnnotation;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -13213,12 +13047,12 @@ function objectTypeAnnotation(properties, indexers = [], callProperties = [], in
         exact,
     };
     
-    const defs = NODE_FIELDS.ObjectTypeAnnotation;
-    validate(defs.properties, node, 'properties', properties, 1);
-    validate(defs.indexers, node, 'indexers', indexers, 1);
-    validate(defs.callProperties, node, 'callProperties', callProperties, 1);
-    validate(defs.internalSlots, node, 'internalSlots', internalSlots, 1);
-    validate(defs.exact, node, 'exact', exact);
+    const defs2 = NODE_FIELDS.ObjectTypeAnnotation;
+    validate(defs2.properties, node, 'properties', properties, 1);
+    validate(defs2.indexers, node, 'indexers', indexers, 1);
+    validate(defs2.callProperties, node, 'callProperties', callProperties, 1);
+    validate(defs2.internalSlots, node, 'internalSlots', internalSlots, 1);
+    validate(defs2.exact, node, 'exact', exact);
     return node;
 }
 
@@ -13232,12 +13066,12 @@ function objectTypeInternalSlot(id, value, optional, _static, method) {
         method,
     };
     
-    const defs = NODE_FIELDS.ObjectTypeInternalSlot;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.value, node, 'value', value, 1);
-    validate(defs.optional, node, 'optional', optional);
-    validate(defs.static, node, 'static', _static);
-    validate(defs.method, node, 'method', method);
+    const defs2 = NODE_FIELDS.ObjectTypeInternalSlot;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.value, node, 'value', value, 1);
+    validate(defs2.optional, node, 'optional', optional);
+    validate(defs2.static, node, 'static', _static);
+    validate(defs2.method, node, 'method', method);
     return node;
 }
 
@@ -13248,8 +13082,8 @@ function objectTypeCallProperty(value) {
         static: false,
     };
     
-    const defs = NODE_FIELDS.ObjectTypeCallProperty;
-    validate(defs.value, node, 'value', value, 1);
+    const defs2 = NODE_FIELDS.ObjectTypeCallProperty;
+    validate(defs2.value, node, 'value', value, 1);
     return node;
 }
 
@@ -13263,11 +13097,11 @@ function objectTypeIndexer(id = null, key, value, variance2 = null) {
         static: false,
     };
     
-    const defs = NODE_FIELDS.ObjectTypeIndexer;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.value, node, 'value', value, 1);
-    validate(defs.variance, node, 'variance', variance2, 1);
+    const defs2 = NODE_FIELDS.ObjectTypeIndexer;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.value, node, 'value', value, 1);
+    validate(defs2.variance, node, 'variance', variance2, 1);
     return node;
 }
 
@@ -13284,10 +13118,10 @@ function objectTypeProperty(key, value, variance2 = null) {
         static: false,
     };
     
-    const defs = NODE_FIELDS.ObjectTypeProperty;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.value, node, 'value', value, 1);
-    validate(defs.variance, node, 'variance', variance2, 1);
+    const defs2 = NODE_FIELDS.ObjectTypeProperty;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.value, node, 'value', value, 1);
+    validate(defs2.variance, node, 'variance', variance2, 1);
     return node;
 }
 
@@ -13297,8 +13131,8 @@ function objectTypeSpreadProperty(argument) {
         argument,
     };
     
-    const defs = NODE_FIELDS.ObjectTypeSpreadProperty;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.ObjectTypeSpreadProperty;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -13311,11 +13145,11 @@ function opaqueType(id, typeParameters = null, supertype = null, impltype) {
         impltype,
     };
     
-    const defs = NODE_FIELDS.OpaqueType;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.supertype, node, 'supertype', supertype, 1);
-    validate(defs.impltype, node, 'impltype', impltype, 1);
+    const defs2 = NODE_FIELDS.OpaqueType;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.supertype, node, 'supertype', supertype, 1);
+    validate(defs2.impltype, node, 'impltype', impltype, 1);
     return node;
 }
 
@@ -13326,9 +13160,9 @@ function qualifiedTypeIdentifier(id, qualification) {
         qualification,
     };
     
-    const defs = NODE_FIELDS.QualifiedTypeIdentifier;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.qualification, node, 'qualification', qualification, 1);
+    const defs2 = NODE_FIELDS.QualifiedTypeIdentifier;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.qualification, node, 'qualification', qualification, 1);
     return node;
 }
 
@@ -13338,8 +13172,8 @@ function stringLiteralTypeAnnotation(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.StringLiteralTypeAnnotation;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.StringLiteralTypeAnnotation;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -13367,8 +13201,8 @@ function tupleTypeAnnotation(types2) {
         types: types2,
     };
     
-    const defs = NODE_FIELDS.TupleTypeAnnotation;
-    validate(defs.types, node, 'types', types2, 1);
+    const defs2 = NODE_FIELDS.TupleTypeAnnotation;
+    validate(defs2.types, node, 'types', types2, 1);
     return node;
 }
 
@@ -13378,8 +13212,8 @@ function typeofTypeAnnotation(argument) {
         argument,
     };
     
-    const defs = NODE_FIELDS.TypeofTypeAnnotation;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.TypeofTypeAnnotation;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -13391,10 +13225,10 @@ function typeAlias(id, typeParameters = null, right) {
         right,
     };
     
-    const defs = NODE_FIELDS.TypeAlias;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.right, node, 'right', right, 1);
+    const defs2 = NODE_FIELDS.TypeAlias;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.right, node, 'right', right, 1);
     return node;
 }
 
@@ -13404,8 +13238,8 @@ function typeAnnotation(typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TypeAnnotation;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TypeAnnotation;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -13416,9 +13250,9 @@ function typeCastExpression(expression2, typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TypeCastExpression;
-    validate(defs.expression, node, 'expression', expression2, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TypeCastExpression;
+    validate(defs2.expression, node, 'expression', expression2, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -13431,11 +13265,11 @@ function typeParameter(name, bound = null, _default = null, variance2 = null) {
         variance: variance2,
     };
     
-    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);
+    const defs2 = NODE_FIELDS.TypeParameter;
+    validate(defs2.name, node, 'name', name);
+    validate(defs2.bound, node, 'bound', bound, 1);
+    validate(defs2.default, node, 'default', _default, 1);
+    validate(defs2.variance, node, 'variance', variance2, 1);
     return node;
 }
 
@@ -13445,8 +13279,8 @@ function typeParameterDeclaration(params) {
         params,
     };
     
-    const defs = NODE_FIELDS.TypeParameterDeclaration;
-    validate(defs.params, node, 'params', params, 1);
+    const defs2 = NODE_FIELDS.TypeParameterDeclaration;
+    validate(defs2.params, node, 'params', params, 1);
     return node;
 }
 
@@ -13456,8 +13290,8 @@ function typeParameterInstantiation(params) {
         params,
     };
     
-    const defs = NODE_FIELDS.TypeParameterInstantiation;
-    validate(defs.params, node, 'params', params, 1);
+    const defs2 = NODE_FIELDS.TypeParameterInstantiation;
+    validate(defs2.params, node, 'params', params, 1);
     return node;
 }
 
@@ -13467,8 +13301,8 @@ function unionTypeAnnotation(types2) {
         types: types2,
     };
     
-    const defs = NODE_FIELDS.UnionTypeAnnotation;
-    validate(defs.types, node, 'types', types2, 1);
+    const defs2 = NODE_FIELDS.UnionTypeAnnotation;
+    validate(defs2.types, node, 'types', types2, 1);
     return node;
 }
 
@@ -13478,8 +13312,8 @@ function variance(kind) {
         kind,
     };
     
-    const defs = NODE_FIELDS.Variance;
-    validate(defs.kind, node, 'kind', kind);
+    const defs2 = NODE_FIELDS.Variance;
+    validate(defs2.kind, node, 'kind', kind);
     return node;
 }
 
@@ -13496,9 +13330,9 @@ function enumDeclaration(id, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.EnumDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.EnumDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -13510,8 +13344,8 @@ function enumBooleanBody(members) {
         hasUnknownMembers: false,
     };
     
-    const defs = NODE_FIELDS.EnumBooleanBody;
-    validate(defs.members, node, 'members', members, 1);
+    const defs2 = NODE_FIELDS.EnumBooleanBody;
+    validate(defs2.members, node, 'members', members, 1);
     return node;
 }
 
@@ -13523,8 +13357,8 @@ function enumNumberBody(members) {
         hasUnknownMembers: false,
     };
     
-    const defs = NODE_FIELDS.EnumNumberBody;
-    validate(defs.members, node, 'members', members, 1);
+    const defs2 = NODE_FIELDS.EnumNumberBody;
+    validate(defs2.members, node, 'members', members, 1);
     return node;
 }
 
@@ -13536,8 +13370,8 @@ function enumStringBody(members) {
         hasUnknownMembers: false,
     };
     
-    const defs = NODE_FIELDS.EnumStringBody;
-    validate(defs.members, node, 'members', members, 1);
+    const defs2 = NODE_FIELDS.EnumStringBody;
+    validate(defs2.members, node, 'members', members, 1);
     return node;
 }
 
@@ -13548,8 +13382,8 @@ function enumSymbolBody(members) {
         hasUnknownMembers: false,
     };
     
-    const defs = NODE_FIELDS.EnumSymbolBody;
-    validate(defs.members, node, 'members', members, 1);
+    const defs2 = NODE_FIELDS.EnumSymbolBody;
+    validate(defs2.members, node, 'members', members, 1);
     return node;
 }
 
@@ -13560,9 +13394,9 @@ function enumBooleanMember(id, init) {
         init,
     };
     
-    const defs = NODE_FIELDS.EnumBooleanMember;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.init, node, 'init', init, 1);
+    const defs2 = NODE_FIELDS.EnumBooleanMember;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.init, node, 'init', init, 1);
     return node;
 }
 
@@ -13573,9 +13407,9 @@ function enumNumberMember(id, init) {
         init,
     };
     
-    const defs = NODE_FIELDS.EnumNumberMember;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.init, node, 'init', init, 1);
+    const defs2 = NODE_FIELDS.EnumNumberMember;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.init, node, 'init', init, 1);
     return node;
 }
 
@@ -13586,9 +13420,9 @@ function enumStringMember(id, init) {
         init,
     };
     
-    const defs = NODE_FIELDS.EnumStringMember;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.init, node, 'init', init, 1);
+    const defs2 = NODE_FIELDS.EnumStringMember;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.init, node, 'init', init, 1);
     return node;
 }
 
@@ -13598,8 +13432,8 @@ function enumDefaultedMember(id) {
         id,
     };
     
-    const defs = NODE_FIELDS.EnumDefaultedMember;
-    validate(defs.id, node, 'id', id, 1);
+    const defs2 = NODE_FIELDS.EnumDefaultedMember;
+    validate(defs2.id, node, 'id', id, 1);
     return node;
 }
 
@@ -13610,9 +13444,9 @@ function indexedAccessType(objectType, indexType) {
         indexType,
     };
     
-    const defs = NODE_FIELDS.IndexedAccessType;
-    validate(defs.objectType, node, 'objectType', objectType, 1);
-    validate(defs.indexType, node, 'indexType', indexType, 1);
+    const defs2 = NODE_FIELDS.IndexedAccessType;
+    validate(defs2.objectType, node, 'objectType', objectType, 1);
+    validate(defs2.indexType, node, 'indexType', indexType, 1);
     return node;
 }
 
@@ -13624,9 +13458,9 @@ function optionalIndexedAccessType(objectType, indexType) {
         optional: false,
     };
     
-    const defs = NODE_FIELDS.OptionalIndexedAccessType;
-    validate(defs.objectType, node, 'objectType', objectType, 1);
-    validate(defs.indexType, node, 'indexType', indexType, 1);
+    const defs2 = NODE_FIELDS.OptionalIndexedAccessType;
+    validate(defs2.objectType, node, 'objectType', objectType, 1);
+    validate(defs2.indexType, node, 'indexType', indexType, 1);
     return node;
 }
 
@@ -13637,9 +13471,9 @@ function jsxAttribute(name, value = null) {
         value,
     };
     
-    const defs = NODE_FIELDS.JSXAttribute;
-    validate(defs.name, node, 'name', name, 1);
-    validate(defs.value, node, 'value', value, 1);
+    const defs2 = NODE_FIELDS.JSXAttribute;
+    validate(defs2.name, node, 'name', name, 1);
+    validate(defs2.value, node, 'value', value, 1);
     return node;
 }
 
@@ -13649,8 +13483,8 @@ function jsxClosingElement(name) {
         name,
     };
     
-    const defs = NODE_FIELDS.JSXClosingElement;
-    validate(defs.name, node, 'name', name, 1);
+    const defs2 = NODE_FIELDS.JSXClosingElement;
+    validate(defs2.name, node, 'name', name, 1);
     return node;
 }
 
@@ -13662,10 +13496,10 @@ function jsxElement(openingElement, closingElement = null, children) {
         children,
     };
     
-    const defs = NODE_FIELDS.JSXElement;
-    validate(defs.openingElement, node, 'openingElement', openingElement, 1);
-    validate(defs.closingElement, node, 'closingElement', closingElement, 1);
-    validate(defs.children, node, 'children', children, 1);
+    const defs2 = NODE_FIELDS.JSXElement;
+    validate(defs2.openingElement, node, 'openingElement', openingElement, 1);
+    validate(defs2.closingElement, node, 'closingElement', closingElement, 1);
+    validate(defs2.children, node, 'children', children, 1);
     return node;
 }
 
@@ -13681,8 +13515,8 @@ function jsxExpressionContainer(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.JSXExpressionContainer;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.JSXExpressionContainer;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -13692,8 +13526,8 @@ function jsxSpreadChild(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.JSXSpreadChild;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.JSXSpreadChild;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -13703,8 +13537,8 @@ function jsxIdentifier(name) {
         name,
     };
     
-    const defs = NODE_FIELDS.JSXIdentifier;
-    validate(defs.name, node, 'name', name);
+    const defs2 = NODE_FIELDS.JSXIdentifier;
+    validate(defs2.name, node, 'name', name);
     return node;
 }
 
@@ -13715,9 +13549,9 @@ function jsxMemberExpression(object, property) {
         property,
     };
     
-    const defs = NODE_FIELDS.JSXMemberExpression;
-    validate(defs.object, node, 'object', object, 1);
-    validate(defs.property, node, 'property', property, 1);
+    const defs2 = NODE_FIELDS.JSXMemberExpression;
+    validate(defs2.object, node, 'object', object, 1);
+    validate(defs2.property, node, 'property', property, 1);
     return node;
 }
 
@@ -13728,9 +13562,9 @@ function jsxNamespacedName(namespace, name) {
         name,
     };
     
-    const defs = NODE_FIELDS.JSXNamespacedName;
-    validate(defs.namespace, node, 'namespace', namespace, 1);
-    validate(defs.name, node, 'name', name, 1);
+    const defs2 = NODE_FIELDS.JSXNamespacedName;
+    validate(defs2.namespace, node, 'namespace', namespace, 1);
+    validate(defs2.name, node, 'name', name, 1);
     return node;
 }
 
@@ -13742,10 +13576,10 @@ function jsxOpeningElement(name, attributes, selfClosing = false) {
         selfClosing,
     };
     
-    const defs = NODE_FIELDS.JSXOpeningElement;
-    validate(defs.name, node, 'name', name, 1);
-    validate(defs.attributes, node, 'attributes', attributes, 1);
-    validate(defs.selfClosing, node, 'selfClosing', selfClosing);
+    const defs2 = NODE_FIELDS.JSXOpeningElement;
+    validate(defs2.name, node, 'name', name, 1);
+    validate(defs2.attributes, node, 'attributes', attributes, 1);
+    validate(defs2.selfClosing, node, 'selfClosing', selfClosing);
     return node;
 }
 
@@ -13755,8 +13589,8 @@ function jsxSpreadAttribute(argument) {
         argument,
     };
     
-    const defs = NODE_FIELDS.JSXSpreadAttribute;
-    validate(defs.argument, node, 'argument', argument, 1);
+    const defs2 = NODE_FIELDS.JSXSpreadAttribute;
+    validate(defs2.argument, node, 'argument', argument, 1);
     return node;
 }
 
@@ -13766,8 +13600,8 @@ function jsxText(value) {
         value,
     };
     
-    const defs = NODE_FIELDS.JSXText;
-    validate(defs.value, node, 'value', value);
+    const defs2 = NODE_FIELDS.JSXText;
+    validate(defs2.value, node, 'value', value);
     return node;
 }
 
@@ -13779,10 +13613,10 @@ function jsxFragment(openingFragment, closingFragment, children) {
         children,
     };
     
-    const defs = NODE_FIELDS.JSXFragment;
-    validate(defs.openingFragment, node, 'openingFragment', openingFragment, 1);
-    validate(defs.closingFragment, node, 'closingFragment', closingFragment, 1);
-    validate(defs.children, node, 'children', children, 1);
+    const defs2 = NODE_FIELDS.JSXFragment;
+    validate(defs2.openingFragment, node, 'openingFragment', openingFragment, 1);
+    validate(defs2.closingFragment, node, 'closingFragment', closingFragment, 1);
+    validate(defs2.children, node, 'children', children, 1);
     return node;
 }
 
@@ -13805,9 +13639,9 @@ function placeholder(expectedNode, name) {
         name,
     };
     
-    const defs = NODE_FIELDS.Placeholder;
-    validate(defs.expectedNode, node, 'expectedNode', expectedNode);
-    validate(defs.name, node, 'name', name, 1);
+    const defs2 = NODE_FIELDS.Placeholder;
+    validate(defs2.expectedNode, node, 'expectedNode', expectedNode);
+    validate(defs2.name, node, 'name', name, 1);
     return node;
 }
 
@@ -13817,8 +13651,8 @@ function v8IntrinsicIdentifier(name) {
         name,
     };
     
-    const defs = NODE_FIELDS.V8IntrinsicIdentifier;
-    validate(defs.name, node, 'name', name);
+    const defs2 = NODE_FIELDS.V8IntrinsicIdentifier;
+    validate(defs2.name, node, 'name', name);
     return node;
 }
 
@@ -13835,9 +13669,30 @@ function bindExpression(object, callee) {
         callee,
     };
     
-    const defs = NODE_FIELDS.BindExpression;
-    validate(defs.object, node, 'object', object, 1);
-    validate(defs.callee, node, 'callee', callee, 1);
+    const defs2 = NODE_FIELDS.BindExpression;
+    validate(defs2.object, node, 'object', object, 1);
+    validate(defs2.callee, node, 'callee', callee, 1);
+    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 defs2 = NODE_FIELDS.ClassAccessorProperty;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.value, node, 'value', value, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    validate(defs2.decorators, node, 'decorators', decorators, 1);
+    validate(defs2.computed, node, 'computed', computed);
+    validate(defs2.static, node, 'static', _static);
     return node;
 }
 
@@ -13847,8 +13702,8 @@ function decorator(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.Decorator;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.Decorator;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -13859,9 +13714,9 @@ function doExpression(body, async = false) {
         async,
     };
     
-    const defs = NODE_FIELDS.DoExpression;
-    validate(defs.body, node, 'body', body, 1);
-    validate(defs.async, node, 'async', async);
+    const defs2 = NODE_FIELDS.DoExpression;
+    validate(defs2.body, node, 'body', body, 1);
+    validate(defs2.async, node, 'async', async);
     return node;
 }
 
@@ -13871,8 +13726,8 @@ function exportDefaultSpecifier(exported) {
         exported,
     };
     
-    const defs = NODE_FIELDS.ExportDefaultSpecifier;
-    validate(defs.exported, node, 'exported', exported, 1);
+    const defs2 = NODE_FIELDS.ExportDefaultSpecifier;
+    validate(defs2.exported, node, 'exported', exported, 1);
     return node;
 }
 
@@ -13882,8 +13737,8 @@ function moduleExpression(body) {
         body,
     };
     
-    const defs = NODE_FIELDS.ModuleExpression;
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.ModuleExpression;
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -13893,34 +13748,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',
@@ -13933,8 +13760,8 @@ function tsParameterProperty(parameter) {
         parameter,
     };
     
-    const defs = NODE_FIELDS.TSParameterProperty;
-    validate(defs.parameter, node, 'parameter', parameter, 1);
+    const defs2 = NODE_FIELDS.TSParameterProperty;
+    validate(defs2.parameter, node, 'parameter', parameter, 1);
     return node;
 }
 
@@ -13949,11 +13776,11 @@ function tsDeclareFunction(id = null, typeParameters = null, params, returnType
         generator: false,
     };
     
-    const defs = NODE_FIELDS.TSDeclareFunction;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.TSDeclareFunction;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -13972,12 +13799,12 @@ function tsDeclareMethod(decorators = null, key, typeParameters = null, params,
         static: false,
     };
     
-    const defs = NODE_FIELDS.TSDeclareMethod;
-    validate(defs.decorators, node, 'decorators', decorators, 1);
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.TSDeclareMethod;
+    validate(defs2.decorators, node, 'decorators', decorators, 1);
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -13988,9 +13815,9 @@ function tsQualifiedName(left, right) {
         right,
     };
     
-    const defs = NODE_FIELDS.TSQualifiedName;
-    validate(defs.left, node, 'left', left, 1);
-    validate(defs.right, node, 'right', right, 1);
+    const defs2 = NODE_FIELDS.TSQualifiedName;
+    validate(defs2.left, node, 'left', left, 1);
+    validate(defs2.right, node, 'right', right, 1);
     return node;
 }
 
@@ -14002,10 +13829,10 @@ function tsCallSignatureDeclaration(typeParameters = null, params, returnType =
         returnType,
     };
     
-    const defs = NODE_FIELDS.TSCallSignatureDeclaration;
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.TSCallSignatureDeclaration;
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -14017,10 +13844,10 @@ function tsConstructSignatureDeclaration(typeParameters = null, params, returnTy
         returnType,
     };
     
-    const defs = NODE_FIELDS.TSConstructSignatureDeclaration;
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.TSConstructSignatureDeclaration;
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -14032,9 +13859,9 @@ function tsPropertySignature(key, typeAnnotation2 = null) {
         computed: false,
     };
     
-    const defs = NODE_FIELDS.TSPropertySignature;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSPropertySignature;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14049,11 +13876,11 @@ function tsMethodSignature(key, typeParameters = null, params, returnType = null
         kind: 'method',
     };
     
-    const defs = NODE_FIELDS.TSMethodSignature;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.TSMethodSignature;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -14064,9 +13891,9 @@ function tsIndexSignature(parameters, typeAnnotation2 = null) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSIndexSignature;
-    validate(defs.parameters, node, 'parameters', parameters, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSIndexSignature;
+    validate(defs2.parameters, node, 'parameters', parameters, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14162,10 +13989,10 @@ function tsFunctionType(typeParameters = null, params, returnType = null) {
         returnType,
     };
     
-    const defs = NODE_FIELDS.TSFunctionType;
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.TSFunctionType;
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -14177,10 +14004,10 @@ function tsConstructorType(typeParameters = null, params, returnType = null) {
         returnType,
     };
     
-    const defs = NODE_FIELDS.TSConstructorType;
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.params, node, 'params', params, 1);
-    validate(defs.returnType, node, 'returnType', returnType, 1);
+    const defs2 = NODE_FIELDS.TSConstructorType;
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.params, node, 'params', params, 1);
+    validate(defs2.returnType, node, 'returnType', returnType, 1);
     return node;
 }
 
@@ -14191,9 +14018,9 @@ function tsTypeReference(typeName, typeArguments = null) {
         typeArguments,
     };
     
-    const defs = NODE_FIELDS.TSTypeReference;
-    validate(defs.typeName, node, 'typeName', typeName, 1);
-    validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
+    const defs2 = NODE_FIELDS.TSTypeReference;
+    validate(defs2.typeName, node, 'typeName', typeName, 1);
+    validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
     return node;
 }
 
@@ -14205,10 +14032,10 @@ function tsTypePredicate(parameterName, typeAnnotation2 = null, asserts = null)
         asserts,
     };
     
-    const defs = NODE_FIELDS.TSTypePredicate;
-    validate(defs.parameterName, node, 'parameterName', parameterName, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
-    validate(defs.asserts, node, 'asserts', asserts);
+    const defs2 = NODE_FIELDS.TSTypePredicate;
+    validate(defs2.parameterName, node, 'parameterName', parameterName, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    validate(defs2.asserts, node, 'asserts', asserts);
     return node;
 }
 
@@ -14219,9 +14046,9 @@ function tsTypeQuery(exprName, typeArguments = null) {
         typeArguments,
     };
     
-    const defs = NODE_FIELDS.TSTypeQuery;
-    validate(defs.exprName, node, 'exprName', exprName, 1);
-    validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
+    const defs2 = NODE_FIELDS.TSTypeQuery;
+    validate(defs2.exprName, node, 'exprName', exprName, 1);
+    validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
     return node;
 }
 
@@ -14231,8 +14058,8 @@ function tsTypeLiteral(members) {
         members,
     };
     
-    const defs = NODE_FIELDS.TSTypeLiteral;
-    validate(defs.members, node, 'members', members, 1);
+    const defs2 = NODE_FIELDS.TSTypeLiteral;
+    validate(defs2.members, node, 'members', members, 1);
     return node;
 }
 
@@ -14242,8 +14069,8 @@ function tsArrayType(elementType) {
         elementType,
     };
     
-    const defs = NODE_FIELDS.TSArrayType;
-    validate(defs.elementType, node, 'elementType', elementType, 1);
+    const defs2 = NODE_FIELDS.TSArrayType;
+    validate(defs2.elementType, node, 'elementType', elementType, 1);
     return node;
 }
 
@@ -14253,8 +14080,8 @@ function tsTupleType(elementTypes) {
         elementTypes,
     };
     
-    const defs = NODE_FIELDS.TSTupleType;
-    validate(defs.elementTypes, node, 'elementTypes', elementTypes, 1);
+    const defs2 = NODE_FIELDS.TSTupleType;
+    validate(defs2.elementTypes, node, 'elementTypes', elementTypes, 1);
     return node;
 }
 
@@ -14264,8 +14091,8 @@ function tsOptionalType(typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSOptionalType;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSOptionalType;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14275,8 +14102,8 @@ function tsRestType(typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSRestType;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSRestType;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14288,10 +14115,10 @@ function tsNamedTupleMember(label, elementType, optional = false) {
         optional,
     };
     
-    const defs = NODE_FIELDS.TSNamedTupleMember;
-    validate(defs.label, node, 'label', label, 1);
-    validate(defs.elementType, node, 'elementType', elementType, 1);
-    validate(defs.optional, node, 'optional', optional);
+    const defs2 = NODE_FIELDS.TSNamedTupleMember;
+    validate(defs2.label, node, 'label', label, 1);
+    validate(defs2.elementType, node, 'elementType', elementType, 1);
+    validate(defs2.optional, node, 'optional', optional);
     return node;
 }
 
@@ -14301,8 +14128,8 @@ function tsUnionType(types2) {
         types: types2,
     };
     
-    const defs = NODE_FIELDS.TSUnionType;
-    validate(defs.types, node, 'types', types2, 1);
+    const defs2 = NODE_FIELDS.TSUnionType;
+    validate(defs2.types, node, 'types', types2, 1);
     return node;
 }
 
@@ -14312,8 +14139,8 @@ function tsIntersectionType(types2) {
         types: types2,
     };
     
-    const defs = NODE_FIELDS.TSIntersectionType;
-    validate(defs.types, node, 'types', types2, 1);
+    const defs2 = NODE_FIELDS.TSIntersectionType;
+    validate(defs2.types, node, 'types', types2, 1);
     return node;
 }
 
@@ -14326,11 +14153,11 @@ function tsConditionalType(checkType, extendsType, trueType, falseType) {
         falseType,
     };
     
-    const defs = NODE_FIELDS.TSConditionalType;
-    validate(defs.checkType, node, 'checkType', checkType, 1);
-    validate(defs.extendsType, node, 'extendsType', extendsType, 1);
-    validate(defs.trueType, node, 'trueType', trueType, 1);
-    validate(defs.falseType, node, 'falseType', falseType, 1);
+    const defs2 = NODE_FIELDS.TSConditionalType;
+    validate(defs2.checkType, node, 'checkType', checkType, 1);
+    validate(defs2.extendsType, node, 'extendsType', extendsType, 1);
+    validate(defs2.trueType, node, 'trueType', trueType, 1);
+    validate(defs2.falseType, node, 'falseType', falseType, 1);
     return node;
 }
 
@@ -14340,8 +14167,8 @@ function tsInferType(typeParameter2) {
         typeParameter: typeParameter2,
     };
     
-    const defs = NODE_FIELDS.TSInferType;
-    validate(defs.typeParameter, node, 'typeParameter', typeParameter2, 1);
+    const defs2 = NODE_FIELDS.TSInferType;
+    validate(defs2.typeParameter, node, 'typeParameter', typeParameter2, 1);
     return node;
 }
 
@@ -14351,8 +14178,8 @@ function tsParenthesizedType(typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSParenthesizedType;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSParenthesizedType;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14363,9 +14190,9 @@ function tsTypeOperator(typeAnnotation2, operator) {
         operator,
     };
     
-    const defs = NODE_FIELDS.TSTypeOperator;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
-    validate(defs.operator, node, 'operator', operator);
+    const defs2 = NODE_FIELDS.TSTypeOperator;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    validate(defs2.operator, node, 'operator', operator);
     return node;
 }
 
@@ -14376,9 +14203,9 @@ function tsIndexedAccessType(objectType, indexType) {
         indexType,
     };
     
-    const defs = NODE_FIELDS.TSIndexedAccessType;
-    validate(defs.objectType, node, 'objectType', objectType, 1);
-    validate(defs.indexType, node, 'indexType', indexType, 1);
+    const defs2 = NODE_FIELDS.TSIndexedAccessType;
+    validate(defs2.objectType, node, 'objectType', objectType, 1);
+    validate(defs2.indexType, node, 'indexType', indexType, 1);
     return node;
 }
 
@@ -14391,11 +14218,11 @@ function tsMappedType(key, constraint, nameType = null, typeAnnotation2 = null)
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSMappedType;
-    validate(defs.key, node, 'key', key, 1);
-    validate(defs.constraint, node, 'constraint', constraint, 1);
-    validate(defs.nameType, node, 'nameType', nameType, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSMappedType;
+    validate(defs2.key, node, 'key', key, 1);
+    validate(defs2.constraint, node, 'constraint', constraint, 1);
+    validate(defs2.nameType, node, 'nameType', nameType, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14406,9 +14233,9 @@ function tsTemplateLiteralType(quasis, types2) {
         types: types2,
     };
     
-    const defs = NODE_FIELDS.TSTemplateLiteralType;
-    validate(defs.quasis, node, 'quasis', quasis, 1);
-    validate(defs.types, node, 'types', types2, 1);
+    const defs2 = NODE_FIELDS.TSTemplateLiteralType;
+    validate(defs2.quasis, node, 'quasis', quasis, 1);
+    validate(defs2.types, node, 'types', types2, 1);
     return node;
 }
 
@@ -14418,8 +14245,8 @@ function tsLiteralType(literal) {
         literal,
     };
     
-    const defs = NODE_FIELDS.TSLiteralType;
-    validate(defs.literal, node, 'literal', literal, 1);
+    const defs2 = NODE_FIELDS.TSLiteralType;
+    validate(defs2.literal, node, 'literal', literal, 1);
     return node;
 }
 
@@ -14430,9 +14257,9 @@ function tsClassImplements(expression2, typeArguments = null) {
         typeArguments,
     };
     
-    const defs = NODE_FIELDS.TSClassImplements;
-    validate(defs.expression, node, 'expression', expression2, 1);
-    validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
+    const defs2 = NODE_FIELDS.TSClassImplements;
+    validate(defs2.expression, node, 'expression', expression2, 1);
+    validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
     return node;
 }
 
@@ -14443,9 +14270,9 @@ function tsInterfaceHeritage(expression2, typeArguments = null) {
         typeArguments,
     };
     
-    const defs = NODE_FIELDS.TSInterfaceHeritage;
-    validate(defs.expression, node, 'expression', expression2, 1);
-    validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
+    const defs2 = NODE_FIELDS.TSInterfaceHeritage;
+    validate(defs2.expression, node, 'expression', expression2, 1);
+    validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
     return node;
 }
 
@@ -14458,11 +14285,11 @@ function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body
         body,
     };
     
-    const defs = NODE_FIELDS.TSInterfaceDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.extends, node, 'extends', _extends, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.TSInterfaceDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.extends, node, 'extends', _extends, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -14472,8 +14299,8 @@ function tsInterfaceBody(body) {
         body,
     };
     
-    const defs = NODE_FIELDS.TSInterfaceBody;
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.TSInterfaceBody;
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -14485,10 +14312,10 @@ function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSTypeAliasDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSTypeAliasDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14499,9 +14326,9 @@ function tsInstantiationExpression(expression2, typeArguments = null) {
         typeArguments,
     };
     
-    const defs = NODE_FIELDS.TSInstantiationExpression;
-    validate(defs.expression, node, 'expression', expression2, 1);
-    validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
+    const defs2 = NODE_FIELDS.TSInstantiationExpression;
+    validate(defs2.expression, node, 'expression', expression2, 1);
+    validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
     return node;
 }
 
@@ -14512,9 +14339,9 @@ function tsAsExpression(expression2, typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSAsExpression;
-    validate(defs.expression, node, 'expression', expression2, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSAsExpression;
+    validate(defs2.expression, node, 'expression', expression2, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14525,9 +14352,9 @@ function tsSatisfiesExpression(expression2, typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSSatisfiesExpression;
-    validate(defs.expression, node, 'expression', expression2, 1);
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSSatisfiesExpression;
+    validate(defs2.expression, node, 'expression', expression2, 1);
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14538,9 +14365,9 @@ function tsTypeAssertion(typeAnnotation2, expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.TSTypeAssertion;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.TSTypeAssertion;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -14550,8 +14377,8 @@ function tsEnumBody(members) {
         members,
     };
     
-    const defs = NODE_FIELDS.TSEnumBody;
-    validate(defs.members, node, 'members', members, 1);
+    const defs2 = NODE_FIELDS.TSEnumBody;
+    validate(defs2.members, node, 'members', members, 1);
     return node;
 }
 
@@ -14562,9 +14389,9 @@ function tsEnumDeclaration(id, body) {
         body,
     };
     
-    const defs = NODE_FIELDS.TSEnumDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.TSEnumDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -14575,9 +14402,9 @@ function tsEnumMember(id, initializer = null) {
         initializer,
     };
     
-    const defs = NODE_FIELDS.TSEnumMember;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.initializer, node, 'initializer', initializer, 1);
+    const defs2 = NODE_FIELDS.TSEnumMember;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.initializer, node, 'initializer', initializer, 1);
     return node;
 }
 
@@ -14589,9 +14416,9 @@ function tsModuleDeclaration(id, body) {
         kind: 'namespace',
     };
     
-    const defs = NODE_FIELDS.TSModuleDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.TSModuleDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -14601,8 +14428,8 @@ function tsModuleBlock(body) {
         body,
     };
     
-    const defs = NODE_FIELDS.TSModuleBlock;
-    validate(defs.body, node, 'body', body, 1);
+    const defs2 = NODE_FIELDS.TSModuleBlock;
+    validate(defs2.body, node, 'body', body, 1);
     return node;
 }
 
@@ -14614,10 +14441,10 @@ function tsImportType(source, qualifier = null, typeArguments = null) {
         typeArguments,
     };
     
-    const defs = NODE_FIELDS.TSImportType;
-    validate(defs.source, node, 'source', source, 1);
-    validate(defs.qualifier, node, 'qualifier', qualifier, 1);
-    validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
+    const defs2 = NODE_FIELDS.TSImportType;
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.qualifier, node, 'qualifier', qualifier, 1);
+    validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
     return node;
 }
 
@@ -14628,9 +14455,9 @@ function tsImportEqualsDeclaration(id, moduleReference) {
         moduleReference,
     };
     
-    const defs = NODE_FIELDS.TSImportEqualsDeclaration;
-    validate(defs.id, node, 'id', id, 1);
-    validate(defs.moduleReference, node, 'moduleReference', moduleReference, 1);
+    const defs2 = NODE_FIELDS.TSImportEqualsDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
+    validate(defs2.moduleReference, node, 'moduleReference', moduleReference, 1);
     return node;
 }
 
@@ -14640,8 +14467,8 @@ function tsExternalModuleReference(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.TSExternalModuleReference;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.TSExternalModuleReference;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -14651,8 +14478,8 @@ function tsNonNullExpression(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.TSNonNullExpression;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.TSNonNullExpression;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -14662,8 +14489,8 @@ function tsExportAssignment(expression2) {
         expression: expression2,
     };
     
-    const defs = NODE_FIELDS.TSExportAssignment;
-    validate(defs.expression, node, 'expression', expression2, 1);
+    const defs2 = NODE_FIELDS.TSExportAssignment;
+    validate(defs2.expression, node, 'expression', expression2, 1);
     return node;
 }
 
@@ -14673,8 +14500,8 @@ function tsNamespaceExportDeclaration(id) {
         id,
     };
     
-    const defs = NODE_FIELDS.TSNamespaceExportDeclaration;
-    validate(defs.id, node, 'id', id, 1);
+    const defs2 = NODE_FIELDS.TSNamespaceExportDeclaration;
+    validate(defs2.id, node, 'id', id, 1);
     return node;
 }
 
@@ -14684,8 +14511,8 @@ function tsTypeAnnotation(typeAnnotation2) {
         typeAnnotation: typeAnnotation2,
     };
     
-    const defs = NODE_FIELDS.TSTypeAnnotation;
-    validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
+    const defs2 = NODE_FIELDS.TSTypeAnnotation;
+    validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
     return node;
 }
 
@@ -14695,8 +14522,8 @@ function tsTypeParameterInstantiation(params) {
         params,
     };
     
-    const defs = NODE_FIELDS.TSTypeParameterInstantiation;
-    validate(defs.params, node, 'params', params, 1);
+    const defs2 = NODE_FIELDS.TSTypeParameterInstantiation;
+    validate(defs2.params, node, 'params', params, 1);
     return node;
 }
 
@@ -14706,8 +14533,8 @@ function tsTypeParameterDeclaration(params) {
         params,
     };
     
-    const defs = NODE_FIELDS.TSTypeParameterDeclaration;
-    validate(defs.params, node, 'params', params, 1);
+    const defs2 = NODE_FIELDS.TSTypeParameterDeclaration;
+    validate(defs2.params, node, 'params', params, 1);
     return node;
 }
 
@@ -14719,10 +14546,10 @@ function tsTypeParameter(constraint = null, _default = null, name) {
         name,
     };
     
-    const defs = NODE_FIELDS.TSTypeParameter;
-    validate(defs.constraint, node, 'constraint', constraint, 1);
-    validate(defs.default, node, 'default', _default, 1);
-    validate(defs.name, node, 'name', name, 1);
+    const defs2 = NODE_FIELDS.TSTypeParameter;
+    validate(defs2.constraint, node, 'constraint', constraint, 1);
+    validate(defs2.default, node, 'default', _default, 1);
+    validate(defs2.name, node, 'name', name, 1);
     return node;
 }
 
@@ -14883,9 +14710,6 @@ var b = /* @__PURE__ */Object.freeze({
     optionalIndexedAccessType,
     optionalMemberExpression,
     parenthesizedExpression,
-    pipelineBareFunction,
-    pipelinePrimaryTopicReference,
-    pipelineTopicExpression,
     placeholder,
     privateName,
     program,
@@ -15094,7 +14918,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');
@@ -15184,14 +15007,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');
@@ -15674,10 +15495,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);
 }
@@ -16034,6 +15851,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);
 }
@@ -16054,18 +15875,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);
 }
@@ -16482,10 +16291,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);
 }
@@ -16526,6 +16331,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);
 }
@@ -17007,7 +16816,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'];
@@ -17018,6 +16826,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'];
@@ -21104,7 +20913,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 <>.',
@@ -21113,7 +20922,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;
@@ -24404,6 +24215,10 @@ var NodeUtils = class extends UtilParser {
     }
     
     finishNodeAt(node, type, endLoc) {
+        if (process.env.NODE_ENV !== 'production' && node.end > 0) {
+            throw new Error('Do not call finishNode*() twice on the same node. Instead use resetEndLocation() or change type directly.');
+        }
+        
         node.type = type;
         node.end = endLoc.index;
         node.loc.end = endLoc;
@@ -25044,7 +24859,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.',
@@ -25110,7 +24925,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) {
@@ -27855,12 +27672,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) {
@@ -28118,10 +27935,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);
@@ -28681,10 +28498,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) {
@@ -29742,17 +29561,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;
@@ -33449,7 +33268,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;
@@ -33570,8 +33389,163 @@ function getParserClass(pluginsMap) {
     return cls;
 }
 
+// ../babel-babel/packages/babel-code-frame/lib/common-BO7XIBW3.js
+var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+
+function getMarkerLines(loc, source, opts, startLineBaseZero) {
+    const startLoc = {
+        column: 0,
+        line: -1,
+        ...loc.start,
+    };
+    
+    const endLoc = {
+        ...startLoc,
+        ...loc.end,
+    };
+    
+    const {linesAbove = 2, linesBelow = 3} = opts || {};
+    
+    const startLine = startLoc.line - startLineBaseZero;
+    const startColumn = startLoc.column;
+    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);
+    
+    if (startLine === -1) {
+        start = 0;
+    }
+    
+    if (endLine === -1) {
+        end = source.length;
+    }
+    
+    const lineDiff = endLine - startLine;
+    const markerLines = {};
+    
+    if (lineDiff) {
+        for (let i = 0; i <= lineDiff; i++) {
+            const lineNumber = i + startLine;
+            
+            if (!startColumn) {
+                markerLines[lineNumber] = true;
+            } else if (i === 0) {
+                const sourceLength = source[lineNumber - 1].length;
+                markerLines[lineNumber] = [
+                    startColumn,
+                    sourceLength - startColumn + 1,
+                ];
+            } else if (i === lineDiff) {
+                markerLines[lineNumber] = [0, endColumn];
+            } else {
+                const sourceLength = source[lineNumber - i].length;
+                markerLines[lineNumber] = [0, sourceLength];
+            }
+
+        }
+    } else {
+        if (startColumn === endColumn) {
+            if (startColumn) {
+                markerLines[startLine] = [startColumn, 0];
+            } else {
+                markerLines[startLine] = true;
+            }
+        } else {
+            markerLines[startLine] = [
+                startColumn,
+                endColumn - startColumn,
+            ];
+        }
+    }
+    
+    return {
+        start,
+        end,
+        markerLines,
+    };
+}
+
+function _codeFrameColumns(rawLines, loc, opts = {}, colorOpts) {
+    const {defs: defs2, highlight: highlight2} = colorOpts || {
+        defs: {
+            gutter: String,
+            marker: String,
+            message: String,
+            reset: String,
+        },
+        highlight: String,
+    };
+    
+    const startLineBaseZero = (opts.startLine || 1) - 1;
+    const lines = rawLines.split(NEWLINE);
+    
+    const {
+        start,
+        end,
+        markerLines,
+    } = getMarkerLines(loc, lines, opts, startLineBaseZero);
+    
+    const hasColumns = loc.start && typeof loc.start.column === 'number';
+    const numberMaxWidth = String(end + startLineBaseZero).length;
+    const highlightedLines = highlight2(rawLines);
+    
+    let frame = highlightedLines
+        .split(NEWLINE, end)
+        .slice(start, end)
+        .map((line, index3) => {
+        const number = start + 1 + index3;
+        const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
+        const gutter = ` ${paddedNumber} |`;
+        const hasMarker = markerLines[number];
+        const lastMarkerLine = !markerLines[number + 1];
+        
+        if (hasMarker) {
+            let markerLine = '';
+            
+            if (Array.isArray(hasMarker)) {
+                const markerSpacing = line
+                    .slice(0, Math.max(hasMarker[0] - 1, 0))
+                    .replace(/[^\t]/g, ' ');
+                const numberOfMarkers = hasMarker[1] || 1;
+                
+                markerLine = [
+                    '\n ',
+                    defs2.gutter(gutter.replace(/\d/g, ' ')),
+                    ' ',
+                    markerSpacing,
+                    defs2
+                        .marker('^')
+                        .repeat(numberOfMarkers),
+                ].join('');
+                
+                if (lastMarkerLine && opts.message) {
+                    markerLine += ' ' + defs2.message(opts.message);
+                }
+            }
+            
+            return [
+                defs2.marker('>'),
+                defs2.gutter(gutter),
+                line.length > 0 ? ` ${line}` : '',
+                markerLine,
+            ].join('');
+        } else {
+            return ` ${defs2.gutter(gutter)}${line.length > 0 ? ` ${line}` : ''}`;
+        }
+    })
+        .join('\n');
+    
+    if (opts.message && !hasColumns) {
+        frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}
+${frame}`;
+    }
+    
+    return defs2.reset(frame);
+}
+
 // ../babel-babel/packages/babel-code-frame/lib/index.js
-var import_picocolors = __toESM(require_picocolors(), 1);
+import {styleText} from 'util';
 
 // ../babel-babel/node_modules/js-tokens/index.js
 var HashbangComment;
@@ -34085,35 +34059,30 @@ var js_tokens_default = jsTokens;
 
 // ../babel-babel/packages/babel-code-frame/lib/index.js
 function isColorSupported() {
-    return typeof process === 'object' && (process.env.FORCE_COLOR === '0' || process.env.FORCE_COLOR === 'false') ? false : import_picocolors.default.isColorSupported;
+    return styleText('red', '-') !== '-';
 }
 
-var compose = (f, g) => (v) => f(g(v));
-
-function buildDefs(colors2) {
-    return {
-        keyword: colors2.cyan,
-        capitalized: colors2.yellow,
-        jsxIdentifier: colors2.yellow,
-        punctuator: colors2.yellow,
-        number: colors2.magenta,
-        string: colors2.green,
-        regex: colors2.magenta,
-        comment: colors2.gray,
-        invalid: compose(compose(colors2.white, colors2.bgRed), colors2.bold),
-        gutter: colors2.gray,
-        marker: compose(colors2.red, colors2.bold),
-        message: compose(colors2.red, colors2.bold),
-        reset: colors2.reset,
-    };
+function createFormatter(format) {
+    return (input) => styleText(format, String(input ?? ''), {
+        validateStream: false,
+    });
 }
 
-var defsOn = buildDefs((0, import_picocolors.createColors)(true));
-var defsOff = buildDefs((0, import_picocolors.createColors)(false));
-
-function getDefs(enabled2) {
-    return enabled2 ? defsOn : defsOff;
-}
+var defs = {
+    keyword: createFormatter('cyan'),
+    capitalized: createFormatter('yellow'),
+    jsxIdentifier: createFormatter('yellow'),
+    punctuator: createFormatter('yellow'),
+    number: createFormatter('magenta'),
+    string: createFormatter('green'),
+    regex: createFormatter('magenta'),
+    comment: createFormatter('gray'),
+    invalid: createFormatter(['white', 'bgRed', 'bold']),
+    gutter: createFormatter('gray'),
+    marker: createFormatter(['red', 'bold']),
+    message: createFormatter(['red', 'bold']),
+    reset: createFormatter('reset'),
+};
 
 var sometimesKeywords = /* @__PURE__ */new Set([
     'as',
@@ -34123,7 +34092,7 @@ var sometimesKeywords = /* @__PURE__ */new Set([
     'of',
     'set',
 ]);
-var NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+var NEWLINE2 = /\r\n|[\n\r\u2028\u2029]/;
 var BRACKET = /^[()[\]{}]$/;
 
 var getTokenType = function(token) {
@@ -34242,13 +34211,12 @@ function highlight(text) {
     if (text === '')
         return '';
     
-    const defs = getDefs(true);
     let highlighted = '';
     
     for (const {type, value} of tokenize(text)) {
         if (type in defs) {
             highlighted += value
-                .split(NEWLINE$1)
+                .split(NEWLINE2)
                 .map((str) => defs[type](str))
                 .join('\n');
         } else {
@@ -34259,153 +34227,13 @@ function highlight(text) {
     return highlighted;
 }
 
-var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-
-function getMarkerLines(loc, source, opts) {
-    const startLoc = {
-        column: 0,
-        line: -1,
-        ...loc.start,
-    };
-    
-    const endLoc = {
-        ...startLoc,
-        ...loc.end,
-    };
-    
-    const {linesAbove = 2, linesBelow = 3} = opts || {};
-    
-    const startLine = startLoc.line;
-    const startColumn = startLoc.column;
-    const endLine = endLoc.line;
-    const endColumn = endLoc.column;
-    let start = Math.max(startLine - (linesAbove + 1), 0);
-    let end = Math.min(source.length, endLine + linesBelow);
-    
-    if (startLine === -1) {
-        start = 0;
-    }
-    
-    if (endLine === -1) {
-        end = source.length;
-    }
-    
-    const lineDiff = endLine - startLine;
-    const markerLines = {};
-    
-    if (lineDiff) {
-        for (let i = 0; i <= lineDiff; i++) {
-            const lineNumber = i + startLine;
-            
-            if (!startColumn) {
-                markerLines[lineNumber] = true;
-            } else if (i === 0) {
-                const sourceLength = source[lineNumber - 1].length;
-                markerLines[lineNumber] = [
-                    startColumn,
-                    sourceLength - startColumn + 1,
-                ];
-            } else if (i === lineDiff) {
-                markerLines[lineNumber] = [0, endColumn];
-            } else {
-                const sourceLength = source[lineNumber - i].length;
-                markerLines[lineNumber] = [0, sourceLength];
-            }
-
-        }
-    } else {
-        if (startColumn === endColumn) {
-            if (startColumn) {
-                markerLines[startLine] = [startColumn, 0];
-            } else {
-                markerLines[startLine] = true;
-            }
-        } else {
-            markerLines[startLine] = [
-                startColumn,
-                endColumn - startColumn,
-            ];
-        }
-    }
-    
-    return {
-        start,
-        end,
-        markerLines,
-    };
-}
-
 function codeFrameColumns(rawLines, loc, opts = {}) {
     const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
-    const defs = getDefs(shouldHighlight);
-    const lines = rawLines.split(NEWLINE);
     
-    const {
-        start,
-        end,
-        markerLines,
-    } = getMarkerLines(loc, lines, opts);
-    
-    const hasColumns = loc.start && typeof loc.start.column === 'number';
-    const numberMaxWidth = String(end).length;
-    const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
-    
-    let frame = highlightedLines
-        .split(NEWLINE, end)
-        .slice(start, end)
-        .map((line, index3) => {
-        const number = start + 1 + index3;
-        const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
-        const gutter = ` ${paddedNumber} |`;
-        const hasMarker = markerLines[number];
-        const lastMarkerLine = !markerLines[number + 1];
-        
-        if (hasMarker) {
-            let markerLine = '';
-            
-            if (Array.isArray(hasMarker)) {
-                const markerSpacing = line
-                    .slice(0, Math.max(hasMarker[0] - 1, 0))
-                    .replace(/[^\t]/g, ' ');
-                const numberOfMarkers = hasMarker[1] || 1;
-                
-                markerLine = [
-                    '\n ',
-                    defs.gutter(gutter.replace(/\d/g, ' ')),
-                    ' ',
-                    markerSpacing,
-                    defs
-                        .marker('^')
-                        .repeat(numberOfMarkers),
-                ].join('');
-                
-                if (lastMarkerLine && opts.message) {
-                    markerLine += ' ' + defs.message(opts.message);
-                }
-            }
-            
-            return [
-                defs.marker('>'),
-                defs.gutter(gutter),
-                line.length > 0 ? ` ${line}` : '',
-                markerLine,
-            ].join('');
-        } else {
-            return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ''}`;
-        }
-    })
-        .join('\n');
-    
-    if (opts.message && !hasColumns) {
-        frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}
-${frame}`;
-    }
-    
-    if (shouldHighlight) {
-        return defs.reset(frame);
-    } else {
-        return frame;
-    }
+    return _codeFrameColumns(rawLines, loc, opts, shouldHighlight ? {
+        defs,
+        highlight,
+    } : void 0);
 }
 
 // ../babel-babel/packages/babel-template/lib/index.js
@@ -35015,28 +34843,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;
         }
     };
@@ -36492,7 +36310,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) => {
@@ -36510,10 +36328,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;
     }
     
@@ -36525,7 +36343,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;
@@ -36552,7 +36370,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;
     }
     
@@ -36564,8 +36382,8 @@ function BinaryLike(node, parent, parentId, nodeType) {
         parentPos = PRECEDENCE.get(parent.operator);
         break;
     
-    case 156:    
-    case 201:
+    case 153:    
+    case 198:
         parentPos = 7;
     }
     
@@ -36592,7 +36410,7 @@ function UnionTypeAnnotation$1(node, parent, parentId) {
     case 4:    
     case 115:    
     case 90:    
-    case 239:
+    case 236:
         return true;
     }
     
@@ -36617,18 +36435,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;
     }
     
@@ -36637,13 +36455,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;
     }
     
@@ -36651,7 +36469,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) {
@@ -36659,7 +36477,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;
     }
     
@@ -36668,11 +36486,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;
         }
@@ -36686,7 +36504,7 @@ function TSInstantiationExpression$1(node, parent, parentId) {
     case 17:    
     case 130:    
     case 112:    
-    case 177:
+    case 174:
         return parent.typeArguments != null;
     }
     
@@ -36697,8 +36515,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);
 }
@@ -36715,7 +36533,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;
     }
     
@@ -36737,8 +36555,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)
@@ -36766,8 +36584,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:
@@ -39022,18 +38840,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');
 }
@@ -40305,9 +40111,6 @@ var generatorFunctions = /* @__PURE__ */Object.freeze({
     OptionalIndexedAccessType: OptionalIndexedAccessType2,
     OptionalMemberExpression: OptionalMemberExpression2,
     ParenthesizedExpression: ParenthesizedExpression2,
-    PipelineBareFunction: PipelineBareFunction2,
-    PipelinePrimaryTopicReference: PipelinePrimaryTopicReference2,
-    PipelineTopicExpression: PipelineTopicExpression2,
     Placeholder: Placeholder2,
     PrivateName: PrivateName2,
     Program: Program2,
@@ -41295,9 +41098,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:            
@@ -41355,7 +41158,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);
@@ -42174,6 +41977,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,
@@ -42778,7 +42755,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);
@@ -42806,8 +42783,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);
             }
         }
         
@@ -42815,7 +42792,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;
@@ -42838,8 +42815,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);
             }
         }
     }
@@ -43852,8 +43829,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);
                 }
             }
         }
@@ -44165,7 +44142,7 @@ collectorVisitor]);
     }
 };
 
-var {VISITOR_KEYS: VISITOR_KEYS$4} = lib_exports;
+var {VISITOR_KEYS: VISITOR_KEYS$2} = lib_exports;
 
 function findParent(callback) {
     let path = this;
@@ -44213,7 +44190,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];
@@ -46435,20 +46412,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);
             }
 
         });
@@ -46838,7 +46815,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);
@@ -46853,7 +46830,7 @@ function ensureFunctionName(supportUnicodeId) {
   `;
     
     return this
-        .replaceWith(call2)[0]
+        .replaceWith(call)[0]
         .get('arguments.0');
 }
 
@@ -46864,7 +46841,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,
@@ -47110,7 +47087,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),
@@ -48048,7 +48025,6 @@ var methods = {
     isConstantExpression,
     isInStrictMode,
     isDenylisted,
-    visit,
     skip,
     skipKey,
     stop,
@@ -48102,325 +48078,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;
@@ -48458,42 +48115,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;
 }