@putout/babel 5.2.7 → 5.2.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/README.md +1 -12
  2. package/bundle/index.js +892 -951
  3. package/bundle/metafile-esm.json +1 -1
  4. package/package.json +8 -8
package/bundle/index.js CHANGED
@@ -40,94 +40,9 @@ isNodeMode || !mod || !mod.__esModule ? __defProp(target, 'default', {
40
40
  enumerable: true,
41
41
  }) : target, mod));
42
42
 
43
- // ../babel-babel/node_modules/picocolors/picocolors.js
44
- var require_picocolors = __commonJS({
45
- '../babel-babel/node_modules/picocolors/picocolors.js'(exports, module) {
46
- var p = process || {};
47
- var argv = p.argv || [];
48
- var env = p.env || {};
49
- var isColorSupported2 = !(!!env.NO_COLOR || argv.includes('--no-color'))
50
- && (!!env.FORCE_COLOR
51
- || argv.includes('--color')
52
- || p.platform === 'win32'
53
- || (p.stdout || {}).isTTY
54
- && env.TERM !== 'dumb'
55
- || !!env.CI);
56
-
57
- var formatter = (open, close, replace = open) => (input) => {
58
- let string = '' + input, index3 = string.indexOf(close, open.length);
59
- return ~index3 ? open + replaceClose(string, close, replace, index3) + close : open + string + close;
60
- };
61
-
62
- var replaceClose = (string, close, replace, index3) => {
63
- let result = '', cursor = 0;
64
-
65
- do {
66
- result += string.substring(cursor, index3) + replace;
67
- cursor = index3 + close.length;
68
- index3 = string.indexOf(close, cursor);
69
- } while (~index3)
70
-
71
- return result + string.substring(cursor);
72
- };
73
-
74
- var createColors2 = (enabled2 = isColorSupported2) => {
75
- let f = enabled2 ? formatter : () => String;
76
-
77
- return {
78
- isColorSupported: enabled2,
79
- reset: f('\x1B[0m', '\x1B[0m'),
80
- bold: f('\x1B[1m', '\x1B[22m', '\x1B[22m\x1B[1m'),
81
- dim: f('\x1B[2m', '\x1B[22m', '\x1B[22m\x1B[2m'),
82
- italic: f('\x1B[3m', '\x1B[23m'),
83
- underline: f('\x1B[4m', '\x1B[24m'),
84
- inverse: f('\x1B[7m', '\x1B[27m'),
85
- hidden: f('\x1B[8m', '\x1B[28m'),
86
- strikethrough: f('\x1B[9m', '\x1B[29m'),
87
- black: f('\x1B[30m', '\x1B[39m'),
88
- red: f('\x1B[31m', '\x1B[39m'),
89
- green: f('\x1B[32m', '\x1B[39m'),
90
- yellow: f('\x1B[33m', '\x1B[39m'),
91
- blue: f('\x1B[34m', '\x1B[39m'),
92
- magenta: f('\x1B[35m', '\x1B[39m'),
93
- cyan: f('\x1B[36m', '\x1B[39m'),
94
- white: f('\x1B[37m', '\x1B[39m'),
95
- gray: f('\x1B[90m', '\x1B[39m'),
96
- bgBlack: f('\x1B[40m', '\x1B[49m'),
97
- bgRed: f('\x1B[41m', '\x1B[49m'),
98
- bgGreen: f('\x1B[42m', '\x1B[49m'),
99
- bgYellow: f('\x1B[43m', '\x1B[49m'),
100
- bgBlue: f('\x1B[44m', '\x1B[49m'),
101
- bgMagenta: f('\x1B[45m', '\x1B[49m'),
102
- bgCyan: f('\x1B[46m', '\x1B[49m'),
103
- bgWhite: f('\x1B[47m', '\x1B[49m'),
104
- blackBright: f('\x1B[90m', '\x1B[39m'),
105
- redBright: f('\x1B[91m', '\x1B[39m'),
106
- greenBright: f('\x1B[92m', '\x1B[39m'),
107
- yellowBright: f('\x1B[93m', '\x1B[39m'),
108
- blueBright: f('\x1B[94m', '\x1B[39m'),
109
- magentaBright: f('\x1B[95m', '\x1B[39m'),
110
- cyanBright: f('\x1B[96m', '\x1B[39m'),
111
- whiteBright: f('\x1B[97m', '\x1B[39m'),
112
- bgBlackBright: f('\x1B[100m', '\x1B[49m'),
113
- bgRedBright: f('\x1B[101m', '\x1B[49m'),
114
- bgGreenBright: f('\x1B[102m', '\x1B[49m'),
115
- bgYellowBright: f('\x1B[103m', '\x1B[49m'),
116
- bgBlueBright: f('\x1B[104m', '\x1B[49m'),
117
- bgMagentaBright: f('\x1B[105m', '\x1B[49m'),
118
- bgCyanBright: f('\x1B[106m', '\x1B[49m'),
119
- bgWhiteBright: f('\x1B[107m', '\x1B[49m'),
120
- };
121
- };
122
-
123
- module.exports = createColors2();
124
- module.exports.createColors = createColors2;
125
- },
126
- });
127
-
128
- // ../babel-babel/node_modules/jsesc/jsesc.js
43
+ // node_modules/jsesc/jsesc.js
129
44
  var require_jsesc = __commonJS({
130
- '../babel-babel/node_modules/jsesc/jsesc.js'(exports, module) {
45
+ 'node_modules/jsesc/jsesc.js'(exports, module) {
131
46
  "use strict";
132
47
 
133
48
  var object = {};
@@ -192,6 +107,10 @@ var require_jsesc = __commonJS({
192
107
  return typeof value == 'number' || toString.call(value) == '[object Number]';
193
108
  };
194
109
 
110
+ var isBigInt = (value) => {
111
+ return typeof value == 'bigint';
112
+ };
113
+
195
114
  var isFunction5 = (value) => {
196
115
  return typeof value == 'function';
197
116
  };
@@ -340,32 +259,41 @@ var require_jsesc = __commonJS({
340
259
  }
341
260
 
342
261
  return '[' + newLine + result.join(',' + newLine) + newLine + (compact ? '' : oldIndent) + ']';
343
- } else if (isNumber2(argument)) {
262
+ } else if (isNumber2(argument) || isBigInt(argument)) {
344
263
  if (json) {
345
- return JSON.stringify(argument);
264
+ return JSON.stringify(Number(argument));
346
265
  }
347
266
 
348
- if (useDecNumbers) {
349
- return String(argument);
350
- }
267
+ let result2;
351
268
 
352
- if (useHexNumbers) {
269
+ if (useDecNumbers) {
270
+ result2 = String(argument);
271
+ } else if (useHexNumbers) {
353
272
  let hexadecimal2 = argument.toString(16);
354
273
 
355
274
  if (!lowercaseHex) {
356
275
  hexadecimal2 = hexadecimal2.toUpperCase();
357
276
  }
358
277
 
359
- return '0x' + hexadecimal2;
278
+ result2 = '0x' + hexadecimal2;
279
+ } else if (useBinNumbers) {
280
+ result2 = '0b' + argument.toString(2);
281
+ } else if (useOctNumbers) {
282
+ result2 = '0o' + argument.toString(8);
360
283
  }
284
+
361
285
 
362
- if (useBinNumbers) {
363
- return '0b' + argument.toString(2);
286
+ if (isBigInt(argument)) {
287
+ return result2 + 'n';
364
288
  }
365
289
 
366
- if (useOctNumbers) {
367
- return '0o' + argument.toString(8);
290
+ return result2;
291
+ } else if (isBigInt(argument)) {
292
+ if (json) {
293
+ return JSON.stringify(Number(argument));
368
294
  }
295
+
296
+ return argument + 'n';
369
297
  } else if (!isObject(argument)) {
370
298
  if (json) {
371
299
  return JSON.stringify(argument) || 'null';
@@ -388,6 +316,7 @@ var require_jsesc = __commonJS({
388
316
  return '{' + newLine + result.join(',' + newLine) + newLine + (compact ? '' : oldIndent) + '}';
389
317
  }
390
318
 
319
+
391
320
  }
392
321
 
393
322
  const regex = options.escapeEverything ? escapeEverythingRegex : escapeNonAsciiRegex;
@@ -474,7 +403,7 @@ var require_jsesc = __commonJS({
474
403
  },
475
404
  });
476
405
 
477
- // ../babel-babel/packages/babel-types/lib/index.js
406
+ // node_modules/@babel/types/lib/index.js
478
407
  var lib_exports = {};
479
408
 
480
409
  __export(lib_exports, {
@@ -1723,7 +1652,7 @@ __export(lib_exports, {
1723
1652
  yieldExpression: () => yieldExpression,
1724
1653
  });
1725
1654
 
1726
- // ../babel-babel/packages/babel-helper-validator-identifier/lib/index.js
1655
+ // node_modules/@babel/helper-validator-identifier/lib/index.js
1727
1656
  var nonASCIIidentifierStartChars = '\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088F\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5C\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDC-\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7DC\uA7F1-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC';
1728
1657
  var nonASCIIidentifierChars = '\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ADD\u1AE0-\u1AEB\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\u30FB\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F\uFF65';
1729
1658
  var nonASCIIidentifierStart = new RegExp('[' + nonASCIIidentifierStartChars + ']');
@@ -2843,7 +2772,7 @@ function isKeyword(word) {
2843
2772
  return keywords.has(word);
2844
2773
  }
2845
2774
 
2846
- // ../babel-babel/packages/babel-helper-string-parser/lib/index.js
2775
+ // node_modules/@babel/helper-string-parser/lib/index.js
2847
2776
  var _isDigit = function isDigit(code2) {
2848
2777
  return code2 >= 48 && code2 <= 57;
2849
2778
  };
@@ -3198,7 +3127,7 @@ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
3198
3127
  };
3199
3128
  }
3200
3129
 
3201
- // ../babel-babel/packages/babel-types/lib/index.js
3130
+ // node_modules/@babel/types/lib/index.js
3202
3131
  function shallowEqual(actual, expected) {
3203
3132
  const keys2 = Object.keys(expected);
3204
3133
 
@@ -11613,8 +11542,8 @@ function arrayExpression(elements) {
11613
11542
  elements,
11614
11543
  };
11615
11544
 
11616
- const defs = NODE_FIELDS.ArrayExpression;
11617
- validate(defs.elements, node, 'elements', elements, 1);
11545
+ const defs2 = NODE_FIELDS.ArrayExpression;
11546
+ validate(defs2.elements, node, 'elements', elements, 1);
11618
11547
  return node;
11619
11548
  }
11620
11549
 
@@ -11626,10 +11555,10 @@ function assignmentExpression(operator, left, right) {
11626
11555
  right,
11627
11556
  };
11628
11557
 
11629
- const defs = NODE_FIELDS.AssignmentExpression;
11630
- validate(defs.operator, node, 'operator', operator);
11631
- validate(defs.left, node, 'left', left, 1);
11632
- validate(defs.right, node, 'right', right, 1);
11558
+ const defs2 = NODE_FIELDS.AssignmentExpression;
11559
+ validate(defs2.operator, node, 'operator', operator);
11560
+ validate(defs2.left, node, 'left', left, 1);
11561
+ validate(defs2.right, node, 'right', right, 1);
11633
11562
  return node;
11634
11563
  }
11635
11564
 
@@ -11641,10 +11570,10 @@ function binaryExpression(operator, left, right) {
11641
11570
  right,
11642
11571
  };
11643
11572
 
11644
- const defs = NODE_FIELDS.BinaryExpression;
11645
- validate(defs.operator, node, 'operator', operator);
11646
- validate(defs.left, node, 'left', left, 1);
11647
- validate(defs.right, node, 'right', right, 1);
11573
+ const defs2 = NODE_FIELDS.BinaryExpression;
11574
+ validate(defs2.operator, node, 'operator', operator);
11575
+ validate(defs2.left, node, 'left', left, 1);
11576
+ validate(defs2.right, node, 'right', right, 1);
11648
11577
  return node;
11649
11578
  }
11650
11579
 
@@ -11654,8 +11583,8 @@ function interpreterDirective(value) {
11654
11583
  value,
11655
11584
  };
11656
11585
 
11657
- const defs = NODE_FIELDS.InterpreterDirective;
11658
- validate(defs.value, node, 'value', value);
11586
+ const defs2 = NODE_FIELDS.InterpreterDirective;
11587
+ validate(defs2.value, node, 'value', value);
11659
11588
  return node;
11660
11589
  }
11661
11590
 
@@ -11665,8 +11594,8 @@ function directive(value) {
11665
11594
  value,
11666
11595
  };
11667
11596
 
11668
- const defs = NODE_FIELDS.Directive;
11669
- validate(defs.value, node, 'value', value, 1);
11597
+ const defs2 = NODE_FIELDS.Directive;
11598
+ validate(defs2.value, node, 'value', value, 1);
11670
11599
  return node;
11671
11600
  }
11672
11601
 
@@ -11676,8 +11605,8 @@ function directiveLiteral(value) {
11676
11605
  value,
11677
11606
  };
11678
11607
 
11679
- const defs = NODE_FIELDS.DirectiveLiteral;
11680
- validate(defs.value, node, 'value', value);
11608
+ const defs2 = NODE_FIELDS.DirectiveLiteral;
11609
+ validate(defs2.value, node, 'value', value);
11681
11610
  return node;
11682
11611
  }
11683
11612
 
@@ -11688,9 +11617,9 @@ function blockStatement(body, directives = []) {
11688
11617
  directives,
11689
11618
  };
11690
11619
 
11691
- const defs = NODE_FIELDS.BlockStatement;
11692
- validate(defs.body, node, 'body', body, 1);
11693
- validate(defs.directives, node, 'directives', directives, 1);
11620
+ const defs2 = NODE_FIELDS.BlockStatement;
11621
+ validate(defs2.body, node, 'body', body, 1);
11622
+ validate(defs2.directives, node, 'directives', directives, 1);
11694
11623
  return node;
11695
11624
  }
11696
11625
 
@@ -11700,8 +11629,8 @@ function breakStatement(label = null) {
11700
11629
  label,
11701
11630
  };
11702
11631
 
11703
- const defs = NODE_FIELDS.BreakStatement;
11704
- validate(defs.label, node, 'label', label, 1);
11632
+ const defs2 = NODE_FIELDS.BreakStatement;
11633
+ validate(defs2.label, node, 'label', label, 1);
11705
11634
  return node;
11706
11635
  }
11707
11636
 
@@ -11712,9 +11641,9 @@ function callExpression(callee, _arguments) {
11712
11641
  arguments: _arguments,
11713
11642
  };
11714
11643
 
11715
- const defs = NODE_FIELDS.CallExpression;
11716
- validate(defs.callee, node, 'callee', callee, 1);
11717
- validate(defs.arguments, node, 'arguments', _arguments, 1);
11644
+ const defs2 = NODE_FIELDS.CallExpression;
11645
+ validate(defs2.callee, node, 'callee', callee, 1);
11646
+ validate(defs2.arguments, node, 'arguments', _arguments, 1);
11718
11647
  return node;
11719
11648
  }
11720
11649
 
@@ -11725,9 +11654,9 @@ function catchClause(param = null, body) {
11725
11654
  body,
11726
11655
  };
11727
11656
 
11728
- const defs = NODE_FIELDS.CatchClause;
11729
- validate(defs.param, node, 'param', param, 1);
11730
- validate(defs.body, node, 'body', body, 1);
11657
+ const defs2 = NODE_FIELDS.CatchClause;
11658
+ validate(defs2.param, node, 'param', param, 1);
11659
+ validate(defs2.body, node, 'body', body, 1);
11731
11660
  return node;
11732
11661
  }
11733
11662
 
@@ -11739,10 +11668,10 @@ function conditionalExpression(test, consequent, alternate) {
11739
11668
  alternate,
11740
11669
  };
11741
11670
 
11742
- const defs = NODE_FIELDS.ConditionalExpression;
11743
- validate(defs.test, node, 'test', test, 1);
11744
- validate(defs.consequent, node, 'consequent', consequent, 1);
11745
- validate(defs.alternate, node, 'alternate', alternate, 1);
11671
+ const defs2 = NODE_FIELDS.ConditionalExpression;
11672
+ validate(defs2.test, node, 'test', test, 1);
11673
+ validate(defs2.consequent, node, 'consequent', consequent, 1);
11674
+ validate(defs2.alternate, node, 'alternate', alternate, 1);
11746
11675
  return node;
11747
11676
  }
11748
11677
 
@@ -11752,8 +11681,8 @@ function continueStatement(label = null) {
11752
11681
  label,
11753
11682
  };
11754
11683
 
11755
- const defs = NODE_FIELDS.ContinueStatement;
11756
- validate(defs.label, node, 'label', label, 1);
11684
+ const defs2 = NODE_FIELDS.ContinueStatement;
11685
+ validate(defs2.label, node, 'label', label, 1);
11757
11686
  return node;
11758
11687
  }
11759
11688
 
@@ -11770,9 +11699,9 @@ function doWhileStatement(test, body) {
11770
11699
  body,
11771
11700
  };
11772
11701
 
11773
- const defs = NODE_FIELDS.DoWhileStatement;
11774
- validate(defs.test, node, 'test', test, 1);
11775
- validate(defs.body, node, 'body', body, 1);
11702
+ const defs2 = NODE_FIELDS.DoWhileStatement;
11703
+ validate(defs2.test, node, 'test', test, 1);
11704
+ validate(defs2.body, node, 'body', body, 1);
11776
11705
  return node;
11777
11706
  }
11778
11707
 
@@ -11788,8 +11717,8 @@ function expressionStatement(expression2) {
11788
11717
  expression: expression2,
11789
11718
  };
11790
11719
 
11791
- const defs = NODE_FIELDS.ExpressionStatement;
11792
- validate(defs.expression, node, 'expression', expression2, 1);
11720
+ const defs2 = NODE_FIELDS.ExpressionStatement;
11721
+ validate(defs2.expression, node, 'expression', expression2, 1);
11793
11722
  return node;
11794
11723
  }
11795
11724
 
@@ -11801,10 +11730,10 @@ function file(program3, comments = null, tokens = null) {
11801
11730
  tokens,
11802
11731
  };
11803
11732
 
11804
- const defs = NODE_FIELDS.File;
11805
- validate(defs.program, node, 'program', program3, 1);
11806
- validate(defs.comments, node, 'comments', comments, 1);
11807
- validate(defs.tokens, node, 'tokens', tokens);
11733
+ const defs2 = NODE_FIELDS.File;
11734
+ validate(defs2.program, node, 'program', program3, 1);
11735
+ validate(defs2.comments, node, 'comments', comments, 1);
11736
+ validate(defs2.tokens, node, 'tokens', tokens);
11808
11737
  return node;
11809
11738
  }
11810
11739
 
@@ -11816,10 +11745,10 @@ function forInStatement(left, right, body) {
11816
11745
  body,
11817
11746
  };
11818
11747
 
11819
- const defs = NODE_FIELDS.ForInStatement;
11820
- validate(defs.left, node, 'left', left, 1);
11821
- validate(defs.right, node, 'right', right, 1);
11822
- validate(defs.body, node, 'body', body, 1);
11748
+ const defs2 = NODE_FIELDS.ForInStatement;
11749
+ validate(defs2.left, node, 'left', left, 1);
11750
+ validate(defs2.right, node, 'right', right, 1);
11751
+ validate(defs2.body, node, 'body', body, 1);
11823
11752
  return node;
11824
11753
  }
11825
11754
 
@@ -11832,11 +11761,11 @@ function forStatement(init = null, test = null, update = null, body) {
11832
11761
  body,
11833
11762
  };
11834
11763
 
11835
- const defs = NODE_FIELDS.ForStatement;
11836
- validate(defs.init, node, 'init', init, 1);
11837
- validate(defs.test, node, 'test', test, 1);
11838
- validate(defs.update, node, 'update', update, 1);
11839
- validate(defs.body, node, 'body', body, 1);
11764
+ const defs2 = NODE_FIELDS.ForStatement;
11765
+ validate(defs2.init, node, 'init', init, 1);
11766
+ validate(defs2.test, node, 'test', test, 1);
11767
+ validate(defs2.update, node, 'update', update, 1);
11768
+ validate(defs2.body, node, 'body', body, 1);
11840
11769
  return node;
11841
11770
  }
11842
11771
 
@@ -11850,12 +11779,12 @@ function functionDeclaration(id = null, params, body, generator = false, async =
11850
11779
  async,
11851
11780
  };
11852
11781
 
