@putout/babel 5.2.7 → 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) {
@@ -11613,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;
 }
 
@@ -11626,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;
 }
 
@@ -11641,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;
 }
 
@@ -11654,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;
 }
 
@@ -11665,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;
 }
 
@@ -11676,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;
 }
 
@@ -11688,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;
 }
 
@@ -11700,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;
 }
 
@@ -11712,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;
 }
 
@@ -11725,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;
 }
 
@@ -11739,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;
 }
 
@@ -11752,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;
 }
 
@@ -11770,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;
 }
 
@@ -11788,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;
 }
 
@@ -11801,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;
 }
 
@@ -11816,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;
 }
 
@@ -11832,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;
 }
 
@@ -11850,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;
 }
 
@@ -11869,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;
 }
 
@@ -11884,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;
 }
 
@@ -11897,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;
 }
 
@@ -11911,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;
 }
 
@@ -11923,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;
 }
 
@@ -11934,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;
 }
 
@@ -11951,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;
 }
 
@@ -11963,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;
 }
 
@@ -11977,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;
 }
 
@@ -11992,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;
 }
 
@@ -12006,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;
 }
 
@@ -12021,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;
 }
 
@@ -12035,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;
 }
 
@@ -12052,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;
 }
 
@@ -12072,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;
 }
 
@@ -12086,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;
 }
 
@@ -12097,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;
 }
 
@@ -12108,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;
 }
 
@@ -12119,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;
 }
 
@@ -12131,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;
 }
 
@@ -12144,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;
 }
 
@@ -12162,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;
 }
 
@@ -12175,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;
 }
 
@@ -12190,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;
 }
 
@@ -12205,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;
 }
 
@@ -12219,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;
 }
 
@@ -12232,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;
 }
 
@@ -12245,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;
 }
 
@@ -12258,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;
 }
 
@@ -12271,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;
 }
 
@@ -12283,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;
 }
 
@@ -12297,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;
 }
 
@@ -12310,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;
 }
 
@@ -12324,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;
 }
 
@@ -12341,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;
 }
 
@@ -12356,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;
 }
 
@@ -12368,8 +12283,8 @@ 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;
 }
 
@@ -12382,11 +12297,11 @@ function exportNamedDeclaration(declaration = null, specifiers = [], source = nu
         attributes,
     };
     
-    const defs = NODE_FIELDS.ExportNamedDeclaration;
-    validate(defs.declaration, node, 'declaration', declaration, 1);
-    validate(defs.specifiers, node, 'specifiers', specifiers, 1);
-    validate(defs.source, node, 'source', source, 1);
-    validate(defs.attributes, node, 'attributes', attributes, 1);
+    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;
 }
 
@@ -12397,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;
 }
 
@@ -12412,11 +12327,11 @@ 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;
 }
 
@@ -12428,10 +12343,10 @@ function importDeclaration(specifiers, source, attributes = null) {
         attributes,
     };
     
-    const defs = NODE_FIELDS.ImportDeclaration;
-    validate(defs.specifiers, node, 'specifiers', specifiers, 1);
-    validate(defs.source, node, 'source', source, 1);
-    validate(defs.attributes, node, 'attributes', attributes, 1);
+    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;
 }
 
@@ -12441,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;
 }
 
@@ -12452,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;
 }
 
@@ -12464,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;
 }
 
@@ -12477,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;
 }
 
@@ -12490,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;
 }
 
@@ -12509,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;
 }
 
@@ -12527,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;
 }
 
@@ -12538,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;
 }
 
@@ -12556,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;
 }
 
@@ -12569,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;
 }
 
@@ -12582,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;
 }
 
@@ -12595,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;
 }
 
@@ -12607,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;
 }
 
@@ -12624,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;
 }
 
@@ -12635,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;
 }
 
@@ -12649,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;
 }
 
@@ -12665,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;
 }
 
@@ -12683,13 +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);
+    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;
 }
 
@@ -12702,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;
 }
 
@@ -12723,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;
 }
 
@@ -12738,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;
 }
 
@@ -12749,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;
 }
 
@@ -12761,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;
 }
 
@@ -12779,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;
 }
 
@@ -12796,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;
 }
 
@@ -12814,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;
 }
 
@@ -12829,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;
 }
 
@@ -12843,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;
 }
 
@@ -12857,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;
 }
 
@@ -12873,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;
 }
 
@@ -12886,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;
 }
 
@@ -12899,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;
 }
 
@@ -12914,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;
 }
 
@@ -12927,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;
 }
 
@@ -12941,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;
 }
 
@@ -12956,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;
 }
 
@@ -12968,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;
 }
 
@@ -12988,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;
 }
 
@@ -13003,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;
 }
 
@@ -13016,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;
 }
 