11853
- const defs = NODE_FIELDS.FunctionDeclaration;
11854
- validate(defs.id, node, 'id', id, 1);
11855
- validate(defs.params, node, 'params', params, 1);
11856
- validate(defs.body, node, 'body', body, 1);
11857
- validate(defs.generator, node, 'generator', generator);
11858
- validate(defs.async, node, 'async', async);
11782
+ const defs2 = NODE_FIELDS.FunctionDeclaration;
11783
+ validate(defs2.id, node, 'id', id, 1);
11784
+ validate(defs2.params, node, 'params', params, 1);
11785
+ validate(defs2.body, node, 'body', body, 1);
11786
+ validate(defs2.generator, node, 'generator', generator);
11787
+ validate(defs2.async, node, 'async', async);
11859
11788
  return node;
11860
11789
  }
11861
11790
 
@@ -11869,12 +11798,12 @@ function functionExpression(id = null, params, body, generator = false, async =
11869
11798
  async,
11870
11799
  };
11871
11800
 
11872
- const defs = NODE_FIELDS.FunctionExpression;
11873
- validate(defs.id, node, 'id', id, 1);
11874
- validate(defs.params, node, 'params', params, 1);
11875
- validate(defs.body, node, 'body', body, 1);
11876
- validate(defs.generator, node, 'generator', generator);
11877
- validate(defs.async, node, 'async', async);
11801
+ const defs2 = NODE_FIELDS.FunctionExpression;
11802
+ validate(defs2.id, node, 'id', id, 1);
11803
+ validate(defs2.params, node, 'params', params, 1);
11804
+ validate(defs2.body, node, 'body', body, 1);
11805
+ validate(defs2.generator, node, 'generator', generator);
11806
+ validate(defs2.async, node, 'async', async);
11878
11807
  return node;
11879
11808
  }
11880
11809
 
@@ -11884,8 +11813,8 @@ function identifier(name) {
11884
11813
  name,
11885
11814
  };
11886
11815
 
11887
- const defs = NODE_FIELDS.Identifier;
11888
- validate(defs.name, node, 'name', name);
11816
+ const defs2 = NODE_FIELDS.Identifier;
11817
+ validate(defs2.name, node, 'name', name);
11889
11818
  return node;
11890
11819
  }
11891
11820
 
@@ -11897,10 +11826,10 @@ function ifStatement(test, consequent, alternate = null) {
11897
11826
  alternate,
11898
11827
  };
11899
11828
 
11900
- const defs = NODE_FIELDS.IfStatement;
11901
- validate(defs.test, node, 'test', test, 1);
11902
- validate(defs.consequent, node, 'consequent', consequent, 1);
11903
- validate(defs.alternate, node, 'alternate', alternate, 1);
11829
+ const defs2 = NODE_FIELDS.IfStatement;
11830
+ validate(defs2.test, node, 'test', test, 1);
11831
+ validate(defs2.consequent, node, 'consequent', consequent, 1);
11832
+ validate(defs2.alternate, node, 'alternate', alternate, 1);
11904
11833
  return node;
11905
11834
  }
11906
11835
 
@@ -11911,9 +11840,9 @@ function labeledStatement(label, body) {
11911
11840
  body,
11912
11841
  };
11913
11842
 
11914
- const defs = NODE_FIELDS.LabeledStatement;
11915
- validate(defs.label, node, 'label', label, 1);
11916
- validate(defs.body, node, 'body', body, 1);
11843
+ const defs2 = NODE_FIELDS.LabeledStatement;
11844
+ validate(defs2.label, node, 'label', label, 1);
11845
+ validate(defs2.body, node, 'body', body, 1);
11917
11846
  return node;
11918
11847
  }
11919
11848
 
@@ -11923,8 +11852,8 @@ function stringLiteral(value) {
11923
11852
  value,
11924
11853
  };
11925
11854
 
11926
- const defs = NODE_FIELDS.StringLiteral;
11927
- validate(defs.value, node, 'value', value);
11855
+ const defs2 = NODE_FIELDS.StringLiteral;
11856
+ validate(defs2.value, node, 'value', value);
11928
11857
  return node;
11929
11858
  }
11930
11859
 
@@ -11934,8 +11863,8 @@ function numericLiteral(value) {
11934
11863
  value,
11935
11864
  };
11936
11865
 
11937
- const defs = NODE_FIELDS.NumericLiteral;
11938
- validate(defs.value, node, 'value', value);
11866
+ const defs2 = NODE_FIELDS.NumericLiteral;
11867
+ validate(defs2.value, node, 'value', value);
11939
11868
  return node;
11940
11869
  }
11941
11870
 
@@ -11951,8 +11880,8 @@ function booleanLiteral(value) {
11951
11880
  value,
11952
11881
  };
11953
11882
 
11954
- const defs = NODE_FIELDS.BooleanLiteral;
11955
- validate(defs.value, node, 'value', value);
11883
+ const defs2 = NODE_FIELDS.BooleanLiteral;
11884
+ validate(defs2.value, node, 'value', value);
11956
11885
  return node;
11957
11886
  }
11958
11887
 
@@ -11963,9 +11892,9 @@ function regExpLiteral(pattern, flags = '') {
11963
11892
  flags,
11964
11893
  };
11965
11894
 
11966
- const defs = NODE_FIELDS.RegExpLiteral;
11967
- validate(defs.pattern, node, 'pattern', pattern);
11968
- validate(defs.flags, node, 'flags', flags);
11895
+ const defs2 = NODE_FIELDS.RegExpLiteral;
11896
+ validate(defs2.pattern, node, 'pattern', pattern);
11897
+ validate(defs2.flags, node, 'flags', flags);
11969
11898
  return node;
11970
11899
  }
11971
11900
 
@@ -11977,10 +11906,10 @@ function logicalExpression(operator, left, right) {
11977
11906
  right,
11978
11907
  };
11979
11908
 
11980
- const defs = NODE_FIELDS.LogicalExpression;
11981
- validate(defs.operator, node, 'operator', operator);
11982
- validate(defs.left, node, 'left', left, 1);
11983
- validate(defs.right, node, 'right', right, 1);
11909
+ const defs2 = NODE_FIELDS.LogicalExpression;
11910
+ validate(defs2.operator, node, 'operator', operator);
11911
+ validate(defs2.left, node, 'left', left, 1);
11912
+ validate(defs2.right, node, 'right', right, 1);
11984
11913
  return node;
11985
11914
  }
11986
11915
 
@@ -11992,10 +11921,10 @@ function memberExpression(object, property, computed = false) {
11992
11921
  computed,
11993
11922
  };
11994
11923
 
11995
- const defs = NODE_FIELDS.MemberExpression;
11996
- validate(defs.object, node, 'object', object, 1);
11997
- validate(defs.property, node, 'property', property, 1);
11998
- validate(defs.computed, node, 'computed', computed);
11924
+ const defs2 = NODE_FIELDS.MemberExpression;
11925
+ validate(defs2.object, node, 'object', object, 1);
11926
+ validate(defs2.property, node, 'property', property, 1);
11927
+ validate(defs2.computed, node, 'computed', computed);
11999
11928
  return node;
12000
11929
  }
12001
11930
 
@@ -12006,9 +11935,9 @@ function newExpression(callee, _arguments) {
12006
11935
  arguments: _arguments,
12007
11936
  };
12008
11937
 
12009
- const defs = NODE_FIELDS.NewExpression;
12010
- validate(defs.callee, node, 'callee', callee, 1);
12011
- validate(defs.arguments, node, 'arguments', _arguments, 1);
11938
+ const defs2 = NODE_FIELDS.NewExpression;
11939
+ validate(defs2.callee, node, 'callee', callee, 1);
11940
+ validate(defs2.arguments, node, 'arguments', _arguments, 1);
12012
11941
  return node;
12013
11942
  }
12014
11943
 
@@ -12021,11 +11950,11 @@ function program(body, directives = [], sourceType = 'script', interpreter = nul
12021
11950
  interpreter,
12022
11951
  };
12023
11952
 
12024
- const defs = NODE_FIELDS.Program;
12025
- validate(defs.body, node, 'body', body, 1);
12026
- validate(defs.directives, node, 'directives', directives, 1);
12027
- validate(defs.sourceType, node, 'sourceType', sourceType);
12028
- validate(defs.interpreter, node, 'interpreter', interpreter, 1);
11953
+ const defs2 = NODE_FIELDS.Program;
11954
+ validate(defs2.body, node, 'body', body, 1);
11955
+ validate(defs2.directives, node, 'directives', directives, 1);
11956
+ validate(defs2.sourceType, node, 'sourceType', sourceType);
11957
+ validate(defs2.interpreter, node, 'interpreter', interpreter, 1);
12029
11958
  return node;
12030
11959
  }
12031
11960
 
@@ -12035,8 +11964,8 @@ function objectExpression(properties) {
12035
11964
  properties,
12036
11965
  };
12037
11966
 
12038
- const defs = NODE_FIELDS.ObjectExpression;
12039
- validate(defs.properties, node, 'properties', properties, 1);
11967
+ const defs2 = NODE_FIELDS.ObjectExpression;
11968
+ validate(defs2.properties, node, 'properties', properties, 1);
12040
11969
  return node;
12041
11970
  }
12042
11971
 
@@ -12052,14 +11981,14 @@ function objectMethod(kind, key, params, body, computed = false, generator = fal
12052
11981
  async,
12053
11982
  };
12054
11983
 
12055
- const defs = NODE_FIELDS.ObjectMethod;
12056
- validate(defs.kind, node, 'kind', kind);
12057
- validate(defs.key, node, 'key', key, 1);
12058
- validate(defs.params, node, 'params', params, 1);
12059
- validate(defs.body, node, 'body', body, 1);
12060
- validate(defs.computed, node, 'computed', computed);
12061
- validate(defs.generator, node, 'generator', generator);
12062
- validate(defs.async, node, 'async', async);
11984
+ const defs2 = NODE_FIELDS.ObjectMethod;
11985
+ validate(defs2.kind, node, 'kind', kind);
11986
+ validate(defs2.key, node, 'key', key, 1);
11987
+ validate(defs2.params, node, 'params', params, 1);
11988
+ validate(defs2.body, node, 'body', body, 1);
11989
+ validate(defs2.computed, node, 'computed', computed);
11990
+ validate(defs2.generator, node, 'generator', generator);
11991
+ validate(defs2.async, node, 'async', async);
12063
11992
  return node;
12064
11993
  }
12065
11994
 
@@ -12072,11 +12001,11 @@ function objectProperty(key, value, computed = false, shorthand = false) {
12072
12001
  shorthand,
12073
12002
  };
12074
12003
 
12075
- const defs = NODE_FIELDS.ObjectProperty;
12076
- validate(defs.key, node, 'key', key, 1);
12077
- validate(defs.value, node, 'value', value, 1);
12078
- validate(defs.computed, node, 'computed', computed);
12079
- validate(defs.shorthand, node, 'shorthand', shorthand);
12004
+ const defs2 = NODE_FIELDS.ObjectProperty;
12005
+ validate(defs2.key, node, 'key', key, 1);
12006
+ validate(defs2.value, node, 'value', value, 1);
12007
+ validate(defs2.computed, node, 'computed', computed);
12008
+ validate(defs2.shorthand, node, 'shorthand', shorthand);
12080
12009
  return node;
12081
12010
  }
12082
12011
 
@@ -12086,8 +12015,8 @@ function restElement(argument) {
12086
12015
  argument,
12087
12016
  };
12088
12017
 
12089
- const defs = NODE_FIELDS.RestElement;
12090
- validate(defs.argument, node, 'argument', argument, 1);
12018
+ const defs2 = NODE_FIELDS.RestElement;
12019
+ validate(defs2.argument, node, 'argument', argument, 1);
12091
12020
  return node;
12092
12021
  }
12093
12022
 
@@ -12097,8 +12026,8 @@ function returnStatement(argument = null) {
12097
12026
  argument,
12098
12027
  };
12099
12028
 
12100
- const defs = NODE_FIELDS.ReturnStatement;
12101
- validate(defs.argument, node, 'argument', argument, 1);
12029
+ const defs2 = NODE_FIELDS.ReturnStatement;
12030
+ validate(defs2.argument, node, 'argument', argument, 1);
12102
12031
  return node;
12103
12032
  }
12104
12033
 
@@ -12108,8 +12037,8 @@ function sequenceExpression(expressions) {
12108
12037
  expressions,
12109
12038
  };
12110
12039
 
12111
- const defs = NODE_FIELDS.SequenceExpression;
12112
- validate(defs.expressions, node, 'expressions', expressions, 1);
12040
+ const defs2 = NODE_FIELDS.SequenceExpression;
12041
+ validate(defs2.expressions, node, 'expressions', expressions, 1);
12113
12042
  return node;
12114
12043
  }
12115
12044
 
@@ -12119,8 +12048,8 @@ function parenthesizedExpression(expression2) {
12119
12048
  expression: expression2,
12120
12049
  };
12121
12050
 
12122
- const defs = NODE_FIELDS.ParenthesizedExpression;
12123
- validate(defs.expression, node, 'expression', expression2, 1);
12051
+ const defs2 = NODE_FIELDS.ParenthesizedExpression;
12052
+ validate(defs2.expression, node, 'expression', expression2, 1);
12124
12053
  return node;
12125
12054
  }
12126
12055
 
@@ -12131,9 +12060,9 @@ function switchCase(test = null, consequent) {
12131
12060
  consequent,
12132
12061
  };
12133
12062
 
12134
- const defs = NODE_FIELDS.SwitchCase;
12135
- validate(defs.test, node, 'test', test, 1);
12136
- validate(defs.consequent, node, 'consequent', consequent, 1);
12063
+ const defs2 = NODE_FIELDS.SwitchCase;
12064
+ validate(defs2.test, node, 'test', test, 1);
12065
+ validate(defs2.consequent, node, 'consequent', consequent, 1);
12137
12066
  return node;
12138
12067
  }
12139
12068
 
@@ -12144,9 +12073,9 @@ function switchStatement(discriminant, cases) {
12144
12073
  cases,
12145
12074
  };
12146
12075
 
12147
- const defs = NODE_FIELDS.SwitchStatement;
12148
- validate(defs.discriminant, node, 'discriminant', discriminant, 1);
12149
- validate(defs.cases, node, 'cases', cases, 1);
12076
+ const defs2 = NODE_FIELDS.SwitchStatement;
12077
+ validate(defs2.discriminant, node, 'discriminant', discriminant, 1);
12078
+ validate(defs2.cases, node, 'cases', cases, 1);
12150
12079
  return node;
12151
12080
  }
12152
12081
 
@@ -12162,8 +12091,8 @@ function throwStatement(argument) {
12162
12091
  argument,
12163
12092
  };
12164
12093
 
12165
- const defs = NODE_FIELDS.ThrowStatement;
12166
- validate(defs.argument, node, 'argument', argument, 1);
12094
+ const defs2 = NODE_FIELDS.ThrowStatement;
12095
+ validate(defs2.argument, node, 'argument', argument, 1);
12167
12096
  return node;
12168
12097
  }
12169
12098
 
@@ -12175,10 +12104,10 @@ function tryStatement(block, handler = null, finalizer = null) {
12175
12104
  finalizer,
12176
12105
  };
12177
12106
 
12178
- const defs = NODE_FIELDS.TryStatement;
12179
- validate(defs.block, node, 'block', block, 1);
12180
- validate(defs.handler, node, 'handler', handler, 1);
12181
- validate(defs.finalizer, node, 'finalizer', finalizer, 1);
12107
+ const defs2 = NODE_FIELDS.TryStatement;
12108
+ validate(defs2.block, node, 'block', block, 1);
12109
+ validate(defs2.handler, node, 'handler', handler, 1);
12110
+ validate(defs2.finalizer, node, 'finalizer', finalizer, 1);
12182
12111
  return node;
12183
12112
  }
12184
12113
 
@@ -12190,10 +12119,10 @@ function unaryExpression(operator, argument, prefix2 = true) {
12190
12119
  prefix: prefix2,
12191
12120
  };
12192
12121
 
12193
- const defs = NODE_FIELDS.UnaryExpression;
12194
- validate(defs.operator, node, 'operator', operator);
12195
- validate(defs.argument, node, 'argument', argument, 1);
12196
- validate(defs.prefix, node, 'prefix', prefix2);
12122
+ const defs2 = NODE_FIELDS.UnaryExpression;
12123
+ validate(defs2.operator, node, 'operator', operator);
12124
+ validate(defs2.argument, node, 'argument', argument, 1);
12125
+ validate(defs2.prefix, node, 'prefix', prefix2);
12197
12126
  return node;
12198
12127
  }
12199
12128
 
@@ -12205,10 +12134,10 @@ function updateExpression(operator, argument, prefix2 = false) {
12205
12134
  prefix: prefix2,
12206
12135
  };
12207
12136
 
12208
- const defs = NODE_FIELDS.UpdateExpression;
12209
- validate(defs.operator, node, 'operator', operator);
12210
- validate(defs.argument, node, 'argument', argument, 1);
12211
- validate(defs.prefix, node, 'prefix', prefix2);
12137
+ const defs2 = NODE_FIELDS.UpdateExpression;
12138
+ validate(defs2.operator, node, 'operator', operator);
12139
+ validate(defs2.argument, node, 'argument', argument, 1);
12140
+ validate(defs2.prefix, node, 'prefix', prefix2);
12212
12141
  return node;
12213
12142
  }
12214
12143
 
@@ -12219,9 +12148,9 @@ function variableDeclaration(kind, declarations) {
12219
12148
  declarations,
12220
12149
  };
12221
12150
 
12222
- const defs = NODE_FIELDS.VariableDeclaration;
12223
- validate(defs.kind, node, 'kind', kind);
12224
- validate(defs.declarations, node, 'declarations', declarations, 1);
12151
+ const defs2 = NODE_FIELDS.VariableDeclaration;
12152
+ validate(defs2.kind, node, 'kind', kind);
12153
+ validate(defs2.declarations, node, 'declarations', declarations, 1);
12225
12154
  return node;
12226
12155
  }
12227
12156
 
@@ -12232,9 +12161,9 @@ function variableDeclarator(id, init = null) {
12232
12161
  init,
12233
12162
  };
12234
12163
 
12235
- const defs = NODE_FIELDS.VariableDeclarator;
12236
- validate(defs.id, node, 'id', id, 1);
12237
- validate(defs.init, node, 'init', init, 1);
12164
+ const defs2 = NODE_FIELDS.VariableDeclarator;
12165
+ validate(defs2.id, node, 'id', id, 1);
12166
+ validate(defs2.init, node, 'init', init, 1);
12238
12167
  return node;
12239
12168
  }
12240
12169
 
@@ -12245,9 +12174,9 @@ function whileStatement(test, body) {
12245
12174
  body,
12246
12175
  };
12247
12176
 
12248
- const defs = NODE_FIELDS.WhileStatement;
12249
- validate(defs.test, node, 'test', test, 1);
12250
- validate(defs.body, node, 'body', body, 1);
12177
+ const defs2 = NODE_FIELDS.WhileStatement;
12178
+ validate(defs2.test, node, 'test', test, 1);
12179
+ validate(defs2.body, node, 'body', body, 1);
12251
12180
  return node;
12252
12181
  }
12253
12182
 
@@ -12258,9 +12187,9 @@ function withStatement(object, body) {
12258
12187
  body,
12259
12188
  };
12260
12189
 
12261
- const defs = NODE_FIELDS.WithStatement;
12262
- validate(defs.object, node, 'object', object, 1);
12263
- validate(defs.body, node, 'body', body, 1);
12190
+ const defs2 = NODE_FIELDS.WithStatement;
12191
+ validate(defs2.object, node, 'object', object, 1);
12192
+ validate(defs2.body, node, 'body', body, 1);
12264
12193
  return node;
12265
12194
  }
12266
12195
 
@@ -12271,9 +12200,9 @@ function assignmentPattern(left, right) {
12271
12200
  right,
12272
12201
  };
12273
12202
 
12274
- const defs = NODE_FIELDS.AssignmentPattern;
12275
- validate(defs.left, node, 'left', left, 1);
12276
- validate(defs.right, node, 'right', right, 1);
12203
+ const defs2 = NODE_FIELDS.AssignmentPattern;
12204
+ validate(defs2.left, node, 'left', left, 1);
12205
+ validate(defs2.right, node, 'right', right, 1);
12277
12206
  return node;
12278
12207
  }
12279
12208
 
@@ -12283,8 +12212,8 @@ function arrayPattern(elements) {
12283
12212
  elements,
12284
12213
  };
12285
12214
 
12286
- const defs = NODE_FIELDS.ArrayPattern;
12287
- validate(defs.elements, node, 'elements', elements, 1);
12215
+ const defs2 = NODE_FIELDS.ArrayPattern;
12216
+ validate(defs2.elements, node, 'elements', elements, 1);
12288
12217
  return node;
12289
12218
  }
12290
12219
 
@@ -12297,10 +12226,10 @@ function arrowFunctionExpression(params, body, async = false) {
12297
12226
  expression: body.type !== 'BlockStatement',
12298
12227
  };
12299
12228
 
12300
- const defs = NODE_FIELDS.ArrowFunctionExpression;
12301
- validate(defs.params, node, 'params', params, 1);
12302
- validate(defs.body, node, 'body', body, 1);
12303
- validate(defs.async, node, 'async', async);
12229
+ const defs2 = NODE_FIELDS.ArrowFunctionExpression;
12230
+ validate(defs2.params, node, 'params', params, 1);
12231
+ validate(defs2.body, node, 'body', body, 1);
12232
+ validate(defs2.async, node, 'async', async);
12304
12233
  return node;
12305
12234
  }
12306
12235
 
@@ -12310,8 +12239,8 @@ function classBody(body) {
12310
12239
  body,
12311
12240
  };
12312
12241
 
12313
- const defs = NODE_FIELDS.ClassBody;
12314
- validate(defs.body, node, 'body', body, 1);
12242
+ const defs2 = NODE_FIELDS.ClassBody;
12243
+ validate(defs2.body, node, 'body', body, 1);
12315
12244
  return node;
12316
12245
  }
12317
12246
 
@@ -12324,11 +12253,11 @@ function classExpression(id = null, superClass = null, body, decorators = null)
12324
12253
  decorators,
12325
12254
  };
12326
12255
 
12327
- const defs = NODE_FIELDS.ClassExpression;
12328
- validate(defs.id, node, 'id', id, 1);
12329
- validate(defs.superClass, node, 'superClass', superClass, 1);
12330
- validate(defs.body, node, 'body', body, 1);
12331
- validate(defs.decorators, node, 'decorators', decorators, 1);
12256
+ const defs2 = NODE_FIELDS.ClassExpression;
12257
+ validate(defs2.id, node, 'id', id, 1);
12258
+ validate(defs2.superClass, node, 'superClass', superClass, 1);
12259
+ validate(defs2.body, node, 'body', body, 1);
12260
+ validate(defs2.decorators, node, 'decorators', decorators, 1);
12332
12261
  return node;
12333
12262
  }
12334
12263
 
@@ -12341,11 +12270,11 @@ function classDeclaration(id = null, superClass = null, body, decorators = null)
12341
12270
  decorators,
12342
12271
  };
12343
12272
 
12344
- const defs = NODE_FIELDS.ClassDeclaration;
12345
- validate(defs.id, node, 'id', id, 1);
12346
- validate(defs.superClass, node, 'superClass', superClass, 1);
12347
- validate(defs.body, node, 'body', body, 1);
12348
- validate(defs.decorators, node, 'decorators', decorators, 1);
12273
+ const defs2 = NODE_FIELDS.ClassDeclaration;
12274
+ validate(defs2.id, node, 'id', id, 1);
12275
+ validate(defs2.superClass, node, 'superClass', superClass, 1);
12276
+ validate(defs2.body, node, 'body', body, 1);
12277
+ validate(defs2.decorators, node, 'decorators', decorators, 1);
12349
12278
  return node;
12350
12279
  }
12351
12280
 
@@ -12356,9 +12285,9 @@ function exportAllDeclaration(source, attributes = null) {
12356
12285
  attributes,
12357
12286
  };
12358
12287
 
12359
- const defs = NODE_FIELDS.ExportAllDeclaration;
12360
- validate(defs.source, node, 'source', source, 1);
12361
- validate(defs.attributes, node, 'attributes', attributes, 1);
12288
+ const defs2 = NODE_FIELDS.ExportAllDeclaration;
12289
+ validate(defs2.source, node, 'source', source, 1);
12290
+ validate(defs2.attributes, node, 'attributes', attributes, 1);
12362
12291
  return node;
12363
12292
  }
12364
12293
 
@@ -12368,8 +12297,8 @@ function exportDefaultDeclaration(declaration) {
12368
12297
  declaration,
12369
12298
  };
12370
12299
 
12371
- const defs = NODE_FIELDS.ExportDefaultDeclaration;
12372
- validate(defs.declaration, node, 'declaration', declaration, 1);
12300
+ const defs2 = NODE_FIELDS.ExportDefaultDeclaration;
12301
+ validate(defs2.declaration, node, 'declaration', declaration, 1);
12373
12302
  return node;
12374
12303
  }
12375
12304
 
@@ -12382,11 +12311,11 @@ function exportNamedDeclaration(declaration = null, specifiers = [], source = nu
12382
12311
  attributes,
12383
12312
  };
12384
12313
 
12385
- const defs = NODE_FIELDS.ExportNamedDeclaration;
12386
- validate(defs.declaration, node, 'declaration', declaration, 1);
12387
- validate(defs.specifiers, node, 'specifiers', specifiers, 1);
12388
- validate(defs.source, node, 'source', source, 1);
12389
- validate(defs.attributes, node, 'attributes', attributes, 1);
12314
+ const defs2 = NODE_FIELDS.ExportNamedDeclaration;
12315
+ validate(defs2.declaration, node, 'declaration', declaration, 1);
12316
+ validate(defs2.specifiers, node, 'specifiers', specifiers, 1);
12317
+ validate(defs2.source, node, 'source', source, 1);
12318
+ validate(defs2.attributes, node, 'attributes', attributes, 1);
12390
12319
  return node;
12391
12320
  }
12392
12321
 
@@ -12397,9 +12326,9 @@ function exportSpecifier(local, exported) {
12397
12326
  exported,
12398
12327
  };
12399
12328
 
12400
- const defs = NODE_FIELDS.ExportSpecifier;
12401
- validate(defs.local, node, 'local', local, 1);
12402
- validate(defs.exported, node, 'exported', exported, 1);
12329
+ const defs2 = NODE_FIELDS.ExportSpecifier;
12330
+ validate(defs2.local, node, 'local', local, 1);
12331
+ validate(defs2.exported, node, 'exported', exported, 1);
12403
12332
  return node;
12404
12333
  }
12405
12334
 
@@ -12412,11 +12341,11 @@ function forOfStatement(left, right, body, _await = false) {
12412
12341
  await: _await,
12413
12342
  };
12414
12343
 
12415
- const defs = NODE_FIELDS.ForOfStatement;
12416
- validate(defs.left, node, 'left', left, 1);
12417
- validate(defs.right, node, 'right', right, 1);
12418
- validate(defs.body, node, 'body', body, 1);
12419
- validate(defs.await, node, 'await', _await);
12344
+ const defs2 = NODE_FIELDS.ForOfStatement;
12345
+ validate(defs2.left, node, 'left', left, 1);
12346
+ validate(defs2.right, node, 'right', right, 1);
12347
+ validate(defs2.body, node, 'body', body, 1);
12348
+ validate(defs2.await, node, 'await', _await);
12420
12349
  return node;
12421
12350
  }
12422
12351
 
@@ -12428,10 +12357,10 @@ function importDeclaration(specifiers, source, attributes = null) {
12428
12357
  attributes,
12429
12358
  };
12430
12359
 
12431
- const defs = NODE_FIELDS.ImportDeclaration;
12432
- validate(defs.specifiers, node, 'specifiers', specifiers, 1);
12433
- validate(defs.source, node, 'source', source, 1);
12434
- validate(defs.attributes, node, 'attributes', attributes, 1);
12360
+ const defs2 = NODE_FIELDS.ImportDeclaration;
12361
+ validate(defs2.specifiers, node, 'specifiers', specifiers, 1);
12362
+ validate(defs2.source, node, 'source', source, 1);
12363
+ validate(defs2.attributes, node, 'attributes', attributes, 1);
12435
12364
  return node;
12436
12365
  }
12437
12366
 
@@ -12441,8 +12370,8 @@ function importDefaultSpecifier(local) {
12441
12370
  local,
12442
12371
  };
12443
12372
 
12444
- const defs = NODE_FIELDS.ImportDefaultSpecifier;
12445
- validate(defs.local, node, 'local', local, 1);
12373
+ const defs2 = NODE_FIELDS.ImportDefaultSpecifier;
12374
+ validate(defs2.local, node, 'local', local, 1);
12446
12375
  return node;
12447
12376
  }
12448
12377
 
@@ -12452,8 +12381,8 @@ function importNamespaceSpecifier(local) {
12452
12381
  local,
12453
12382
  };
12454
12383
 
12455
- const defs = NODE_FIELDS.ImportNamespaceSpecifier;
12456
- validate(defs.local, node, 'local', local, 1);
12384
+ const defs2 = NODE_FIELDS.ImportNamespaceSpecifier;
12385
+ validate(defs2.local, node, 'local', local, 1);
12457
12386
  return node;
12458
12387
  }
12459
12388
 
@@ -12464,9 +12393,9 @@ function importSpecifier(local, imported) {
12464
12393
  imported,
12465
12394
  };
12466
12395
 
12467
- const defs = NODE_FIELDS.ImportSpecifier;
12468
- validate(defs.local, node, 'local', local, 1);
12469
- validate(defs.imported, node, 'imported', imported, 1);
12396
+ const defs2 = NODE_FIELDS.ImportSpecifier;
12397
+ validate(defs2.local, node, 'local', local, 1);
12398
+ validate(defs2.imported, node, 'imported', imported, 1);
12470
12399
  return node;
12471
12400
  }
12472
12401
 
@@ -12477,9 +12406,9 @@ function importExpression(source, options = null) {
12477
12406
  options,
12478
12407
  };
12479
12408
 
12480
- const defs = NODE_FIELDS.ImportExpression;
12481
- validate(defs.source, node, 'source', source, 1);
12482
- validate(defs.options, node, 'options', options, 1);
12409
+ const defs2 = NODE_FIELDS.ImportExpression;
12410
+ validate(defs2.source, node, 'source', source, 1);
12411
+ validate(defs2.options, node, 'options', options, 1);
12483
12412
  return node;
12484
12413
  }
12485
12414
 
@@ -12490,9 +12419,9 @@ function metaProperty(meta, property) {
12490
12419
  property,
12491
12420
  };
12492
12421
 
12493
- const defs = NODE_FIELDS.MetaProperty;
12494
- validate(defs.meta, node, 'meta', meta, 1);
12495
- validate(defs.property, node, 'property', property, 1);
12422
+ const defs2 = NODE_FIELDS.MetaProperty;
12423
+ validate(defs2.meta, node, 'meta', meta, 1);
12424
+ validate(defs2.property, node, 'property', property, 1);
12496
12425
  return node;
12497
12426
  }
12498
12427
 
@@ -12509,15 +12438,15 @@ function classMethod(kind = 'method', key, params, body, computed = false, _stat
12509
12438
  async,
12510
12439
  };
12511
12440
 
12512
- const defs = NODE_FIELDS.ClassMethod;
12513
- validate(defs.kind, node, 'kind', kind);
12514
- validate(defs.key, node, 'key', key, 1);
12515
- validate(defs.params, node, 'params', params, 1);
12516
- validate(defs.body, node, 'body', body, 1);
12517
- validate(defs.computed, node, 'computed', computed);
12518
- validate(defs.static, node, 'static', _static);
12519
- validate(defs.generator, node, 'generator', generator);
12520
- validate(defs.async, node, 'async', async);
12441
+ const defs2 = NODE_FIELDS.ClassMethod;
12442
+ validate(defs2.kind, node, 'kind', kind);
12443
+ validate(defs2.key, node, 'key', key, 1);
12444
+ validate(defs2.params, node, 'params', params, 1);
12445
+ validate(defs2.body, node, 'body', body, 1);
12446
+ validate(defs2.computed, node, 'computed', computed);
12447
+ validate(defs2.static, node, 'static', _static);
12448
+ validate(defs2.generator, node, 'generator', generator);
12449
+ validate(defs2.async, node, 'async', async);
12521
12450
  return node;
12522
12451
  }
12523
12452
 
@@ -12527,8 +12456,8 @@ function objectPattern(properties) {
12527
12456
  properties,
12528
12457
  };
12529
12458
 
12530
- const defs = NODE_FIELDS.ObjectPattern;
12531
- validate(defs.properties, node, 'properties', properties, 1);
12459
+ const defs2 = NODE_FIELDS.ObjectPattern;
12460
+ validate(defs2.properties, node, 'properties', properties, 1);
12532
12461
  return node;
12533
12462
  }
12534
12463
 
@@ -12538,8 +12467,8 @@ function spreadElement(argument) {
12538
12467
  argument,
12539
12468
  };
12540
12469
 
12541
- const defs = NODE_FIELDS.SpreadElement;
12542
- validate(defs.argument, node, 'argument', argument, 1);
12470
+ const defs2 = NODE_FIELDS.SpreadElement;
12471
+ validate(defs2.argument, node, 'argument', argument, 1);
12543
12472
  return node;
12544
12473
  }
12545
12474
 
@@ -12556,9 +12485,9 @@ function taggedTemplateExpression(tag, quasi) {
12556
12485
  quasi,
12557
12486
  };
12558
12487
 
12559
- const defs = NODE_FIELDS.TaggedTemplateExpression;
12560
- validate(defs.tag, node, 'tag', tag, 1);
12561
- validate(defs.quasi, node, 'quasi', quasi, 1);
12488
+ const defs2 = NODE_FIELDS.TaggedTemplateExpression;
12489
+ validate(defs2.tag, node, 'tag', tag, 1);
12490
+ validate(defs2.quasi, node, 'quasi', quasi, 1);
12562
12491
  return node;
12563
12492
  }
12564
12493
 
@@ -12569,9 +12498,9 @@ function templateElement(value, tail = false) {
12569
12498
  tail,
12570
12499
  };
12571
12500
 
12572
- const defs = NODE_FIELDS.TemplateElement;
12573
- validate(defs.value, node, 'value', value);
12574
- validate(defs.tail, node, 'tail', tail);
12501
+ const defs2 = NODE_FIELDS.TemplateElement;
12502
+ validate(defs2.value, node, 'value', value);
12503
+ validate(defs2.tail, node, 'tail', tail);
12575
12504
  return node;
12576
12505
  }
12577
12506
 
@@ -12582,9 +12511,9 @@ function templateLiteral(quasis, expressions) {
12582
12511
  expressions,
12583
12512
  };
12584
12513
 
12585
- const defs = NODE_FIELDS.TemplateLiteral;
12586
- validate(defs.quasis, node, 'quasis', quasis, 1);
12587
- validate(defs.expressions, node, 'expressions', expressions, 1);
12514
+ const defs2 = NODE_FIELDS.TemplateLiteral;
12515
+ validate(defs2.quasis, node, 'quasis', quasis, 1);
12516
+ validate(defs2.expressions, node, 'expressions', expressions, 1);
12588
12517
  return node;
12589
12518
  }
12590
12519
 
@@ -12595,9 +12524,9 @@ function yieldExpression(argument = null, delegate = false) {
12595
12524
  delegate,
12596
12525
  };
12597
12526
 
12598
- const defs = NODE_FIELDS.YieldExpression;
12599
- validate(defs.argument, node, 'argument', argument, 1);
12600
- validate(defs.delegate, node, 'delegate', delegate);
12527
+ const defs2 = NODE_FIELDS.YieldExpression;
12528
+ validate(defs2.argument, node, 'argument', argument, 1);
12529
+ validate(defs2.delegate, node, 'delegate', delegate);
12601
12530
  return node;
12602
12531
  }
12603
12532
 
@@ -12607,8 +12536,8 @@ function awaitExpression(argument) {
12607
12536
  argument,
12608
12537
  };
12609
12538
 
12610
- const defs = NODE_FIELDS.AwaitExpression;
12611
- validate(defs.argument, node, 'argument', argument, 1);
12539
+ const defs2 = NODE_FIELDS.AwaitExpression;
12540
+ validate(defs2.argument, node, 'argument', argument, 1);
12612
12541
  return node;
12613
12542
  }
12614
12543
 
@@ -12624,8 +12553,8 @@ function bigIntLiteral(value) {
12624
12553
  value,
12625
12554
  };
12626
12555
 
12627
- const defs = NODE_FIELDS.BigIntLiteral;
12628
- validate(defs.value, node, 'value', value);
12556
+ const defs2 = NODE_FIELDS.BigIntLiteral;
12557
+ validate(defs2.value, node, 'value', value);
12629
12558
  return node;
12630
12559
  }
12631
12560
 
@@ -12635,8 +12564,8 @@ function exportNamespaceSpecifier(exported) {
12635
12564
  exported,
12636
12565
  };
12637
12566
 
12638
- const defs = NODE_FIELDS.ExportNamespaceSpecifier;
12639
- validate(defs.exported, node, 'exported', exported, 1);
12567
+ const defs2 = NODE_FIELDS.ExportNamespaceSpecifier;
12568
+ validate(defs2.exported, node, 'exported', exported, 1);
12640
12569
  return node;
12641
12570
  }
12642
12571
 
@@ -12649,11 +12578,11 @@ function optionalMemberExpression(object, property, computed = false, optional)
12649
12578
  optional,
12650
12579
  };
12651
12580
 
12652
- const defs = NODE_FIELDS.OptionalMemberExpression;
12653
- validate(defs.object, node, 'object', object, 1);
12654
- validate(defs.property, node, 'property', property, 1);
12655
- validate(defs.computed, node, 'computed', computed);
12656
- validate(defs.optional, node, 'optional', optional);
12581
+ const defs2 = NODE_FIELDS.OptionalMemberExpression;
12582
+ validate(defs2.object, node, 'object', object, 1);
12583
+ validate(defs2.property, node, 'property', property, 1);
12584
+ validate(defs2.computed, node, 'computed', computed);
12585
+ validate(defs2.optional, node, 'optional', optional);
12657
12586
  return node;
12658
12587
  }
12659
12588
 
@@ -12665,10 +12594,10 @@ function optionalCallExpression(callee, _arguments, optional) {
12665
12594
  optional,
12666
12595
  };
12667
12596
 
12668
- const defs = NODE_FIELDS.OptionalCallExpression;
12669
- validate(defs.callee, node, 'callee', callee, 1);
12670
- validate(defs.arguments, node, 'arguments', _arguments, 1);
12671
- validate(defs.optional, node, 'optional', optional);
12597
+ const defs2 = NODE_FIELDS.OptionalCallExpression;
12598
+ validate(defs2.callee, node, 'callee', callee, 1);
12599
+ validate(defs2.arguments, node, 'arguments', _arguments, 1);
12600
+ validate(defs2.optional, node, 'optional', optional);
12672
12601
  return node;
12673
12602
  }
12674
12603
 
@@ -12683,13 +12612,13 @@ function classProperty(key, value = null, typeAnnotation2 = null, decorators = n
12683
12612
  static: _static,
12684
12613
  };
12685
12614
 
12686
- const defs = NODE_FIELDS.ClassProperty;
12687
- validate(defs.key, node, 'key', key, 1);
12688
- validate(defs.value, node, 'value', value, 1);
12689
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
12690
- validate(defs.decorators, node, 'decorators', decorators, 1);
12691
- validate(defs.computed, node, 'computed', computed);
12692
- validate(defs.static, node, 'static', _static);
12615
+ const defs2 = NODE_FIELDS.ClassProperty;
12616
+ validate(defs2.key, node, 'key', key, 1);
12617
+ validate(defs2.value, node, 'value', value, 1);
12618
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
12619
+ validate(defs2.decorators, node, 'decorators', decorators, 1);
12620
+ validate(defs2.computed, node, 'computed', computed);
12621
+ validate(defs2.static, node, 'static', _static);
12693
12622
  return node;
12694
12623
  }
12695
12624
 
@@ -12702,11 +12631,11 @@ function classPrivateProperty(key, value = null, decorators = null, _static = fa
12702
12631
  static: _static,
12703
12632
  };
12704
12633
 
12705
- const defs = NODE_FIELDS.ClassPrivateProperty;
12706
- validate(defs.key, node, 'key', key, 1);
12707
- validate(defs.value, node, 'value', value, 1);
12708
- validate(defs.decorators, node, 'decorators', decorators, 1);
12709
- validate(defs.static, node, 'static', _static);
12634
+ const defs2 = NODE_FIELDS.ClassPrivateProperty;
12635
+ validate(defs2.key, node, 'key', key, 1);
12636
+ validate(defs2.value, node, 'value', value, 1);
12637
+ validate(defs2.decorators, node, 'decorators', decorators, 1);
12638
+ validate(defs2.static, node, 'static', _static);
12710
12639
  return node;