@@ -13035,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;
 }
 
@@ -13050,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;
 }
 
@@ -13065,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;
 }
 
@@ -13077,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;
 }
 
@@ -13100,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;
 }
 
@@ -13111,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;
 }
 
@@ -13132,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;
 }
 
@@ -13151,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;
 }
 
@@ -13167,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;
 }
 
@@ -13182,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;
 }
 
@@ -13203,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;
 }
 
@@ -13216,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;
 }
 
@@ -13230,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;
 }
 
@@ -13245,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;
 }
 
@@ -13257,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;
 }
 
@@ -13286,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;
 }
 
@@ -13297,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;
 }
 
@@ -13310,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;
 }
 
@@ -13323,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;
 }
 
@@ -13335,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;
 }
 
@@ -13350,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;
 }
 
@@ -13364,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;
 }
 
@@ -13375,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;
 }
 
@@ -13386,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;
 }
 
@@ -13397,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;
 }
 
@@ -13415,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;
 }
 
@@ -13429,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;
 }
 
@@ -13442,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;
 }
 
@@ -13455,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;
 }
 
@@ -13467,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;
 }
 
@@ -13479,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;
 }
 
@@ -13492,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;
 }
 
@@ -13505,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;
 }
 
@@ -13517,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;
 }
 
@@ -13529,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;
 }
 
@@ -13543,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;
 }
 
@@ -13556,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;
 }
 
@@ -13568,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;
 }
 
@@ -13581,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;
 }
 
@@ -13600,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;
 }
 
@@ -13611,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;
 }
 
@@ -13622,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;
 }
 
@@ -13634,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;
 }
 
@@ -13647,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;
 }
 
@@ -13661,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;
 }
 
@@ -13674,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;
 }
 
@@ -13685,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;
 }
 
@@ -13698,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;
 }
 
@@ -13724,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;
 }
 
@@ -13736,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;
 }
 
@@ -13754,9 +13669,9 @@ 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;
 }
 
@@ -13771,13 +13686,13 @@ function classAccessorProperty(key, value = null, typeAnnotation2 = null, decora
         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.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;
 }
 
@@ -13787,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;
 }
 
@@ -13799,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;
 }
 
@@ -13811,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;
 }
 
@@ -13822,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;
 }
 
@@ -13845,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;
 }
 
@@ -13861,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;
 }
 
@@ -13884,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;
 }
 
@@ -13900,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;
 }
 
@@ -13914,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;
 }
 
@@ -13929,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;
 }
 
@@ -13944,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;
 }
 
@@ -13961,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;
 }
 
@@ -13976,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;
 }
 
@@ -14074,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;
 }
 
@@ -14089,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;
 }
 
@@ -14103,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;
 }
 
@@ -14117,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;
 }
 
@@ -14131,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;
 }
 
@@ -14143,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;
 }
 
@@ -14154,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;
 }
 
@@ -14165,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;
 }
 
@@ -14176,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;
 }
 
@@ -14187,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;
 }
 
@@ -14200,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;
 }
 
@@ -14213,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;
 }
 
@@ -14224,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;
 }
 
@@ -14238,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;
 }
 
@@ -14252,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;
 }
 
@@ -14263,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;
 }
 
@@ -14275,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;
 }
 
@@ -14288,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;
 }
 
@@ -14303,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;
 }
 
@@ -14318,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;
 }
 
@@ -14330,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;
 }
 
@@ -14342,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;
 }
 
@@ -14355,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;
 }
 
@@ -14370,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;
 }
 
@@ -14384,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;
 }
 
@@ -14397,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;
 }
 
@@ -14411,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;
 }
 
@@ -14424,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;
 }
 
@@ -14437,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;
 }
 
@@ -14450,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;
 }
 
@@ -14462,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;
 }
 
@@ -14474,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;
 }
 
@@ -14487,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;
 }
 
@@ -14501,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;
 }
 
@@ -14513,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;
 }
 
@@ -14526,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;
 }
 
@@ -14540,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;
 }
 
@@ -14552,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;
 }
 
@@ -14563,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;
 }
 
@@ -14574,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;
 }
 
@@ -14585,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;
 }
 
@@ -14596,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;
 }
 
@@ -14607,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;
 }
 
@@ -14618,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;
 }
 
@@ -14631,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;
 }
 
@@ -24300,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;
@@ -33470,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;
@@ -33985,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',
@@ -34023,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) {
@@ -34142,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 {
@@ -34159,154 +34227,13 @@ function highlight(text) {
     return highlighted;
 }
 
-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 = {}) {
     const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
-    const startLineBaseZero = (opts.startLine || 1) - 1;
-    const defs = getDefs(shouldHighlight);
-    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 = shouldHighlight ? highlight(rawLines) : 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 ',
-                    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