12711
12640
  }
12712
12641
 
@@ -12723,12 +12652,12 @@ function classPrivateMethod(kind = 'method', key, params, body, _static = false)
12723
12652
  generator: false,
12724
12653
  };
12725
12654
 
12726
- const defs = NODE_FIELDS.ClassPrivateMethod;
12727
- validate(defs.kind, node, 'kind', kind);
12728
- validate(defs.key, node, 'key', key, 1);
12729
- validate(defs.params, node, 'params', params, 1);
12730
- validate(defs.body, node, 'body', body, 1);
12731
- validate(defs.static, node, 'static', _static);
12655
+ const defs2 = NODE_FIELDS.ClassPrivateMethod;
12656
+ validate(defs2.kind, node, 'kind', kind);
12657
+ validate(defs2.key, node, 'key', key, 1);
12658
+ validate(defs2.params, node, 'params', params, 1);
12659
+ validate(defs2.body, node, 'body', body, 1);
12660
+ validate(defs2.static, node, 'static', _static);
12732
12661
  return node;
12733
12662
  }
12734
12663
 
@@ -12738,8 +12667,8 @@ function privateName(id) {
12738
12667
  id,
12739
12668
  };
12740
12669
 
12741
- const defs = NODE_FIELDS.PrivateName;
12742
- validate(defs.id, node, 'id', id, 1);
12670
+ const defs2 = NODE_FIELDS.PrivateName;
12671
+ validate(defs2.id, node, 'id', id, 1);
12743
12672
  return node;
12744
12673
  }
12745
12674
 
@@ -12749,8 +12678,8 @@ function staticBlock(body) {
12749
12678
  body,
12750
12679
  };
12751
12680
 
12752
- const defs = NODE_FIELDS.StaticBlock;
12753
- validate(defs.body, node, 'body', body, 1);
12681
+ const defs2 = NODE_FIELDS.StaticBlock;
12682
+ validate(defs2.body, node, 'body', body, 1);
12754
12683
  return node;
12755
12684
  }
12756
12685
 
@@ -12761,9 +12690,9 @@ function importAttribute(key, value) {
12761
12690
  value,
12762
12691
  };
12763
12692
 
12764
- const defs = NODE_FIELDS.ImportAttribute;
12765
- validate(defs.key, node, 'key', key, 1);
12766
- validate(defs.value, node, 'value', value, 1);
12693
+ const defs2 = NODE_FIELDS.ImportAttribute;
12694
+ validate(defs2.key, node, 'key', key, 1);
12695
+ validate(defs2.value, node, 'value', value, 1);
12767
12696
  return node;
12768
12697
  }
12769
12698
 
@@ -12779,8 +12708,8 @@ function arrayTypeAnnotation(elementType) {
12779
12708
  elementType,
12780
12709
  };
12781
12710
 
12782
- const defs = NODE_FIELDS.ArrayTypeAnnotation;
12783
- validate(defs.elementType, node, 'elementType', elementType, 1);
12711
+ const defs2 = NODE_FIELDS.ArrayTypeAnnotation;
12712
+ validate(defs2.elementType, node, 'elementType', elementType, 1);
12784
12713
  return node;
12785
12714
  }
12786
12715
 
@@ -12796,8 +12725,8 @@ function booleanLiteralTypeAnnotation(value) {
12796
12725
  value,
12797
12726
  };
12798
12727
 
12799
- const defs = NODE_FIELDS.BooleanLiteralTypeAnnotation;
12800
- validate(defs.value, node, 'value', value);
12728
+ const defs2 = NODE_FIELDS.BooleanLiteralTypeAnnotation;
12729
+ validate(defs2.value, node, 'value', value);
12801
12730
  return node;
12802
12731
  }
12803
12732
 
@@ -12814,9 +12743,9 @@ function classImplements(id, typeParameters = null) {
12814
12743
  typeParameters,
12815
12744
  };
12816
12745
 
12817
- const defs = NODE_FIELDS.ClassImplements;
12818
- validate(defs.id, node, 'id', id, 1);
12819
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12746
+ const defs2 = NODE_FIELDS.ClassImplements;
12747
+ validate(defs2.id, node, 'id', id, 1);
12748
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
12820
12749
  return node;
12821
12750
  }
12822
12751
 
@@ -12829,11 +12758,11 @@ function declareClass(id, typeParameters = null, _extends = null, body) {
12829
12758
  body,
12830
12759
  };
12831
12760
 
12832
- const defs = NODE_FIELDS.DeclareClass;
12833
- validate(defs.id, node, 'id', id, 1);
12834
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12835
- validate(defs.extends, node, 'extends', _extends, 1);
12836
- validate(defs.body, node, 'body', body, 1);
12761
+ const defs2 = NODE_FIELDS.DeclareClass;
12762
+ validate(defs2.id, node, 'id', id, 1);
12763
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
12764
+ validate(defs2.extends, node, 'extends', _extends, 1);
12765
+ validate(defs2.body, node, 'body', body, 1);
12837
12766
  return node;
12838
12767
  }
12839
12768
 
@@ -12843,8 +12772,8 @@ function declareFunction(id) {
12843
12772
  id,
12844
12773
  };
12845
12774
 
12846
- const defs = NODE_FIELDS.DeclareFunction;
12847
- validate(defs.id, node, 'id', id, 1);
12775
+ const defs2 = NODE_FIELDS.DeclareFunction;
12776
+ validate(defs2.id, node, 'id', id, 1);
12848
12777
  return node;
12849
12778
  }
12850
12779
 
@@ -12857,11 +12786,11 @@ function declareInterface(id, typeParameters = null, _extends = null, body) {
12857
12786
  body,
12858
12787
  };
12859
12788
 
12860
- const defs = NODE_FIELDS.DeclareInterface;
12861
- validate(defs.id, node, 'id', id, 1);
12862
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12863
- validate(defs.extends, node, 'extends', _extends, 1);
12864
- validate(defs.body, node, 'body', body, 1);
12789
+ const defs2 = NODE_FIELDS.DeclareInterface;
12790
+ validate(defs2.id, node, 'id', id, 1);
12791
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
12792
+ validate(defs2.extends, node, 'extends', _extends, 1);
12793
+ validate(defs2.body, node, 'body', body, 1);
12865
12794
  return node;
12866
12795
  }
12867
12796
 
@@ -12873,10 +12802,10 @@ function declareModule(id, body, kind = null) {
12873
12802
  kind,
12874
12803
  };
12875
12804
 
12876
- const defs = NODE_FIELDS.DeclareModule;
12877
- validate(defs.id, node, 'id', id, 1);
12878
- validate(defs.body, node, 'body', body, 1);
12879
- validate(defs.kind, node, 'kind', kind);
12805
+ const defs2 = NODE_FIELDS.DeclareModule;
12806
+ validate(defs2.id, node, 'id', id, 1);
12807
+ validate(defs2.body, node, 'body', body, 1);
12808
+ validate(defs2.kind, node, 'kind', kind);
12880
12809
  return node;
12881
12810
  }
12882
12811
 
@@ -12886,8 +12815,8 @@ function declareModuleExports(typeAnnotation2) {
12886
12815
  typeAnnotation: typeAnnotation2,
12887
12816
  };
12888
12817
 
12889
- const defs = NODE_FIELDS.DeclareModuleExports;
12890
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
12818
+ const defs2 = NODE_FIELDS.DeclareModuleExports;
12819
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
12891
12820
  return node;
12892
12821
  }
12893
12822
 
@@ -12899,10 +12828,10 @@ function declareTypeAlias(id, typeParameters = null, right) {
12899
12828
  right,
12900
12829
  };
12901
12830
 
12902
- const defs = NODE_FIELDS.DeclareTypeAlias;
12903
- validate(defs.id, node, 'id', id, 1);
12904
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12905
- validate(defs.right, node, 'right', right, 1);
12831
+ const defs2 = NODE_FIELDS.DeclareTypeAlias;
12832
+ validate(defs2.id, node, 'id', id, 1);
12833
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
12834
+ validate(defs2.right, node, 'right', right, 1);
12906
12835
  return node;
12907
12836
  }
12908
12837
 
@@ -12914,10 +12843,10 @@ function declareOpaqueType(id, typeParameters = null, supertype = null) {
12914
12843
  supertype,
12915
12844
  };
12916
12845
 
12917
- const defs = NODE_FIELDS.DeclareOpaqueType;
12918
- validate(defs.id, node, 'id', id, 1);
12919
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12920
- validate(defs.supertype, node, 'supertype', supertype, 1);
12846
+ const defs2 = NODE_FIELDS.DeclareOpaqueType;
12847
+ validate(defs2.id, node, 'id', id, 1);
12848
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
12849
+ validate(defs2.supertype, node, 'supertype', supertype, 1);
12921
12850
  return node;
12922
12851
  }
12923
12852
 
@@ -12927,8 +12856,8 @@ function declareVariable(id) {
12927
12856
  id,
12928
12857
  };
12929
12858
 
12930
- const defs = NODE_FIELDS.DeclareVariable;
12931
- validate(defs.id, node, 'id', id, 1);
12859
+ const defs2 = NODE_FIELDS.DeclareVariable;
12860
+ validate(defs2.id, node, 'id', id, 1);
12932
12861
  return node;
12933
12862
  }
12934
12863
 
@@ -12941,11 +12870,11 @@ function declareExportDeclaration(declaration = null, specifiers = null, source
12941
12870
  attributes,
12942
12871
  };
12943
12872
 
12944
- const defs = NODE_FIELDS.DeclareExportDeclaration;
12945
- validate(defs.declaration, node, 'declaration', declaration, 1);
12946
- validate(defs.specifiers, node, 'specifiers', specifiers, 1);
12947
- validate(defs.source, node, 'source', source, 1);
12948
- validate(defs.attributes, node, 'attributes', attributes, 1);
12873
+ const defs2 = NODE_FIELDS.DeclareExportDeclaration;
12874
+ validate(defs2.declaration, node, 'declaration', declaration, 1);
12875
+ validate(defs2.specifiers, node, 'specifiers', specifiers, 1);
12876
+ validate(defs2.source, node, 'source', source, 1);
12877
+ validate(defs2.attributes, node, 'attributes', attributes, 1);
12949
12878
  return node;
12950
12879
  }
12951
12880
 
@@ -12956,9 +12885,9 @@ function declareExportAllDeclaration(source, attributes = null) {
12956
12885
  attributes,
12957
12886
  };
12958
12887
 
12959
- const defs = NODE_FIELDS.DeclareExportAllDeclaration;
12960
- validate(defs.source, node, 'source', source, 1);
12961
- validate(defs.attributes, node, 'attributes', attributes, 1);
12888
+ const defs2 = NODE_FIELDS.DeclareExportAllDeclaration;
12889
+ validate(defs2.source, node, 'source', source, 1);
12890
+ validate(defs2.attributes, node, 'attributes', attributes, 1);
12962
12891
  return node;
12963
12892
  }
12964
12893
 
@@ -12968,8 +12897,8 @@ function declaredPredicate(value) {
12968
12897
  value,
12969
12898
  };
12970
12899
 
12971
- const defs = NODE_FIELDS.DeclaredPredicate;
12972
- validate(defs.value, node, 'value', value, 1);
12900
+ const defs2 = NODE_FIELDS.DeclaredPredicate;
12901
+ validate(defs2.value, node, 'value', value, 1);
12973
12902
  return node;
12974
12903
  }
12975
12904
 
@@ -12988,11 +12917,11 @@ function functionTypeAnnotation(typeParameters = null, params, rest = null, retu
12988
12917
  returnType,
12989
12918
  };
12990
12919
 
12991
- const defs = NODE_FIELDS.FunctionTypeAnnotation;
12992
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12993
- validate(defs.params, node, 'params', params, 1);
12994
- validate(defs.rest, node, 'rest', rest, 1);
12995
- validate(defs.returnType, node, 'returnType', returnType, 1);
12920
+ const defs2 = NODE_FIELDS.FunctionTypeAnnotation;
12921
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
12922
+ validate(defs2.params, node, 'params', params, 1);
12923
+ validate(defs2.rest, node, 'rest', rest, 1);
12924
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
12996
12925
  return node;
12997
12926
  }
12998
12927
 
@@ -13003,9 +12932,9 @@ function functionTypeParam(name = null, typeAnnotation2) {
13003
12932
  typeAnnotation: typeAnnotation2,
13004
12933
  };
13005
12934
 
13006
- const defs = NODE_FIELDS.FunctionTypeParam;
13007
- validate(defs.name, node, 'name', name, 1);
13008
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
12935
+ const defs2 = NODE_FIELDS.FunctionTypeParam;
12936
+ validate(defs2.name, node, 'name', name, 1);
12937
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13009
12938
  return node;
13010
12939
  }
13011
12940
 
@@ -13016,9 +12945,9 @@ function genericTypeAnnotation(id, typeParameters = null) {
13016
12945
  typeParameters,
13017
12946
  };
13018
12947
 
13019
- const defs = NODE_FIELDS.GenericTypeAnnotation;
13020
- validate(defs.id, node, 'id', id, 1);
13021
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12948
+ const defs2 = NODE_FIELDS.GenericTypeAnnotation;
12949
+ validate(defs2.id, node, 'id', id, 1);
12950
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13022
12951
  return node;
13023
12952
  }
13024
12953
 
@@ -13035,9 +12964,9 @@ function interfaceExtends(id, typeParameters = null) {
13035
12964
  typeParameters,
13036
12965
  };
13037
12966
 
13038
- const defs = NODE_FIELDS.InterfaceExtends;
13039
- validate(defs.id, node, 'id', id, 1);
13040
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
12967
+ const defs2 = NODE_FIELDS.InterfaceExtends;
12968
+ validate(defs2.id, node, 'id', id, 1);
12969
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13041
12970
  return node;
13042
12971
  }
13043
12972
 
@@ -13050,11 +12979,11 @@ function interfaceDeclaration(id, typeParameters = null, _extends = null, body)
13050
12979
  body,
13051
12980
  };
13052
12981
 
13053
- const defs = NODE_FIELDS.InterfaceDeclaration;
13054
- validate(defs.id, node, 'id', id, 1);
13055
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13056
- validate(defs.extends, node, 'extends', _extends, 1);
13057
- validate(defs.body, node, 'body', body, 1);
12982
+ const defs2 = NODE_FIELDS.InterfaceDeclaration;
12983
+ validate(defs2.id, node, 'id', id, 1);
12984
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
12985
+ validate(defs2.extends, node, 'extends', _extends, 1);
12986
+ validate(defs2.body, node, 'body', body, 1);
13058
12987
  return node;
13059
12988
  }
13060
12989
 
@@ -13065,9 +12994,9 @@ function interfaceTypeAnnotation(_extends = null, body) {
13065
12994
  body,
13066
12995
  };
13067
12996
 
13068
- const defs = NODE_FIELDS.InterfaceTypeAnnotation;
13069
- validate(defs.extends, node, 'extends', _extends, 1);
13070
- validate(defs.body, node, 'body', body, 1);
12997
+ const defs2 = NODE_FIELDS.InterfaceTypeAnnotation;
12998
+ validate(defs2.extends, node, 'extends', _extends, 1);
12999
+ validate(defs2.body, node, 'body', body, 1);
13071
13000
  return node;
13072
13001
  }
13073
13002
 
@@ -13077,8 +13006,8 @@ function intersectionTypeAnnotation(types2) {
13077
13006
  types: types2,
13078
13007
  };
13079
13008
 
13080
- const defs = NODE_FIELDS.IntersectionTypeAnnotation;
13081
- validate(defs.types, node, 'types', types2, 1);
13009
+ const defs2 = NODE_FIELDS.IntersectionTypeAnnotation;
13010
+ validate(defs2.types, node, 'types', types2, 1);
13082
13011
  return node;
13083
13012
  }
13084
13013
 
@@ -13100,8 +13029,8 @@ function nullableTypeAnnotation(typeAnnotation2) {
13100
13029
  typeAnnotation: typeAnnotation2,
13101
13030
  };
13102
13031
 
13103
- const defs = NODE_FIELDS.NullableTypeAnnotation;
13104
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13032
+ const defs2 = NODE_FIELDS.NullableTypeAnnotation;
13033
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13105
13034
  return node;
13106
13035
  }
13107
13036
 
@@ -13111,8 +13040,8 @@ function numberLiteralTypeAnnotation(value) {
13111
13040
  value,
13112
13041
  };
13113
13042
 
13114
- const defs = NODE_FIELDS.NumberLiteralTypeAnnotation;
13115
- validate(defs.value, node, 'value', value);
13043
+ const defs2 = NODE_FIELDS.NumberLiteralTypeAnnotation;
13044
+ validate(defs2.value, node, 'value', value);
13116
13045
  return node;
13117
13046
  }
13118
13047
 
@@ -13132,12 +13061,12 @@ function objectTypeAnnotation(properties, indexers = [], callProperties = [], in
13132
13061
  exact,
13133
13062
  };
13134
13063
 
13135
- const defs = NODE_FIELDS.ObjectTypeAnnotation;
13136
- validate(defs.properties, node, 'properties', properties, 1);
13137
- validate(defs.indexers, node, 'indexers', indexers, 1);
13138
- validate(defs.callProperties, node, 'callProperties', callProperties, 1);
13139
- validate(defs.internalSlots, node, 'internalSlots', internalSlots, 1);
13140
- validate(defs.exact, node, 'exact', exact);
13064
+ const defs2 = NODE_FIELDS.ObjectTypeAnnotation;
13065
+ validate(defs2.properties, node, 'properties', properties, 1);
13066
+ validate(defs2.indexers, node, 'indexers', indexers, 1);
13067
+ validate(defs2.callProperties, node, 'callProperties', callProperties, 1);
13068
+ validate(defs2.internalSlots, node, 'internalSlots', internalSlots, 1);
13069
+ validate(defs2.exact, node, 'exact', exact);
13141
13070
  return node;
13142
13071
  }
13143
13072
 
@@ -13151,12 +13080,12 @@ function objectTypeInternalSlot(id, value, optional, _static, method) {
13151
13080
  method,
13152
13081
  };
13153
13082
 
13154
- const defs = NODE_FIELDS.ObjectTypeInternalSlot;
13155
- validate(defs.id, node, 'id', id, 1);
13156
- validate(defs.value, node, 'value', value, 1);
13157
- validate(defs.optional, node, 'optional', optional);
13158
- validate(defs.static, node, 'static', _static);
13159
- validate(defs.method, node, 'method', method);
13083
+ const defs2 = NODE_FIELDS.ObjectTypeInternalSlot;
13084
+ validate(defs2.id, node, 'id', id, 1);
13085
+ validate(defs2.value, node, 'value', value, 1);
13086
+ validate(defs2.optional, node, 'optional', optional);
13087
+ validate(defs2.static, node, 'static', _static);
13088
+ validate(defs2.method, node, 'method', method);
13160
13089
  return node;
13161
13090
  }
13162
13091
 
@@ -13167,8 +13096,8 @@ function objectTypeCallProperty(value) {
13167
13096
  static: false,
13168
13097
  };
13169
13098
 
13170
- const defs = NODE_FIELDS.ObjectTypeCallProperty;
13171
- validate(defs.value, node, 'value', value, 1);
13099
+ const defs2 = NODE_FIELDS.ObjectTypeCallProperty;
13100
+ validate(defs2.value, node, 'value', value, 1);
13172
13101
  return node;
13173
13102
  }
13174
13103
 
@@ -13182,11 +13111,11 @@ function objectTypeIndexer(id = null, key, value, variance2 = null) {
13182
13111
  static: false,
13183
13112
  };
13184
13113
 
13185
- const defs = NODE_FIELDS.ObjectTypeIndexer;
13186
- validate(defs.id, node, 'id', id, 1);
13187
- validate(defs.key, node, 'key', key, 1);
13188
- validate(defs.value, node, 'value', value, 1);
13189
- validate(defs.variance, node, 'variance', variance2, 1);
13114
+ const defs2 = NODE_FIELDS.ObjectTypeIndexer;
13115
+ validate(defs2.id, node, 'id', id, 1);
13116
+ validate(defs2.key, node, 'key', key, 1);
13117
+ validate(defs2.value, node, 'value', value, 1);
13118
+ validate(defs2.variance, node, 'variance', variance2, 1);
13190
13119
  return node;
13191
13120
  }
13192
13121
 
@@ -13203,10 +13132,10 @@ function objectTypeProperty(key, value, variance2 = null) {
13203
13132
  static: false,
13204
13133
  };
13205
13134
 
13206
- const defs = NODE_FIELDS.ObjectTypeProperty;
13207
- validate(defs.key, node, 'key', key, 1);
13208
- validate(defs.value, node, 'value', value, 1);
13209
- validate(defs.variance, node, 'variance', variance2, 1);
13135
+ const defs2 = NODE_FIELDS.ObjectTypeProperty;
13136
+ validate(defs2.key, node, 'key', key, 1);
13137
+ validate(defs2.value, node, 'value', value, 1);
13138
+ validate(defs2.variance, node, 'variance', variance2, 1);
13210
13139
  return node;
13211
13140
  }
13212
13141
 
@@ -13216,8 +13145,8 @@ function objectTypeSpreadProperty(argument) {
13216
13145
  argument,
13217
13146
  };
13218
13147
 
13219
- const defs = NODE_FIELDS.ObjectTypeSpreadProperty;
13220
- validate(defs.argument, node, 'argument', argument, 1);
13148
+ const defs2 = NODE_FIELDS.ObjectTypeSpreadProperty;
13149
+ validate(defs2.argument, node, 'argument', argument, 1);
13221
13150
  return node;
13222
13151
  }
13223
13152
 
@@ -13230,11 +13159,11 @@ function opaqueType(id, typeParameters = null, supertype = null, impltype) {
13230
13159
  impltype,
13231
13160
  };
13232
13161
 
13233
- const defs = NODE_FIELDS.OpaqueType;
13234
- validate(defs.id, node, 'id', id, 1);
13235
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13236
- validate(defs.supertype, node, 'supertype', supertype, 1);
13237
- validate(defs.impltype, node, 'impltype', impltype, 1);
13162
+ const defs2 = NODE_FIELDS.OpaqueType;
13163
+ validate(defs2.id, node, 'id', id, 1);
13164
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13165
+ validate(defs2.supertype, node, 'supertype', supertype, 1);
13166
+ validate(defs2.impltype, node, 'impltype', impltype, 1);
13238
13167
  return node;
13239
13168
  }
13240
13169
 
@@ -13245,9 +13174,9 @@ function qualifiedTypeIdentifier(id, qualification) {
13245
13174
  qualification,
13246
13175
  };
13247
13176
 
13248
- const defs = NODE_FIELDS.QualifiedTypeIdentifier;
13249
- validate(defs.id, node, 'id', id, 1);
13250
- validate(defs.qualification, node, 'qualification', qualification, 1);
13177
+ const defs2 = NODE_FIELDS.QualifiedTypeIdentifier;
13178
+ validate(defs2.id, node, 'id', id, 1);
13179
+ validate(defs2.qualification, node, 'qualification', qualification, 1);
13251
13180
  return node;
13252
13181
  }
13253
13182
 
@@ -13257,8 +13186,8 @@ function stringLiteralTypeAnnotation(value) {
13257
13186
  value,
13258
13187
  };
13259
13188
 
13260
- const defs = NODE_FIELDS.StringLiteralTypeAnnotation;
13261
- validate(defs.value, node, 'value', value);
13189
+ const defs2 = NODE_FIELDS.StringLiteralTypeAnnotation;
13190
+ validate(defs2.value, node, 'value', value);
13262
13191
  return node;
13263
13192
  }
13264
13193
 
@@ -13286,8 +13215,8 @@ function tupleTypeAnnotation(types2) {
13286
13215
  types: types2,
13287
13216
  };
13288
13217
 
13289
- const defs = NODE_FIELDS.TupleTypeAnnotation;
13290
- validate(defs.types, node, 'types', types2, 1);
13218
+ const defs2 = NODE_FIELDS.TupleTypeAnnotation;
13219
+ validate(defs2.types, node, 'types', types2, 1);
13291
13220
  return node;
13292
13221
  }
13293
13222
 
@@ -13297,8 +13226,8 @@ function typeofTypeAnnotation(argument) {
13297
13226
  argument,
13298
13227
  };
13299
13228
 
13300
- const defs = NODE_FIELDS.TypeofTypeAnnotation;
13301
- validate(defs.argument, node, 'argument', argument, 1);
13229
+ const defs2 = NODE_FIELDS.TypeofTypeAnnotation;
13230
+ validate(defs2.argument, node, 'argument', argument, 1);
13302
13231
  return node;
13303
13232
  }
13304
13233
 
@@ -13310,10 +13239,10 @@ function typeAlias(id, typeParameters = null, right) {
13310
13239
  right,
13311
13240
  };
13312
13241
 
13313
- const defs = NODE_FIELDS.TypeAlias;
13314
- validate(defs.id, node, 'id', id, 1);
13315
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13316
- validate(defs.right, node, 'right', right, 1);
13242
+ const defs2 = NODE_FIELDS.TypeAlias;
13243
+ validate(defs2.id, node, 'id', id, 1);
13244
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13245
+ validate(defs2.right, node, 'right', right, 1);
13317
13246
  return node;
13318
13247
  }
13319
13248
 
@@ -13323,8 +13252,8 @@ function typeAnnotation(typeAnnotation2) {
13323
13252
  typeAnnotation: typeAnnotation2,
13324
13253
  };
13325
13254
 
13326
- const defs = NODE_FIELDS.TypeAnnotation;
13327
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13255
+ const defs2 = NODE_FIELDS.TypeAnnotation;
13256
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13328
13257
  return node;
13329
13258
  }
13330
13259
 
@@ -13335,9 +13264,9 @@ function typeCastExpression(expression2, typeAnnotation2) {
13335
13264
  typeAnnotation: typeAnnotation2,
13336
13265
  };
13337
13266
 
13338
- const defs = NODE_FIELDS.TypeCastExpression;
13339
- validate(defs.expression, node, 'expression', expression2, 1);
13340
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13267
+ const defs2 = NODE_FIELDS.TypeCastExpression;
13268
+ validate(defs2.expression, node, 'expression', expression2, 1);
13269
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13341
13270
  return node;
13342
13271
  }
13343
13272
 
@@ -13350,11 +13279,11 @@ function typeParameter(name, bound = null, _default = null, variance2 = null) {
13350
13279
  variance: variance2,
13351
13280
  };
13352
13281
 
13353
- const defs = NODE_FIELDS.TypeParameter;
13354
- validate(defs.name, node, 'name', name);
13355
- validate(defs.bound, node, 'bound', bound, 1);
13356
- validate(defs.default, node, 'default', _default, 1);
13357
- validate(defs.variance, node, 'variance', variance2, 1);
13282
+ const defs2 = NODE_FIELDS.TypeParameter;
13283
+ validate(defs2.name, node, 'name', name);
13284
+ validate(defs2.bound, node, 'bound', bound, 1);
13285
+ validate(defs2.default, node, 'default', _default, 1);
13286
+ validate(defs2.variance, node, 'variance', variance2, 1);
13358
13287
  return node;
13359
13288
  }
13360
13289
 
@@ -13364,8 +13293,8 @@ function typeParameterDeclaration(params) {
13364
13293
  params,
13365
13294
  };
13366
13295
 
13367
- const defs = NODE_FIELDS.TypeParameterDeclaration;
13368
- validate(defs.params, node, 'params', params, 1);
13296
+ const defs2 = NODE_FIELDS.TypeParameterDeclaration;
13297
+ validate(defs2.params, node, 'params', params, 1);
13369
13298
  return node;
13370
13299
  }
13371
13300
 
@@ -13375,8 +13304,8 @@ function typeParameterInstantiation(params) {
13375
13304
  params,
13376
13305
  };
13377
13306
 
13378
- const defs = NODE_FIELDS.TypeParameterInstantiation;
13379
- validate(defs.params, node, 'params', params, 1);
13307
+ const defs2 = NODE_FIELDS.TypeParameterInstantiation;
13308
+ validate(defs2.params, node, 'params', params, 1);
13380
13309
  return node;
13381
13310
  }
13382
13311
 
@@ -13386,8 +13315,8 @@ function unionTypeAnnotation(types2) {
13386
13315
  types: types2,
13387
13316
  };
13388
13317
 
13389
- const defs = NODE_FIELDS.UnionTypeAnnotation;
13390
- validate(defs.types, node, 'types', types2, 1);
13318
+ const defs2 = NODE_FIELDS.UnionTypeAnnotation;
13319
+ validate(defs2.types, node, 'types', types2, 1);
13391
13320
  return node;
13392
13321
  }
13393
13322
 
@@ -13397,8 +13326,8 @@ function variance(kind) {
13397
13326
  kind,
13398
13327
  };
13399
13328
 
13400
- const defs = NODE_FIELDS.Variance;
13401
- validate(defs.kind, node, 'kind', kind);
13329
+ const defs2 = NODE_FIELDS.Variance;
13330
+ validate(defs2.kind, node, 'kind', kind);
13402
13331
  return node;
13403
13332
  }
13404
13333
 
@@ -13415,9 +13344,9 @@ function enumDeclaration(id, body) {
13415
13344
  body,
13416
13345
  };
13417
13346
 
13418
- const defs = NODE_FIELDS.EnumDeclaration;
13419
- validate(defs.id, node, 'id', id, 1);
13420
- validate(defs.body, node, 'body', body, 1);
13347
+ const defs2 = NODE_FIELDS.EnumDeclaration;
13348
+ validate(defs2.id, node, 'id', id, 1);
13349
+ validate(defs2.body, node, 'body', body, 1);
13421
13350
  return node;
13422
13351
  }
13423
13352
 
@@ -13429,8 +13358,8 @@ function enumBooleanBody(members) {
13429
13358
  hasUnknownMembers: false,
13430
13359
  };
13431
13360
 
13432
- const defs = NODE_FIELDS.EnumBooleanBody;
13433
- validate(defs.members, node, 'members', members, 1);
13361
+ const defs2 = NODE_FIELDS.EnumBooleanBody;
13362
+ validate(defs2.members, node, 'members', members, 1);
13434
13363
  return node;
13435
13364
  }
13436
13365
 
@@ -13442,8 +13371,8 @@ function enumNumberBody(members) {
13442
13371
  hasUnknownMembers: false,
13443
13372
  };
13444
13373
 
13445
- const defs = NODE_FIELDS.EnumNumberBody;
13446
- validate(defs.members, node, 'members', members, 1);
13374
+ const defs2 = NODE_FIELDS.EnumNumberBody;
13375
+ validate(defs2.members, node, 'members', members, 1);
13447
13376
  return node;
13448
13377
  }
13449
13378
 
@@ -13455,8 +13384,8 @@ function enumStringBody(members) {
13455
13384
  hasUnknownMembers: false,
13456
13385
  };
13457
13386
 
13458
- const defs = NODE_FIELDS.EnumStringBody;
13459
- validate(defs.members, node, 'members', members, 1);
13387
+ const defs2 = NODE_FIELDS.EnumStringBody;
13388
+ validate(defs2.members, node, 'members', members, 1);
13460
13389
  return node;
13461
13390
  }
13462
13391
 
@@ -13467,8 +13396,8 @@ function enumSymbolBody(members) {
13467
13396
  hasUnknownMembers: false,
13468
13397
  };
13469
13398
 
13470
- const defs = NODE_FIELDS.EnumSymbolBody;
13471
- validate(defs.members, node, 'members', members, 1);
13399
+ const defs2 = NODE_FIELDS.EnumSymbolBody;
13400
+ validate(defs2.members, node, 'members', members, 1);
13472
13401
  return node;
13473
13402
  }
13474
13403
 
@@ -13479,9 +13408,9 @@ function enumBooleanMember(id, init) {
13479
13408
  init,
13480
13409
  };
13481
13410
 
13482
- const defs = NODE_FIELDS.EnumBooleanMember;
13483
- validate(defs.id, node, 'id', id, 1);
13484
- validate(defs.init, node, 'init', init, 1);
13411
+ const defs2 = NODE_FIELDS.EnumBooleanMember;
13412
+ validate(defs2.id, node, 'id', id, 1);
13413
+ validate(defs2.init, node, 'init', init, 1);
13485
13414
  return node;
13486
13415
  }
13487
13416
 
@@ -13492,9 +13421,9 @@ function enumNumberMember(id, init) {
13492
13421
  init,
13493
13422
  };
13494
13423
 
13495
- const defs = NODE_FIELDS.EnumNumberMember;
13496
- validate(defs.id, node, 'id', id, 1);
13497
- validate(defs.init, node, 'init', init, 1);
13424
+ const defs2 = NODE_FIELDS.EnumNumberMember;
13425
+ validate(defs2.id, node, 'id', id, 1);
13426
+ validate(defs2.init, node, 'init', init, 1);
13498
13427
  return node;
13499
13428
  }
13500
13429
 
@@ -13505,9 +13434,9 @@ function enumStringMember(id, init) {
13505
13434
  init,
13506
13435
  };
13507
13436
 
13508
- const defs = NODE_FIELDS.EnumStringMember;
13509
- validate(defs.id, node, 'id', id, 1);
13510
- validate(defs.init, node, 'init', init, 1);
13437
+ const defs2 = NODE_FIELDS.EnumStringMember;
13438
+ validate(defs2.id, node, 'id', id, 1);
13439
+ validate(defs2.init, node, 'init', init, 1);
13511
13440
  return node;
13512
13441
  }
13513
13442
 
@@ -13517,8 +13446,8 @@ function enumDefaultedMember(id) {
13517
13446
  id,
13518
13447
  };
13519
13448
 
13520
- const defs = NODE_FIELDS.EnumDefaultedMember;
13521
- validate(defs.id, node, 'id', id, 1);
13449
+ const defs2 = NODE_FIELDS.EnumDefaultedMember;
13450
+ validate(defs2.id, node, 'id', id, 1);
13522
13451
  return node;
13523
13452
  }
13524
13453
 
@@ -13529,9 +13458,9 @@ function indexedAccessType(objectType, indexType) {
13529
13458
  indexType,
13530
13459
  };
13531
13460
 
13532
- const defs = NODE_FIELDS.IndexedAccessType;
13533
- validate(defs.objectType, node, 'objectType', objectType, 1);
13534
- validate(defs.indexType, node, 'indexType', indexType, 1);
13461
+ const defs2 = NODE_FIELDS.IndexedAccessType;
13462
+ validate(defs2.objectType, node, 'objectType', objectType, 1);
13463
+ validate(defs2.indexType, node, 'indexType', indexType, 1);
13535
13464
  return node;
13536
13465
  }
13537
13466
 
@@ -13543,9 +13472,9 @@ function optionalIndexedAccessType(objectType, indexType) {
13543
13472
  optional: false,
13544
13473
  };
13545
13474
 
13546
- const defs = NODE_FIELDS.OptionalIndexedAccessType;
13547
- validate(defs.objectType, node, 'objectType', objectType, 1);
13548
- validate(defs.indexType, node, 'indexType', indexType, 1);
13475
+ const defs2 = NODE_FIELDS.OptionalIndexedAccessType;
13476
+ validate(defs2.objectType, node, 'objectType', objectType, 1);
13477
+ validate(defs2.indexType, node, 'indexType', indexType, 1);
13549
13478
  return node;
13550
13479
  }
13551
13480
 
@@ -13556,9 +13485,9 @@ function jsxAttribute(name, value = null) {
13556
13485
  value,
13557
13486
  };
13558
13487
 
13559
- const defs = NODE_FIELDS.JSXAttribute;
13560
- validate(defs.name, node, 'name', name, 1);
13561
- validate(defs.value, node, 'value', value, 1);
13488
+ const defs2 = NODE_FIELDS.JSXAttribute;
13489
+ validate(defs2.name, node, 'name', name, 1);
13490
+ validate(defs2.value, node, 'value', value, 1);
13562
13491
  return node;
13563
13492
  }
13564
13493
 
@@ -13568,8 +13497,8 @@ function jsxClosingElement(name) {
13568
13497
  name,
13569
13498
  };
13570
13499
 
13571
- const defs = NODE_FIELDS.JSXClosingElement;
13572
- validate(defs.name, node, 'name', name, 1);
13500
+ const defs2 = NODE_FIELDS.JSXClosingElement;
13501
+ validate(defs2.name, node, 'name', name, 1);
13573
13502
  return node;
13574
13503
  }
13575
13504
 
@@ -13581,10 +13510,10 @@ function jsxElement(openingElement, closingElement = null, children) {
13581
13510
  children,
13582
13511
  };
13583
13512
 
13584
- const defs = NODE_FIELDS.JSXElement;
13585
- validate(defs.openingElement, node, 'openingElement', openingElement, 1);
13586
- validate(defs.closingElement, node, 'closingElement', closingElement, 1);
13587
- validate(defs.children, node, 'children', children, 1);
13513
+ const defs2 = NODE_FIELDS.JSXElement;
13514
+ validate(defs2.openingElement, node, 'openingElement', openingElement, 1);
13515
+ validate(defs2.closingElement, node, 'closingElement', closingElement, 1);
13516
+ validate(defs2.children, node, 'children', children, 1);
13588
13517
  return node;
13589
13518
  }
13590
13519
 
@@ -13600,8 +13529,8 @@ function jsxExpressionContainer(expression2) {
13600
13529
  expression: expression2,
13601
13530
  };
13602
13531
 
13603
- const defs = NODE_FIELDS.JSXExpressionContainer;
13604
- validate(defs.expression, node, 'expression', expression2, 1);
13532
+ const defs2 = NODE_FIELDS.JSXExpressionContainer;
13533
+ validate(defs2.expression, node, 'expression', expression2, 1);
13605
13534
  return node;
13606
13535
  }
13607
13536
 
@@ -13611,8 +13540,8 @@ function jsxSpreadChild(expression2) {
13611
13540
  expression: expression2,
13612
13541
  };
13613
13542
 
13614
- const defs = NODE_FIELDS.JSXSpreadChild;
13615
- validate(defs.expression, node, 'expression', expression2, 1);
13543
+ const defs2 = NODE_FIELDS.JSXSpreadChild;
13544
+ validate(defs2.expression, node, 'expression', expression2, 1);
13616
13545
  return node;
13617
13546
  }
13618
13547
 
@@ -13622,8 +13551,8 @@ function jsxIdentifier(name) {
13622
13551
  name,
13623
13552
  };
13624
13553
 
13625
- const defs = NODE_FIELDS.JSXIdentifier;
13626
- validate(defs.name, node, 'name', name);
13554
+ const defs2 = NODE_FIELDS.JSXIdentifier;
13555
+ validate(defs2.name, node, 'name', name);
13627
13556
  return node;
13628
13557
  }
13629
13558
 
@@ -13634,9 +13563,9 @@ function jsxMemberExpression(object, property) {
13634
13563
  property,
13635
13564
  };
13636
13565
 
13637
- const defs = NODE_FIELDS.JSXMemberExpression;
13638
- validate(defs.object, node, 'object', object, 1);
13639
- validate(defs.property, node, 'property', property, 1);
13566
+ const defs2 = NODE_FIELDS.JSXMemberExpression;
13567
+ validate(defs2.object, node, 'object', object, 1);
13568
+ validate(defs2.property, node, 'property', property, 1);
13640
13569
  return node;
13641
13570
  }
13642
13571
 
@@ -13647,9 +13576,9 @@ function jsxNamespacedName(namespace, name) {
13647
13576
  name,
13648
13577
  };
13649
13578
 
13650
- const defs = NODE_FIELDS.JSXNamespacedName;
13651
- validate(defs.namespace, node, 'namespace', namespace, 1);
13652
- validate(defs.name, node, 'name', name, 1);
13579
+ const defs2 = NODE_FIELDS.JSXNamespacedName;
13580
+ validate(defs2.namespace, node, 'namespace', namespace, 1);
13581
+ validate(defs2.name, node, 'name', name, 1);
13653
13582
  return node;
13654
13583
  }
13655
13584
 
@@ -13661,10 +13590,10 @@ function jsxOpeningElement(name, attributes, selfClosing = false) {
13661
13590
  selfClosing,
13662
13591
  };
13663
13592
 
13664
- const defs = NODE_FIELDS.JSXOpeningElement;
13665
- validate(defs.name, node, 'name', name, 1);
13666
- validate(defs.attributes, node, 'attributes', attributes, 1);
13667
- validate(defs.selfClosing, node, 'selfClosing', selfClosing);
13593
+ const defs2 = NODE_FIELDS.JSXOpeningElement;
13594
+ validate(defs2.name, node, 'name', name, 1);
13595
+ validate(defs2.attributes, node, 'attributes', attributes, 1);
13596
+ validate(defs2.selfClosing, node, 'selfClosing', selfClosing);
13668
13597
  return node;
13669
13598
  }
13670
13599
 
@@ -13674,8 +13603,8 @@ function jsxSpreadAttribute(argument) {
13674
13603
  argument,
13675
13604
  };
13676
13605
 
13677
- const defs = NODE_FIELDS.JSXSpreadAttribute;
13678
- validate(defs.argument, node, 'argument', argument, 1);
13606
+ const defs2 = NODE_FIELDS.JSXSpreadAttribute;
13607
+ validate(defs2.argument, node, 'argument', argument, 1);
13679
13608
  return node;
13680
13609
  }
13681
13610
 
@@ -13685,8 +13614,8 @@ function jsxText(value) {
13685
13614
  value,
13686
13615
  };
13687
13616
 
13688
- const defs = NODE_FIELDS.JSXText;
13689
- validate(defs.value, node, 'value', value);
13617
+ const defs2 = NODE_FIELDS.JSXText;
13618
+ validate(defs2.value, node, 'value', value);
13690
13619
  return node;
13691
13620
  }
13692
13621
 
@@ -13698,10 +13627,10 @@ function jsxFragment(openingFragment, closingFragment, children) {
13698
13627
  children,
13699
13628
  };
13700
13629
 
13701
- const defs = NODE_FIELDS.JSXFragment;
13702
- validate(defs.openingFragment, node, 'openingFragment', openingFragment, 1);
13703
- validate(defs.closingFragment, node, 'closingFragment', closingFragment, 1);
13704
- validate(defs.children, node, 'children', children, 1);
13630
+ const defs2 = NODE_FIELDS.JSXFragment;
13631
+ validate(defs2.openingFragment, node, 'openingFragment', openingFragment, 1);
13632
+ validate(defs2.closingFragment, node, 'closingFragment', closingFragment, 1);
13633
+ validate(defs2.children, node, 'children', children, 1);
13705
13634
  return node;
13706
13635
  }
13707
13636
 
@@ -13724,9 +13653,9 @@ function placeholder(expectedNode, name) {
13724
13653
  name,
13725
13654
  };
13726
13655
 
13727
- const defs = NODE_FIELDS.Placeholder;
13728
- validate(defs.expectedNode, node, 'expectedNode', expectedNode);
13729
- validate(defs.name, node, 'name', name, 1);
13656
+ const defs2 = NODE_FIELDS.Placeholder;
13657
+ validate(defs2.expectedNode, node, 'expectedNode', expectedNode);
13658
+ validate(defs2.name, node, 'name', name, 1);
13730
13659
  return node;
13731
13660
  }
13732
13661
 
@@ -13736,8 +13665,8 @@ function v8IntrinsicIdentifier(name) {
13736
13665
  name,
13737
13666
  };
13738
13667
 
13739
- const defs = NODE_FIELDS.V8IntrinsicIdentifier;
13740
- validate(defs.name, node, 'name', name);
13668
+ const defs2 = NODE_FIELDS.V8IntrinsicIdentifier;
13669
+ validate(defs2.name, node, 'name', name);
13741
13670
  return node;
13742
13671
  }
13743
13672
 
@@ -13754,9 +13683,9 @@ function bindExpression(object, callee) {
13754
13683
  callee,
13755
13684
  };
13756
13685
 
13757
- const defs = NODE_FIELDS.BindExpression;
13758
- validate(defs.object, node, 'object', object, 1);
13759
- validate(defs.callee, node, 'callee', callee, 1);
13686
+ const defs2 = NODE_FIELDS.BindExpression;
13687
+ validate(defs2.object, node, 'object', object, 1);
13688
+ validate(defs2.callee, node, 'callee', callee, 1);
13760
13689
  return node;
13761
13690
  }
13762
13691
 
@@ -13771,13 +13700,13 @@ function classAccessorProperty(key, value = null, typeAnnotation2 = null, decora
13771
13700
  static: _static,
13772
13701
  };
13773
13702
 
13774
- const defs = NODE_FIELDS.ClassAccessorProperty;
13775
- validate(defs.key, node, 'key', key, 1);
13776
- validate(defs.value, node, 'value', value, 1);
13777
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13778
- validate(defs.decorators, node, 'decorators', decorators, 1);
13779
- validate(defs.computed, node, 'computed', computed);
13780
- validate(defs.static, node, 'static', _static);
13703
+ const defs2 = NODE_FIELDS.ClassAccessorProperty;
13704
+ validate(defs2.key, node, 'key', key, 1);
13705
+ validate(defs2.value, node, 'value', value, 1);
13706
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13707
+ validate(defs2.decorators, node, 'decorators', decorators, 1);
13708
+ validate(defs2.computed, node, 'computed', computed);
13709
+ validate(defs2.static, node, 'static', _static);
13781
13710
  return node;
13782
13711
  }
13783
13712
 
@@ -13787,8 +13716,8 @@ function decorator(expression2) {
13787
13716
  expression: expression2,
13788
13717
  };
13789
13718
 
13790
- const defs = NODE_FIELDS.Decorator;
13791
- validate(defs.expression, node, 'expression', expression2, 1);
13719
+ const defs2 = NODE_FIELDS.Decorator;
13720
+ validate(defs2.expression, node, 'expression', expression2, 1);
13792
13721
  return node;
13793
13722
  }
13794
13723
 
@@ -13799,9 +13728,9 @@ function doExpression(body, async = false) {
13799
13728
  async,
13800
13729
  };
13801
13730
 
13802
- const defs = NODE_FIELDS.DoExpression;
13803
- validate(defs.body, node, 'body', body, 1);
13804
- validate(defs.async, node, 'async', async);
13731
+ const defs2 = NODE_FIELDS.DoExpression;
13732
+ validate(defs2.body, node, 'body', body, 1);
13733
+ validate(defs2.async, node, 'async', async);
13805
13734
  return node;
13806
13735
  }
13807
13736
 
@@ -13811,8 +13740,8 @@ function exportDefaultSpecifier(exported) {
13811
13740
  exported,
13812
13741
  };
13813
13742
 
13814
- const defs = NODE_FIELDS.ExportDefaultSpecifier;
13815
- validate(defs.exported, node, 'exported', exported, 1);
13743
+ const defs2 = NODE_FIELDS.ExportDefaultSpecifier;
13744
+ validate(defs2.exported, node, 'exported', exported, 1);
13816
13745
  return node;
13817
13746
  }
13818
13747
 
@@ -13822,8 +13751,8 @@ function moduleExpression(body) {
13822
13751
  body,
13823
13752
  };
13824
13753
 
13825
- const defs = NODE_FIELDS.ModuleExpression;
13826
- validate(defs.body, node, 'body', body, 1);
13754
+ const defs2 = NODE_FIELDS.ModuleExpression;
13755
+ validate(defs2.body, node, 'body', body, 1);
13827
13756
  return node;
13828
13757
  }
13829
13758
 
@@ -13845,8 +13774,8 @@ function tsParameterProperty(parameter) {
13845
13774
  parameter,
13846
13775
  };
13847
13776
 
13848
- const defs = NODE_FIELDS.TSParameterProperty;
13849
- validate(defs.parameter, node, 'parameter', parameter, 1);
13777
+ const defs2 = NODE_FIELDS.TSParameterProperty;
13778
+ validate(defs2.parameter, node, 'parameter', parameter, 1);
13850
13779
  return node;
13851
13780
  }
13852
13781
 
@@ -13861,11 +13790,11 @@ function tsDeclareFunction(id = null, typeParameters = null, params, returnType
13861
13790
  generator: false,
13862
13791
  };
13863
13792
 
13864
- const defs = NODE_FIELDS.TSDeclareFunction;
13865
- validate(defs.id, node, 'id', id, 1);
13866
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13867
- validate(defs.params, node, 'params', params, 1);
13868
- validate(defs.returnType, node, 'returnType', returnType, 1);
13793
+ const defs2 = NODE_FIELDS.TSDeclareFunction;
13794
+ validate(defs2.id, node, 'id', id, 1);
13795
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13796
+ validate(defs2.params, node, 'params', params, 1);
13797
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
13869
13798
  return node;
13870
13799
  }
13871
13800
 
@@ -13884,12 +13813,12 @@ function tsDeclareMethod(decorators = null, key, typeParameters = null, params,
13884
13813
  static: false,
13885
13814
  };
13886
13815
 
13887
- const defs = NODE_FIELDS.TSDeclareMethod;
13888
- validate(defs.decorators, node, 'decorators', decorators, 1);
13889
- validate(defs.key, node, 'key', key, 1);
13890
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13891
- validate(defs.params, node, 'params', params, 1);
13892
- validate(defs.returnType, node, 'returnType', returnType, 1);
13816
+ const defs2 = NODE_FIELDS.TSDeclareMethod;
13817
+ validate(defs2.decorators, node, 'decorators', decorators, 1);
13818
+ validate(defs2.key, node, 'key', key, 1);
13819
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13820
+ validate(defs2.params, node, 'params', params, 1);
13821
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
13893
13822
  return node;
13894
13823
  }
13895
13824
 
@@ -13900,9 +13829,9 @@ function tsQualifiedName(left, right) {
13900
13829
  right,
13901
13830
  };
13902
13831
 
13903
- const defs = NODE_FIELDS.TSQualifiedName;
13904
- validate(defs.left, node, 'left', left, 1);
13905
- validate(defs.right, node, 'right', right, 1);
13832
+ const defs2 = NODE_FIELDS.TSQualifiedName;
13833
+ validate(defs2.left, node, 'left', left, 1);
13834
+ validate(defs2.right, node, 'right', right, 1);
13906
13835
  return node;
13907
13836
  }
13908
13837
 
@@ -13914,10 +13843,10 @@ function tsCallSignatureDeclaration(typeParameters = null, params, returnType =
13914
13843
  returnType,
13915
13844
  };
13916
13845
 
13917
- const defs = NODE_FIELDS.TSCallSignatureDeclaration;
13918
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13919
- validate(defs.params, node, 'params', params, 1);
13920
- validate(defs.returnType, node, 'returnType', returnType, 1);
13846
+ const defs2 = NODE_FIELDS.TSCallSignatureDeclaration;
13847
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13848
+ validate(defs2.params, node, 'params', params, 1);
13849
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
13921
13850
  return node;
13922
13851
  }
13923
13852
 
@@ -13929,10 +13858,10 @@ function tsConstructSignatureDeclaration(typeParameters = null, params, returnTy
13929
13858
  returnType,
13930
13859
  };
13931
13860
 
13932
- const defs = NODE_FIELDS.TSConstructSignatureDeclaration;
13933
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13934
- validate(defs.params, node, 'params', params, 1);
13935
- validate(defs.returnType, node, 'returnType', returnType, 1);
13861
+ const defs2 = NODE_FIELDS.TSConstructSignatureDeclaration;
13862
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13863
+ validate(defs2.params, node, 'params', params, 1);
13864
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
13936
13865
  return node;
13937
13866
  }
13938
13867
 
@@ -13944,9 +13873,9 @@ function tsPropertySignature(key, typeAnnotation2 = null) {
13944
13873
  computed: false,
13945
13874
  };
13946
13875
 
13947
- const defs = NODE_FIELDS.TSPropertySignature;
13948
- validate(defs.key, node, 'key', key, 1);
13949
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13876
+ const defs2 = NODE_FIELDS.TSPropertySignature;
13877
+ validate(defs2.key, node, 'key', key, 1);
13878
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13950
13879
  return node;
13951
13880
  }
13952
13881
 
@@ -13961,11 +13890,11 @@ function tsMethodSignature(key, typeParameters = null, params, returnType = null
13961
13890
  kind: 'method',
13962
13891
  };
13963
13892
 
13964
- const defs = NODE_FIELDS.TSMethodSignature;
13965
- validate(defs.key, node, 'key', key, 1);
13966
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
13967
- validate(defs.params, node, 'params', params, 1);
13968
- validate(defs.returnType, node, 'returnType', returnType, 1);
13893
+ const defs2 = NODE_FIELDS.TSMethodSignature;
13894
+ validate(defs2.key, node, 'key', key, 1);
13895
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
13896
+ validate(defs2.params, node, 'params', params, 1);
13897
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
13969
13898
  return node;
13970
13899
  }
13971
13900
 
@@ -13976,9 +13905,9 @@ function tsIndexSignature(parameters, typeAnnotation2 = null) {
13976
13905
  typeAnnotation: typeAnnotation2,
13977
13906
  };
13978
13907
 
13979
- const defs = NODE_FIELDS.TSIndexSignature;
13980
- validate(defs.parameters, node, 'parameters', parameters, 1);
13981
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13908
+ const defs2 = NODE_FIELDS.TSIndexSignature;
13909
+ validate(defs2.parameters, node, 'parameters', parameters, 1);
13910
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
13982
13911
  return node;
13983
13912
  }
13984
13913
 
@@ -14074,10 +14003,10 @@ function tsFunctionType(typeParameters = null, params, returnType = null) {
14074
14003
  returnType,
14075
14004
  };
14076
14005
 
14077
- const defs = NODE_FIELDS.TSFunctionType;
14078
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
14079
- validate(defs.params, node, 'params', params, 1);
14080
- validate(defs.returnType, node, 'returnType', returnType, 1);
14006
+ const defs2 = NODE_FIELDS.TSFunctionType;
14007
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
14008
+ validate(defs2.params, node, 'params', params, 1);
14009
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
14081
14010
  return node;
14082
14011
  }
14083
14012
 
@@ -14089,10 +14018,10 @@ function tsConstructorType(typeParameters = null, params, returnType = null) {
14089
14018
  returnType,
14090
14019
  };
14091
14020
 
14092
- const defs = NODE_FIELDS.TSConstructorType;
14093
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
14094
- validate(defs.params, node, 'params', params, 1);
14095
- validate(defs.returnType, node, 'returnType', returnType, 1);
14021
+ const defs2 = NODE_FIELDS.TSConstructorType;
14022
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
14023
+ validate(defs2.params, node, 'params', params, 1);
14024
+ validate(defs2.returnType, node, 'returnType', returnType, 1);
14096
14025
  return node;
14097
14026
  }
14098
14027
 
@@ -14103,9 +14032,9 @@ function tsTypeReference(typeName, typeArguments = null) {
14103
14032
  typeArguments,
14104
14033
  };
14105
14034
 
14106
- const defs = NODE_FIELDS.TSTypeReference;
14107
- validate(defs.typeName, node, 'typeName', typeName, 1);
14108
- validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
14035
+ const defs2 = NODE_FIELDS.TSTypeReference;
14036
+ validate(defs2.typeName, node, 'typeName', typeName, 1);
14037
+ validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
14109
14038
  return node;
14110
14039
  }
14111
14040
 
@@ -14117,10 +14046,10 @@ function tsTypePredicate(parameterName, typeAnnotation2 = null, asserts = null)
14117
14046
  asserts,
14118
14047
  };
14119
14048
 
14120
- const defs = NODE_FIELDS.TSTypePredicate;
14121
- validate(defs.parameterName, node, 'parameterName', parameterName, 1);
14122
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14123
- validate(defs.asserts, node, 'asserts', asserts);
14049
+ const defs2 = NODE_FIELDS.TSTypePredicate;
14050
+ validate(defs2.parameterName, node, 'parameterName', parameterName, 1);
14051
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14052
+ validate(defs2.asserts, node, 'asserts', asserts);
14124
14053
  return node;
14125
14054
  }
14126
14055
 
@@ -14131,9 +14060,9 @@ function tsTypeQuery(exprName, typeArguments = null) {
14131
14060
  typeArguments,
14132
14061
  };
14133
14062
 
14134
- const defs = NODE_FIELDS.TSTypeQuery;
14135
- validate(defs.exprName, node, 'exprName', exprName, 1);
14136
- validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
14063
+ const defs2 = NODE_FIELDS.TSTypeQuery;
14064
+ validate(defs2.exprName, node, 'exprName', exprName, 1);
14065
+ validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
14137
14066
  return node;
14138
14067
  }
14139
14068
 
@@ -14143,8 +14072,8 @@ function tsTypeLiteral(members) {
14143
14072
  members,
14144
14073
  };
14145
14074
 
14146
- const defs = NODE_FIELDS.TSTypeLiteral;
14147
- validate(defs.members, node, 'members', members, 1);
14075
+ const defs2 = NODE_FIELDS.TSTypeLiteral;
14076
+ validate(defs2.members, node, 'members', members, 1);
14148
14077
  return node;
14149
14078
  }
14150
14079
 
@@ -14154,8 +14083,8 @@ function tsArrayType(elementType) {
14154
14083
  elementType,
14155
14084
  };
14156
14085
 
14157
- const defs = NODE_FIELDS.TSArrayType;
14158
- validate(defs.elementType, node, 'elementType', elementType, 1);
14086
+ const defs2 = NODE_FIELDS.TSArrayType;
14087
+ validate(defs2.elementType, node, 'elementType', elementType, 1);
14159
14088
  return node;
14160
14089
  }
14161
14090
 
@@ -14165,8 +14094,8 @@ function tsTupleType(elementTypes) {
14165
14094
  elementTypes,
14166
14095
  };
14167
14096
 
14168
- const defs = NODE_FIELDS.TSTupleType;
14169
- validate(defs.elementTypes, node, 'elementTypes', elementTypes, 1);
14097
+ const defs2 = NODE_FIELDS.TSTupleType;
14098
+ validate(defs2.elementTypes, node, 'elementTypes', elementTypes, 1);
14170
14099
  return node;
14171
14100
  }
14172
14101
 
@@ -14176,8 +14105,8 @@ function tsOptionalType(typeAnnotation2) {
14176
14105
  typeAnnotation: typeAnnotation2,
14177
14106
  };
14178
14107
 
14179
- const defs = NODE_FIELDS.TSOptionalType;
14180
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14108
+ const defs2 = NODE_FIELDS.TSOptionalType;
14109
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14181
14110
  return node;
14182
14111
  }
14183
14112
 
@@ -14187,8 +14116,8 @@ function tsRestType(typeAnnotation2) {
14187
14116
  typeAnnotation: typeAnnotation2,
14188
14117
  };
14189
14118
 
14190
- const defs = NODE_FIELDS.TSRestType;
14191
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14119
+ const defs2 = NODE_FIELDS.TSRestType;
14120
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14192
14121
  return node;
14193
14122
  }
14194
14123
 
@@ -14200,10 +14129,10 @@ function tsNamedTupleMember(label, elementType, optional = false) {
14200
14129
  optional,
14201
14130
  };
14202
14131
 
14203
- const defs = NODE_FIELDS.TSNamedTupleMember;
14204
- validate(defs.label, node, 'label', label, 1);
14205
- validate(defs.elementType, node, 'elementType', elementType, 1);
14206
- validate(defs.optional, node, 'optional', optional);
14132
+ const defs2 = NODE_FIELDS.TSNamedTupleMember;
14133
+ validate(defs2.label, node, 'label', label, 1);
14134
+ validate(defs2.elementType, node, 'elementType', elementType, 1);
14135
+ validate(defs2.optional, node, 'optional', optional);
14207
14136
  return node;
14208
14137
  }
14209
14138
 
@@ -14213,8 +14142,8 @@ function tsUnionType(types2) {
14213
14142
  types: types2,
14214
14143
  };
14215
14144
 
14216
- const defs = NODE_FIELDS.TSUnionType;
14217
- validate(defs.types, node, 'types', types2, 1);
14145
+ const defs2 = NODE_FIELDS.TSUnionType;
14146
+ validate(defs2.types, node, 'types', types2, 1);
14218
14147
  return node;
14219
14148
  }
14220
14149
 
@@ -14224,8 +14153,8 @@ function tsIntersectionType(types2) {
14224
14153
  types: types2,
14225
14154
  };
14226
14155
 
14227
- const defs = NODE_FIELDS.TSIntersectionType;
14228
- validate(defs.types, node, 'types', types2, 1);
14156
+ const defs2 = NODE_FIELDS.TSIntersectionType;
14157
+ validate(defs2.types, node, 'types', types2, 1);
14229
14158
  return node;
14230
14159
  }
14231
14160
 
@@ -14238,11 +14167,11 @@ function tsConditionalType(checkType, extendsType, trueType, falseType) {
14238
14167
  falseType,
14239
14168
  };
14240
14169
 
14241
- const defs = NODE_FIELDS.TSConditionalType;
14242
- validate(defs.checkType, node, 'checkType', checkType, 1);
14243
- validate(defs.extendsType, node, 'extendsType', extendsType, 1);
14244
- validate(defs.trueType, node, 'trueType', trueType, 1);
14245
- validate(defs.falseType, node, 'falseType', falseType, 1);
14170
+ const defs2 = NODE_FIELDS.TSConditionalType;
14171
+ validate(defs2.checkType, node, 'checkType', checkType, 1);
14172
+ validate(defs2.extendsType, node, 'extendsType', extendsType, 1);
14173
+ validate(defs2.trueType, node, 'trueType', trueType, 1);
14174
+ validate(defs2.falseType, node, 'falseType', falseType, 1);
14246
14175
  return node;
14247
14176
  }
14248
14177
 
@@ -14252,8 +14181,8 @@ function tsInferType(typeParameter2) {
14252
14181
  typeParameter: typeParameter2,
14253
14182
  };
14254
14183
 
14255
- const defs = NODE_FIELDS.TSInferType;
14256
- validate(defs.typeParameter, node, 'typeParameter', typeParameter2, 1);
14184
+ const defs2 = NODE_FIELDS.TSInferType;
14185
+ validate(defs2.typeParameter, node, 'typeParameter', typeParameter2, 1);
14257
14186
  return node;
14258
14187
  }
14259
14188
 
@@ -14263,8 +14192,8 @@ function tsParenthesizedType(typeAnnotation2) {
14263
14192
  typeAnnotation: typeAnnotation2,
14264
14193
  };
14265
14194
 
14266
- const defs = NODE_FIELDS.TSParenthesizedType;
14267
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14195
+ const defs2 = NODE_FIELDS.TSParenthesizedType;
14196
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14268
14197
  return node;
14269
14198
  }
14270
14199
 
@@ -14275,9 +14204,9 @@ function tsTypeOperator(typeAnnotation2, operator) {
14275
14204
  operator,
14276
14205
  };
14277
14206
 
14278
- const defs = NODE_FIELDS.TSTypeOperator;
14279
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14280
- validate(defs.operator, node, 'operator', operator);
14207
+ const defs2 = NODE_FIELDS.TSTypeOperator;
14208
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14209
+ validate(defs2.operator, node, 'operator', operator);
14281
14210
  return node;
14282
14211
  }
14283
14212
 
@@ -14288,9 +14217,9 @@ function tsIndexedAccessType(objectType, indexType) {
14288
14217
  indexType,
14289
14218
  };
14290
14219
 
14291
- const defs = NODE_FIELDS.TSIndexedAccessType;
14292
- validate(defs.objectType, node, 'objectType', objectType, 1);
14293
- validate(defs.indexType, node, 'indexType', indexType, 1);
14220
+ const defs2 = NODE_FIELDS.TSIndexedAccessType;
14221
+ validate(defs2.objectType, node, 'objectType', objectType, 1);
14222
+ validate(defs2.indexType, node, 'indexType', indexType, 1);
14294
14223
  return node;
14295
14224
  }
14296
14225
 
@@ -14303,11 +14232,11 @@ function tsMappedType(key, constraint, nameType = null, typeAnnotation2 = null)
14303
14232
  typeAnnotation: typeAnnotation2,
14304
14233
  };
14305
14234
 
14306
- const defs = NODE_FIELDS.TSMappedType;
14307
- validate(defs.key, node, 'key', key, 1);
14308
- validate(defs.constraint, node, 'constraint', constraint, 1);
14309
- validate(defs.nameType, node, 'nameType', nameType, 1);
14310
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14235
+ const defs2 = NODE_FIELDS.TSMappedType;
14236
+ validate(defs2.key, node, 'key', key, 1);
14237
+ validate(defs2.constraint, node, 'constraint', constraint, 1);
14238
+ validate(defs2.nameType, node, 'nameType', nameType, 1);
14239
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14311
14240
  return node;
14312
14241
  }
14313
14242
 
@@ -14318,9 +14247,9 @@ function tsTemplateLiteralType(quasis, types2) {
14318
14247
  types: types2,
14319
14248
  };
14320
14249
 
14321
- const defs = NODE_FIELDS.TSTemplateLiteralType;
14322
- validate(defs.quasis, node, 'quasis', quasis, 1);
14323
- validate(defs.types, node, 'types', types2, 1);
14250
+ const defs2 = NODE_FIELDS.TSTemplateLiteralType;
14251
+ validate(defs2.quasis, node, 'quasis', quasis, 1);
14252
+ validate(defs2.types, node, 'types', types2, 1);
14324
14253
  return node;
14325
14254
  }
14326
14255
 
@@ -14330,8 +14259,8 @@ function tsLiteralType(literal) {
14330
14259
  literal,
14331
14260
  };
14332
14261
 
14333
- const defs = NODE_FIELDS.TSLiteralType;
14334
- validate(defs.literal, node, 'literal', literal, 1);
14262
+ const defs2 = NODE_FIELDS.TSLiteralType;
14263
+ validate(defs2.literal, node, 'literal', literal, 1);
14335
14264
  return node;
14336
14265
  }
14337
14266
 
@@ -14342,9 +14271,9 @@ function tsClassImplements(expression2, typeArguments = null) {
14342
14271
  typeArguments,
14343
14272
  };
14344
14273
 
14345
- const defs = NODE_FIELDS.TSClassImplements;
14346
- validate(defs.expression, node, 'expression', expression2, 1);
14347
- validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
14274
+ const defs2 = NODE_FIELDS.TSClassImplements;
14275
+ validate(defs2.expression, node, 'expression', expression2, 1);
14276
+ validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
14348
14277
  return node;
14349
14278
  }
14350
14279
 
@@ -14355,9 +14284,9 @@ function tsInterfaceHeritage(expression2, typeArguments = null) {
14355
14284
  typeArguments,
14356
14285
  };
14357
14286
 
14358
- const defs = NODE_FIELDS.TSInterfaceHeritage;
14359
- validate(defs.expression, node, 'expression', expression2, 1);
14360
- validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
14287
+ const defs2 = NODE_FIELDS.TSInterfaceHeritage;
14288
+ validate(defs2.expression, node, 'expression', expression2, 1);
14289
+ validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
14361
14290
  return node;
14362
14291
  }
14363
14292
 
@@ -14370,11 +14299,11 @@ function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body
14370
14299
  body,
14371
14300
  };
14372
14301
 
14373
- const defs = NODE_FIELDS.TSInterfaceDeclaration;
14374
- validate(defs.id, node, 'id', id, 1);
14375
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
14376
- validate(defs.extends, node, 'extends', _extends, 1);
14377
- validate(defs.body, node, 'body', body, 1);
14302
+ const defs2 = NODE_FIELDS.TSInterfaceDeclaration;
14303
+ validate(defs2.id, node, 'id', id, 1);
14304
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
14305
+ validate(defs2.extends, node, 'extends', _extends, 1);
14306
+ validate(defs2.body, node, 'body', body, 1);
14378
14307
  return node;
14379
14308
  }
14380
14309
 
@@ -14384,8 +14313,8 @@ function tsInterfaceBody(body) {
14384
14313
  body,
14385
14314
  };
14386
14315
 
14387
- const defs = NODE_FIELDS.TSInterfaceBody;
14388
- validate(defs.body, node, 'body', body, 1);
14316
+ const defs2 = NODE_FIELDS.TSInterfaceBody;
14317
+ validate(defs2.body, node, 'body', body, 1);
14389
14318
  return node;
14390
14319
  }
14391
14320
 
@@ -14397,10 +14326,10 @@ function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation2) {
14397
14326
  typeAnnotation: typeAnnotation2,
14398
14327
  };
14399
14328
 
14400
- const defs = NODE_FIELDS.TSTypeAliasDeclaration;
14401
- validate(defs.id, node, 'id', id, 1);
14402
- validate(defs.typeParameters, node, 'typeParameters', typeParameters, 1);
14403
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14329
+ const defs2 = NODE_FIELDS.TSTypeAliasDeclaration;
14330
+ validate(defs2.id, node, 'id', id, 1);
14331
+ validate(defs2.typeParameters, node, 'typeParameters', typeParameters, 1);
14332
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14404
14333
  return node;
14405
14334
  }
14406
14335
 
@@ -14411,9 +14340,9 @@ function tsInstantiationExpression(expression2, typeArguments = null) {
14411
14340
  typeArguments,
14412
14341
  };
14413
14342
 
14414
- const defs = NODE_FIELDS.TSInstantiationExpression;
14415
- validate(defs.expression, node, 'expression', expression2, 1);
14416
- validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
14343
+ const defs2 = NODE_FIELDS.TSInstantiationExpression;
14344
+ validate(defs2.expression, node, 'expression', expression2, 1);
14345
+ validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
14417
14346
  return node;
14418
14347
  }
14419
14348
 
@@ -14424,9 +14353,9 @@ function tsAsExpression(expression2, typeAnnotation2) {
14424
14353
  typeAnnotation: typeAnnotation2,
14425
14354
  };
14426
14355
 
14427
- const defs = NODE_FIELDS.TSAsExpression;
14428
- validate(defs.expression, node, 'expression', expression2, 1);
14429
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14356
+ const defs2 = NODE_FIELDS.TSAsExpression;
14357
+ validate(defs2.expression, node, 'expression', expression2, 1);
14358
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14430
14359
  return node;
14431
14360
  }
14432
14361
 
@@ -14437,9 +14366,9 @@ function tsSatisfiesExpression(expression2, typeAnnotation2) {
14437
14366
  typeAnnotation: typeAnnotation2,
14438
14367
  };
14439
14368
 
14440
- const defs = NODE_FIELDS.TSSatisfiesExpression;
14441
- validate(defs.expression, node, 'expression', expression2, 1);
14442
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14369
+ const defs2 = NODE_FIELDS.TSSatisfiesExpression;
14370
+ validate(defs2.expression, node, 'expression', expression2, 1);
14371
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14443
14372
  return node;
14444
14373
  }
14445
14374
 
@@ -14450,9 +14379,9 @@ function tsTypeAssertion(typeAnnotation2, expression2) {
14450
14379
  expression: expression2,
14451
14380
  };
14452
14381
 
14453
- const defs = NODE_FIELDS.TSTypeAssertion;
14454
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14455
- validate(defs.expression, node, 'expression', expression2, 1);
14382
+ const defs2 = NODE_FIELDS.TSTypeAssertion;
14383
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14384
+ validate(defs2.expression, node, 'expression', expression2, 1);
14456
14385
  return node;
14457
14386
  }
14458
14387
 
@@ -14462,8 +14391,8 @@ function tsEnumBody(members) {
14462
14391
  members,
14463
14392
  };
14464
14393
 
14465
- const defs = NODE_FIELDS.TSEnumBody;
14466
- validate(defs.members, node, 'members', members, 1);
14394
+ const defs2 = NODE_FIELDS.TSEnumBody;
14395
+ validate(defs2.members, node, 'members', members, 1);
14467
14396
  return node;
14468
14397
  }
14469
14398
 
@@ -14474,9 +14403,9 @@ function tsEnumDeclaration(id, body) {
14474
14403
  body,
14475
14404
  };
14476
14405
 
14477
- const defs = NODE_FIELDS.TSEnumDeclaration;
14478
- validate(defs.id, node, 'id', id, 1);
14479
- validate(defs.body, node, 'body', body, 1);
14406
+ const defs2 = NODE_FIELDS.TSEnumDeclaration;
14407
+ validate(defs2.id, node, 'id', id, 1);
14408
+ validate(defs2.body, node, 'body', body, 1);
14480
14409
  return node;
14481
14410
  }
14482
14411
 
@@ -14487,9 +14416,9 @@ function tsEnumMember(id, initializer = null) {
14487
14416
  initializer,
14488
14417
  };
14489
14418
 
14490
- const defs = NODE_FIELDS.TSEnumMember;
14491
- validate(defs.id, node, 'id', id, 1);
14492
- validate(defs.initializer, node, 'initializer', initializer, 1);
14419
+ const defs2 = NODE_FIELDS.TSEnumMember;
14420
+ validate(defs2.id, node, 'id', id, 1);
14421
+ validate(defs2.initializer, node, 'initializer', initializer, 1);
14493
14422
  return node;
14494
14423
  }
14495
14424
 
@@ -14501,9 +14430,9 @@ function tsModuleDeclaration(id, body) {
14501
14430
  kind: 'namespace',
14502
14431
  };
14503
14432
 
14504
- const defs = NODE_FIELDS.TSModuleDeclaration;
14505
- validate(defs.id, node, 'id', id, 1);
14506
- validate(defs.body, node, 'body', body, 1);
14433
+ const defs2 = NODE_FIELDS.TSModuleDeclaration;
14434
+ validate(defs2.id, node, 'id', id, 1);
14435
+ validate(defs2.body, node, 'body', body, 1);
14507
14436
  return node;
14508
14437
  }
14509
14438
 
@@ -14513,8 +14442,8 @@ function tsModuleBlock(body) {
14513
14442
  body,
14514
14443
  };
14515
14444
 
14516
- const defs = NODE_FIELDS.TSModuleBlock;
14517
- validate(defs.body, node, 'body', body, 1);
14445
+ const defs2 = NODE_FIELDS.TSModuleBlock;
14446
+ validate(defs2.body, node, 'body', body, 1);
14518
14447
  return node;
14519
14448
  }
14520
14449
 
@@ -14526,10 +14455,10 @@ function tsImportType(source, qualifier = null, typeArguments = null) {
14526
14455
  typeArguments,
14527
14456
  };
14528
14457
 
14529
- const defs = NODE_FIELDS.TSImportType;
14530
- validate(defs.source, node, 'source', source, 1);
14531
- validate(defs.qualifier, node, 'qualifier', qualifier, 1);
14532
- validate(defs.typeArguments, node, 'typeArguments', typeArguments, 1);
14458
+ const defs2 = NODE_FIELDS.TSImportType;
14459
+ validate(defs2.source, node, 'source', source, 1);
14460
+ validate(defs2.qualifier, node, 'qualifier', qualifier, 1);
14461
+ validate(defs2.typeArguments, node, 'typeArguments', typeArguments, 1);
14533
14462
  return node;
14534
14463
  }
14535
14464
 
@@ -14540,9 +14469,9 @@ function tsImportEqualsDeclaration(id, moduleReference) {
14540
14469
  moduleReference,
14541
14470
  };
14542
14471
 
14543
- const defs = NODE_FIELDS.TSImportEqualsDeclaration;
14544
- validate(defs.id, node, 'id', id, 1);
14545
- validate(defs.moduleReference, node, 'moduleReference', moduleReference, 1);
14472
+ const defs2 = NODE_FIELDS.TSImportEqualsDeclaration;
14473
+ validate(defs2.id, node, 'id', id, 1);
14474
+ validate(defs2.moduleReference, node, 'moduleReference', moduleReference, 1);
14546
14475
  return node;
14547
14476
  }
14548
14477
 
@@ -14552,8 +14481,8 @@ function tsExternalModuleReference(expression2) {
14552
14481
  expression: expression2,
14553
14482
  };
14554
14483
 
14555
- const defs = NODE_FIELDS.TSExternalModuleReference;
14556
- validate(defs.expression, node, 'expression', expression2, 1);
14484
+ const defs2 = NODE_FIELDS.TSExternalModuleReference;
14485
+ validate(defs2.expression, node, 'expression', expression2, 1);
14557
14486
  return node;
14558
14487
  }
14559
14488
 
@@ -14563,8 +14492,8 @@ function tsNonNullExpression(expression2) {
14563
14492
  expression: expression2,
14564
14493
  };
14565
14494
 
14566
- const defs = NODE_FIELDS.TSNonNullExpression;
14567
- validate(defs.expression, node, 'expression', expression2, 1);
14495
+ const defs2 = NODE_FIELDS.TSNonNullExpression;
14496
+ validate(defs2.expression, node, 'expression', expression2, 1);
14568
14497
  return node;
14569
14498
  }
14570
14499
 
@@ -14574,8 +14503,8 @@ function tsExportAssignment(expression2) {
14574
14503
  expression: expression2,
14575
14504
  };
14576
14505
 
14577
- const defs = NODE_FIELDS.TSExportAssignment;
14578
- validate(defs.expression, node, 'expression', expression2, 1);
14506
+ const defs2 = NODE_FIELDS.TSExportAssignment;
14507
+ validate(defs2.expression, node, 'expression', expression2, 1);
14579
14508
  return node;
14580
14509
  }
14581
14510
 
@@ -14585,8 +14514,8 @@ function tsNamespaceExportDeclaration(id) {
14585
14514
  id,
14586
14515
  };
14587
14516
 
14588
- const defs = NODE_FIELDS.TSNamespaceExportDeclaration;
14589
- validate(defs.id, node, 'id', id, 1);
14517
+ const defs2 = NODE_FIELDS.TSNamespaceExportDeclaration;
14518
+ validate(defs2.id, node, 'id', id, 1);
14590
14519
  return node;
14591
14520
  }
14592
14521
 
@@ -14596,8 +14525,8 @@ function tsTypeAnnotation(typeAnnotation2) {
14596
14525
  typeAnnotation: typeAnnotation2,
14597
14526
  };
14598
14527
 
14599
- const defs = NODE_FIELDS.TSTypeAnnotation;
14600
- validate(defs.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14528
+ const defs2 = NODE_FIELDS.TSTypeAnnotation;
14529
+ validate(defs2.typeAnnotation, node, 'typeAnnotation', typeAnnotation2, 1);
14601
14530
  return node;
14602
14531
  }
14603
14532
 
@@ -14607,8 +14536,8 @@ function tsTypeParameterInstantiation(params) {
14607
14536
  params,
14608
14537
  };
14609
14538
 
14610
- const defs = NODE_FIELDS.TSTypeParameterInstantiation;
14611
- validate(defs.params, node, 'params', params, 1);
14539
+ const defs2 = NODE_FIELDS.TSTypeParameterInstantiation;
14540
+ validate(defs2.params, node, 'params', params, 1);
14612
14541
  return node;
14613
14542
  }
14614
14543
 
@@ -14618,8 +14547,8 @@ function tsTypeParameterDeclaration(params) {
14618
14547
  params,
14619
14548
  };
14620
14549
 
14621
- const defs = NODE_FIELDS.TSTypeParameterDeclaration;
14622
- validate(defs.params, node, 'params', params, 1);
14550
+ const defs2 = NODE_FIELDS.TSTypeParameterDeclaration;
14551
+ validate(defs2.params, node, 'params', params, 1);
14623
14552
  return node;
14624
14553
  }
14625
14554
 
@@ -14631,10 +14560,10 @@ function tsTypeParameter(constraint = null, _default = null, name) {
14631
14560
  name,
14632
14561
  };
14633
14562
 
14634
- const defs = NODE_FIELDS.TSTypeParameter;
14635
- validate(defs.constraint, node, 'constraint', constraint, 1);
14636
- validate(defs.default, node, 'default', _default, 1);
14637
- validate(defs.name, node, 'name', name, 1);
14563
+ const defs2 = NODE_FIELDS.TSTypeParameter;
14564
+ validate(defs2.constraint, node, 'constraint', constraint, 1);
14565
+ validate(defs2.default, node, 'default', _default, 1);
14566
+ validate(defs2.name, node, 'name', name, 1);
14638
14567
  return node;
14639
14568
  }
14640
14569
 
@@ -17008,8 +16937,8 @@ function toExpression(node) {
17008
16937
  return node;
17009
16938
  }
17010
16939
 
17011
- var _skip = Symbol();
17012
- var _stop = Symbol();
16940
+ var _skip = /* @__PURE__ */Symbol();
16941
+ var _stop = /* @__PURE__ */Symbol();
17013
16942
 
17014
16943
  function traverseFast(node, enter, opts) {
17015
16944
  if (!node)
@@ -17883,7 +17812,7 @@ var react = {
17883
17812
  buildChildren,
17884
17813
  };
17885
17814
 
17886
- // ../babel-babel/packages/babel-parser/lib/index.js
17815
+ // node_modules/@babel/parser/lib/index.js
17887
17816
  var Position = class {
17888
17817
  line;
17889
17818
  column;
@@ -24300,6 +24229,10 @@ var NodeUtils = class extends UtilParser {
24300
24229
  }
24301
24230
 
24302
24231
  finishNodeAt(node, type, endLoc) {
24232
+ if (process.env.NODE_ENV !== 'production' && node.end > 0) {
24233
+ throw new Error('Do not call finishNode*() twice on the same node. Instead use resetEndLocation() or change type directly.');
24234
+ }
24235
+
24303
24236
  node.type = type;
24304
24237
  node.end = endLoc.index;
24305
24238
  node.loc.end = endLoc;
@@ -27079,7 +27012,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
27079
27012
 
27080
27013
  const tokenType = this.state.type;
27081
27014
 
27082
- if (tokenType === 44 || tokenType === 48 || tokenType !== 6 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
27015
+ if (tokenType === 44 || tokenType === 48 || tokenType !== 6 && tokenType !== 89 && tokenType !== 116 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
27083
27016
  return;
27084
27017
  }
27085
27018
 
@@ -33470,10 +33403,165 @@ function getParserClass(pluginsMap) {
33470
33403
  return cls;
33471
33404
  }
33472
33405
 
33473
- // ../babel-babel/packages/babel-code-frame/lib/index.js
33474
- var import_picocolors = __toESM(require_picocolors(), 1);
33406
+ // node_modules/@babel/code-frame/lib/common-BO7XIBW3.js
33407
+ var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
33475
33408
 
33476
- // ../babel-babel/node_modules/js-tokens/index.js
33409
+ function getMarkerLines(loc, source, opts, startLineBaseZero) {
33410
+ const startLoc = {
33411
+ column: 0,
33412
+ line: -1,
33413
+ ...loc.start,
33414
+ };
33415
+
33416
+ const endLoc = {
33417
+ ...startLoc,
33418
+ ...loc.end,
33419
+ };
33420
+
33421
+ const {linesAbove = 2, linesBelow = 3} = opts || {};
33422
+
33423
+ const startLine = startLoc.line - startLineBaseZero;
33424
+ const startColumn = startLoc.column;
33425
+ const endLine = endLoc.line - startLineBaseZero;
33426
+ const endColumn = endLoc.column;
33427
+ let start = Math.max(startLine - (linesAbove + 1), 0);
33428
+ let end = Math.min(source.length, endLine + linesBelow);
33429
+
33430
+ if (startLine === -1) {
33431
+ start = 0;
33432
+ }
33433
+
33434
+ if (endLine === -1) {
33435
+ end = source.length;
33436
+ }
33437
+
33438
+ const lineDiff = endLine - startLine;
33439
+ const markerLines = {};
33440
+
33441
+ if (lineDiff) {
33442
+ for (let i = 0; i <= lineDiff; i++) {
33443
+ const lineNumber = i + startLine;
33444
+
33445
+ if (!startColumn) {
33446
+ markerLines[lineNumber] = true;
33447
+ } else if (i === 0) {
33448
+ const sourceLength = source[lineNumber - 1].length;
33449
+ markerLines[lineNumber] = [
33450
+ startColumn,
33451
+ sourceLength - startColumn + 1,
33452
+ ];
33453
+ } else if (i === lineDiff) {
33454
+ markerLines[lineNumber] = [0, endColumn];
33455
+ } else {
33456
+ const sourceLength = source[lineNumber - i].length;
33457
+ markerLines[lineNumber] = [0, sourceLength];
33458
+ }
33459
+
33460
+ }
33461
+ } else {
33462
+ if (startColumn === endColumn) {
33463
+ if (startColumn) {
33464
+ markerLines[startLine] = [startColumn, 0];
33465
+ } else {
33466
+ markerLines[startLine] = true;
33467
+ }
33468
+ } else {
33469
+ markerLines[startLine] = [
33470
+ startColumn,
33471
+ endColumn - startColumn,
33472
+ ];
33473
+ }
33474
+ }
33475
+
33476
+ return {
33477
+ start,
33478
+ end,
33479
+ markerLines,
33480
+ };
33481
+ }
33482
+
33483
+ function _codeFrameColumns(rawLines, loc, opts = {}, colorOpts) {
33484
+ const {defs: defs2, highlight: highlight2} = colorOpts || {
33485
+ defs: {
33486
+ gutter: String,
33487
+ marker: String,
33488
+ message: String,
33489
+ reset: String,
33490
+ },
33491
+ highlight: String,
33492
+ };
33493
+
33494
+ const startLineBaseZero = (opts.startLine || 1) - 1;
33495
+ const lines = rawLines.split(NEWLINE);
33496
+
33497
+ const {
33498
+ start,
33499
+ end,
33500
+ markerLines,
33501
+ } = getMarkerLines(loc, lines, opts, startLineBaseZero);
33502
+
33503
+ const hasColumns = loc.start && typeof loc.start.column === 'number';
33504
+ const numberMaxWidth = String(end + startLineBaseZero).length;
33505
+ const highlightedLines = highlight2(rawLines);
33506
+
33507
+ let frame = highlightedLines
33508
+ .split(NEWLINE, end)
33509
+ .slice(start, end)
33510
+ .map((line, index3) => {
33511
+ const number = start + 1 + index3;
33512
+ const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
33513
+ const gutter = ` ${paddedNumber} |`;
33514
+ const hasMarker = markerLines[number];
33515
+ const lastMarkerLine = !markerLines[number + 1];
33516
+
33517
+ if (hasMarker) {
33518
+ let markerLine = '';
33519
+
33520
+ if (Array.isArray(hasMarker)) {
33521
+ const markerSpacing = line
33522
+ .slice(0, Math.max(hasMarker[0] - 1, 0))
33523
+ .replace(/[^\t]/g, ' ');
33524
+ const numberOfMarkers = hasMarker[1] || 1;
33525
+
33526
+ markerLine = [
33527
+ '\n ',
33528
+ defs2.gutter(gutter.replace(/\d/g, ' ')),
33529
+ ' ',
33530
+ markerSpacing,
33531
+ defs2
33532
+ .marker('^')
33533
+ .repeat(numberOfMarkers),
33534
+ ].join('');
33535
+
33536
+ if (lastMarkerLine && opts.message) {
33537
+ markerLine += ' ' + defs2.message(opts.message);
33538
+ }
33539
+ }
33540
+
33541
+ return [
33542
+ defs2.marker('>'),
33543
+ defs2.gutter(gutter),
33544
+ line.length > 0 ? ` ${line}` : '',
33545
+ markerLine,
33546
+ ].join('');
33547
+ } else {
33548
+ return ` ${defs2.gutter(gutter)}${line.length > 0 ? ` ${line}` : ''}`;
33549
+ }
33550
+ })
33551
+ .join('\n');
33552
+
33553
+ if (opts.message && !hasColumns) {
33554
+ frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}
33555
+ ${frame}`;
33556
+ }
33557
+
33558
+ return defs2.reset(frame);
33559
+ }
33560
+
33561
+ // node_modules/@babel/code-frame/lib/index.js
33562
+ import {styleText} from 'util';
33563
+
33564
+ // node_modules/js-tokens/index.js
33477
33565
  var HashbangComment;
33478
33566
  var Identifier2;
33479
33567
  var JSXIdentifier2;
@@ -33983,37 +34071,32 @@ jsTokens = function*(input, {jsx: jsx2 = false} = {}) {
33983
34071
  };
33984
34072
  var js_tokens_default = jsTokens;
33985
34073
 
33986
- // ../babel-babel/packages/babel-code-frame/lib/index.js
34074
+ // node_modules/@babel/code-frame/lib/index.js
33987
34075
  function isColorSupported() {
33988
- return typeof process === 'object' && (process.env.FORCE_COLOR === '0' || process.env.FORCE_COLOR === 'false') ? false : import_picocolors.default.isColorSupported;
34076
+ return styleText('red', '-') !== '-';
33989
34077
  }
33990
34078
 
33991
- var compose = (f, g) => (v) => f(g(v));
33992
-
33993
- function buildDefs(colors2) {
33994
- return {
33995
- keyword: colors2.cyan,
33996
- capitalized: colors2.yellow,
33997
- jsxIdentifier: colors2.yellow,
33998
- punctuator: colors2.yellow,
33999
- number: colors2.magenta,
34000
- string: colors2.green,
34001
- regex: colors2.magenta,
34002
- comment: colors2.gray,
34003
- invalid: compose(compose(colors2.white, colors2.bgRed), colors2.bold),
34004
- gutter: colors2.gray,
34005
- marker: compose(colors2.red, colors2.bold),
34006
- message: compose(colors2.red, colors2.bold),
34007
- reset: colors2.reset,
34008
- };
34079
+ function createFormatter(format) {
34080
+ return (input) => styleText(format, String(input ?? ''), {
34081
+ validateStream: false,
34082
+ });
34009
34083
  }
34010
34084
 
34011
- var defsOn = buildDefs((0, import_picocolors.createColors)(true));
34012
- var defsOff = buildDefs((0, import_picocolors.createColors)(false));
34013
-
34014
- function getDefs(enabled2) {
34015
- return enabled2 ? defsOn : defsOff;
34016
- }
34085
+ var defs = {
34086
+ keyword: createFormatter('cyan'),
34087
+ capitalized: createFormatter('yellow'),
34088
+ jsxIdentifier: createFormatter('yellow'),
34089
+ punctuator: createFormatter('yellow'),
34090
+ number: createFormatter('magenta'),
34091
+ string: createFormatter('green'),
34092
+ regex: createFormatter('magenta'),
34093
+ comment: createFormatter('gray'),
34094
+ invalid: createFormatter(['white', 'bgRed', 'bold']),
34095
+ gutter: createFormatter('gray'),
34096
+ marker: createFormatter(['red', 'bold']),
34097
+ message: createFormatter(['red', 'bold']),
34098
+ reset: createFormatter('reset'),
34099
+ };
34017
34100
 
34018
34101
  var sometimesKeywords = /* @__PURE__ */new Set([
34019
34102
  'as',
@@ -34023,7 +34106,7 @@ var sometimesKeywords = /* @__PURE__ */new Set([
34023
34106
  'of',
34024
34107
  'set',
34025
34108
  ]);
34026
- var NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
34109
+ var NEWLINE2 = /\r\n|[\n\r\u2028\u2029]/;
34027
34110
  var BRACKET = /^[()[\]{}]$/;
34028
34111
 
34029
34112
  var getTokenType = function(token) {
@@ -34142,13 +34225,12 @@ function highlight(text) {
34142
34225
  if (text === '')
34143
34226
  return '';
34144
34227
 
34145
- const defs = getDefs(true);
34146
34228
  let highlighted = '';
34147
34229
 
34148
34230
  for (const {type, value} of tokenize(text)) {
34149
34231
  if (type in defs) {
34150
34232
  highlighted += value
34151
- .split(NEWLINE$1)
34233
+ .split(NEWLINE2)
34152
34234
  .map((str) => defs[type](str))
34153
34235
  .join('\n');
34154
34236
  } else {
@@ -34159,157 +34241,16 @@ function highlight(text) {
34159
34241
  return highlighted;
34160
34242
  }
34161
34243
 
34162
- var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
34163
-
34164
- function getMarkerLines(loc, source, opts, startLineBaseZero) {
34165
- const startLoc = {
34166
- column: 0,
34167
- line: -1,
34168
- ...loc.start,
34169
- };
34170
-
34171
- const endLoc = {
34172
- ...startLoc,
34173
- ...loc.end,
34174
- };
34175
-
34176
- const {linesAbove = 2, linesBelow = 3} = opts || {};
34177
-
34178
- const startLine = startLoc.line - startLineBaseZero;
34179
- const startColumn = startLoc.column;
34180
- const endLine = endLoc.line - startLineBaseZero;
34181
- const endColumn = endLoc.column;
34182
- let start = Math.max(startLine - (linesAbove + 1), 0);
34183
- let end = Math.min(source.length, endLine + linesBelow);
34184
-
34185
- if (startLine === -1) {
34186
- start = 0;
34187
- }
34188
-
34189
- if (endLine === -1) {
34190
- end = source.length;
34191
- }
34192
-
34193
- const lineDiff = endLine - startLine;
34194
- const markerLines = {};
34195
-
34196
- if (lineDiff) {
34197
- for (let i = 0; i <= lineDiff; i++) {
34198
- const lineNumber = i + startLine;
34199
-
34200
- if (!startColumn) {
34201
- markerLines[lineNumber] = true;
34202
- } else if (i === 0) {
34203
- const sourceLength = source[lineNumber - 1].length;
34204
- markerLines[lineNumber] = [
34205
- startColumn,
34206
- sourceLength - startColumn + 1,
34207
- ];
34208
- } else if (i === lineDiff) {
34209
- markerLines[lineNumber] = [0, endColumn];
34210
- } else {
34211
- const sourceLength = source[lineNumber - i].length;
34212
- markerLines[lineNumber] = [0, sourceLength];
34213
- }
34214
-
34215
- }
34216
- } else {
34217
- if (startColumn === endColumn) {
34218
- if (startColumn) {
34219
- markerLines[startLine] = [startColumn, 0];
34220
- } else {
34221
- markerLines[startLine] = true;
34222
- }
34223
- } else {
34224
- markerLines[startLine] = [
34225
- startColumn,
34226
- endColumn - startColumn,
34227
- ];
34228
- }
34229
- }
34230
-
34231
- return {
34232
- start,
34233
- end,
34234
- markerLines,
34235
- };
34236
- }
34237
-
34238
34244
  function codeFrameColumns(rawLines, loc, opts = {}) {
34239
34245
  const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
34240
- const startLineBaseZero = (opts.startLine || 1) - 1;
34241
- const defs = getDefs(shouldHighlight);
34242
- const lines = rawLines.split(NEWLINE);
34243
-
34244
- const {
34245
- start,
34246
- end,
34247
- markerLines,
34248
- } = getMarkerLines(loc, lines, opts, startLineBaseZero);
34249
-
34250
- const hasColumns = loc.start && typeof loc.start.column === 'number';
34251
- const numberMaxWidth = String(end + startLineBaseZero).length;
34252
- const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
34253
-
34254
- let frame = highlightedLines
34255
- .split(NEWLINE, end)
34256
- .slice(start, end)
34257
- .map((line, index3) => {
34258
- const number = start + 1 + index3;
34259
- const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
34260
- const gutter = ` ${paddedNumber} |`;
34261
- const hasMarker = markerLines[number];
34262
- const lastMarkerLine = !markerLines[number + 1];
34263
-
34264
- if (hasMarker) {
34265
- let markerLine = '';
34266
-
34267
- if (Array.isArray(hasMarker)) {
34268
- const markerSpacing = line
34269
- .slice(0, Math.max(hasMarker[0] - 1, 0))
34270
- .replace(/[^\t]/g, ' ');
34271
- const numberOfMarkers = hasMarker[1] || 1;
34272
-
34273
- markerLine = [
34274
- '\n ',
34275
- defs.gutter(gutter.replace(/\d/g, ' ')),
34276
- ' ',
34277
- markerSpacing,
34278
- defs
34279
- .marker('^')
34280
- .repeat(numberOfMarkers),
34281
- ].join('');
34282
-
34283
- if (lastMarkerLine && opts.message) {
34284
- markerLine += ' ' + defs.message(opts.message);
34285
- }
34286
- }
34287
-
34288
- return [
34289
- defs.marker('>'),
34290
- defs.gutter(gutter),
34291
- line.length > 0 ? ` ${line}` : '',
34292
- markerLine,
34293
- ].join('');
34294
- } else {
34295
- return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ''}`;
34296
- }
34297
- })
34298
- .join('\n');
34299
34246
 
34300
- if (opts.message && !hasColumns) {
34301
- frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}
34302
- ${frame}`;
34303
- }
34304
-
34305
- if (shouldHighlight) {
34306
- return defs.reset(frame);
34307
- } else {
34308
- return frame;
34309
- }
34247
+ return _codeFrameColumns(rawLines, loc, opts, shouldHighlight ? {
34248
+ defs,
34249
+ highlight,
34250
+ } : void 0);
34310
34251
  }
34311
34252
 
34312
- // ../babel-babel/packages/babel-template/lib/index.js
34253
+ // node_modules/@babel/template/lib/index.js
34313
34254
  var {assertExpressionStatement: assertExpressionStatement2} = lib_exports;
34314
34255
 
34315
34256
  function makeStatementFormatter(fn) {
@@ -34948,7 +34889,7 @@ var index = Object.assign(smart.bind(void 0), {
34948
34889
  ast: smart.ast,
34949
34890
  });
34950
34891
 
34951
- // ../babel-babel/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
34892
+ // node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
34952
34893
  var comma = ','.charCodeAt(0);
34953
34894
  var semicolon = ';'.charCodeAt(0);
34954
34895
  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
@@ -35197,7 +35138,7 @@ function encode(decoded) {
35197
35138
  return writer.flush();
35198
35139
  }
35199
35140
 
35200
- // ../babel-babel/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
35141
+ // node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
35201
35142
  var schemeRegex = /^[\w+.-]+:\/\//;
35202
35143
  var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
35203
35144
  var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
@@ -35417,7 +35358,7 @@ case 2:
35417
35358
  }
35418
35359
  }
35419
35360
 
35420
- // ../babel-babel/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
35361
+ // node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
35421
35362
  function stripFilename(path) {
35422
35363
  if (!path)
35423
35364
  return '';
@@ -35689,7 +35630,7 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
35689
35630
  return index3;
35690
35631
  }
35691
35632
 
35692
- // ../babel-babel/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
35633
+ // node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
35693
35634
  var SetArray = class {
35694
35635
  constructor() {
35695
35636
  this._indexes = {
@@ -35965,7 +35906,7 @@ function addMappingInternal(skipable, map, mapping) {
35965
35906
  return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
35966
35907
  }
35967
35908
 
35968
- // ../babel-babel/packages/babel-generator/lib/index.js
35909
+ // node_modules/@babel/generator/lib/index.js
35969
35910
  var import_jsesc = __toESM(require_jsesc(), 1);
35970
35911
 
35971
35912
  var SourceMap = class {
@@ -41814,7 +41755,7 @@ function generate(ast, opts = {}, code2) {
41814
41755
  return printer.generate(ast);
41815
41756
  }
41816
41757
 
41817
- // ../babel-babel/node_modules/obug/dist/core.js
41758
+ // node_modules/obug/dist/core.js
41818
41759
  function selectColor(colors2, namespace) {
41819
41760
  let hash = 0;
41820
41761
 
@@ -41861,7 +41802,7 @@ function enable(namespaces$1) {
41861
41802
  names.push(ns);
41862
41803
  }
41863
41804
 
41864
- // ../babel-babel/node_modules/obug/dist/node.js
41805
+ // node_modules/obug/dist/node.js
41865
41806
  var colors = [];
41866
41807
 
41867
41808
  var inspectOpts = {};
@@ -41908,7 +41849,7 @@ function createDebug2(namespace, options) {
41908
41849
  }
41909
41850
 
41910
41851
  enable(process.env.DEBUG || '');
41911
- // ../babel-babel/packages/babel-helper-globals/data/builtin-lower.json
41852
+ // node_modules/@babel/helper-globals/data/builtin-lower.json
41912
41853
 
41913
41854
  var builtin_lower_default = [
41914
41855
  'decodeURI',
@@ -41926,7 +41867,7 @@ var builtin_lower_default = [
41926
41867
  'unescape',
41927
41868
  ];
41928
41869
 
41929
- // ../babel-babel/packages/babel-helper-globals/data/builtin-upper.json
41870
+ // node_modules/@babel/helper-globals/data/builtin-upper.json
41930
41871
  var builtin_upper_default = [
41931
41872
  'AggregateError',
41932
41873
  'Array',
@@ -41979,7 +41920,7 @@ var builtin_upper_default = [
41979
41920
  'WeakSet',
41980
41921
  ];
41981
41922
 
41982
- // ../babel-babel/packages/babel-traverse/lib/index.js
41923
+ // node_modules/@babel/traverse/lib/index.js
41983
41924
  var ReferencedIdentifier = [
41984
41925
  'Identifier',
41985
41926
  'JSXIdentifier',
@@ -42514,7 +42455,7 @@ function verify$1(visitor) {
42514
42455
  continue;
42515
42456
 
42516
42457
  if (!TYPES2.includes(nodeType)) {
42517
- throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${'8.0.0-beta.4'}`);
42458
+ throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${'8.0.0-rc.1'}`);
42518
42459
  }
42519
42460
 
42520
42461
  const visitors2 = visitor[nodeType];
@@ -47097,7 +47038,7 @@ function isExecutionUncertainInList(paths, maxIndex) {
47097
47038
  return false;
47098
47039
  }
47099
47040
 
47100
- var SYMBOL_CHECKING = Symbol();
47041
+ var SYMBOL_CHECKING = /* @__PURE__ */Symbol();
47101
47042
 
47102
47043
  function _guessExecutionStatusRelativeTo(target) {
47103
47044
  return _guessExecutionStatusRelativeToCached(this, target, /* @__PURE__ */new Map());