@putout/babel 4.2.0 → 4.4.0

package/bundle/index.js

@@ -1003,568 +1003,13 @@ var require_jsesc = __commonJS({
 });
 
 // node_modules/ms/index.js
-var require_ms = __commonJS({
-    'node_modules/ms/index.js'(exports2, module2) {
-        var s = 1e3;
-        var m = s * 60;
-        var h = m * 60;
-        var d = h * 24;
-        var w = d * 7;
-        var y = d * 365.25;
-        
-        module2.exports = function(val, options) {
-            options = options || {};
-            var type = typeof val;
-            
-            if (type === 'string' && val.length > 0) {
-                return parse3(val);
-            } else if (type === 'number' && isFinite(val)) {
-                return options.long ? fmtLong(val) : fmtShort(val);
-            }
-            
-            throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val));
-        };
-        function parse3(str) {
-            str = String(str);
-            
-            if (str.length > 100) {
-                return;
-            }
-            
-            var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
-            
-            if (!match) {
-                return;
-            }
-            
-            var n2 = parseFloat(match[1]);
-            var type = (match[2] || 'ms').toLowerCase();
-            
-            switch(type) {
-            case 'years':            
-            case 'year':            
-            case 'yrs':            
-            case 'yr':            
-            case 'y':
-                return n2 * y;
-            
-            case 'weeks':            
-            case 'week':            
-            case 'w':
-                return n2 * w;
-            
-            case 'days':            
-            case 'day':            
-            case 'd':
-                return n2 * d;
-            
-            case 'hours':            
-            case 'hour':            
-            case 'hrs':            
-            case 'hr':            
-            case 'h':
-                return n2 * h;
-            
-            case 'minutes':            
-            case 'minute':            
-            case 'mins':            
-            case 'min':            
-            case 'm':
-                return n2 * m;
-            
-            case 'seconds':            
-            case 'second':            
-            case 'secs':            
-            case 'sec':            
-            case 's':
-                return n2 * s;
-            
-            case 'milliseconds':            
-            case 'millisecond':            
-            case 'msecs':            
-            case 'msec':            
-            case 'ms':
-                return n2;
-            
-            default:
-                return void 0;
-            }
-        }
-        
-        function fmtShort(ms) {
-            var msAbs = Math.abs(ms);
-            
-            if (msAbs >= d) {
-                return Math.round(ms / d) + 'd';
-            }
-            
-            if (msAbs >= h) {
-                return Math.round(ms / h) + 'h';
-            }
-            
-            if (msAbs >= m) {
-                return Math.round(ms / m) + 'm';
-            }
-            
-            if (msAbs >= s) {
-                return Math.round(ms / s) + 's';
-            }
-            
-            return ms + 'ms';
-        }
-        
-        function fmtLong(ms) {
-            var msAbs = Math.abs(ms);
-            
-            if (msAbs >= d) {
-                return plural(ms, msAbs, d, 'day');
-            }
-            
-            if (msAbs >= h) {
-                return plural(ms, msAbs, h, 'hour');
-            }
-            
-            if (msAbs >= m) {
-                return plural(ms, msAbs, m, 'minute');
-            }
-            
-            if (msAbs >= s) {
-                return plural(ms, msAbs, s, 'second');
-            }
-            
-            return ms + ' ms';
-        }
-        
-        function plural(ms, msAbs, n2, name) {
-            var isPlural = msAbs >= n2 * 1.5;
-            return Math.round(ms / n2) + ' ' + name + (isPlural ? 's' : '');
-        }
-    },
-});
+var require_ms = () => () => {};
 
 // node_modules/debug/src/common.js
-var require_common = __commonJS({
-    'node_modules/debug/src/common.js'(exports2, module2) {
-        function setup2(env) {
-            createDebug.debug = createDebug;
-            createDebug.default = createDebug;
-            createDebug.coerce = coerce;
-            createDebug.disable = disable;
-            createDebug.enable = enable;
-            createDebug.enabled = enabled;
-            createDebug.humanize = require_ms();
-            createDebug.destroy = destroy;
-            Object
-                .keys(env)
-                .forEach((key) => {
-                    createDebug[key] = env[key];
-                });
-            createDebug.names = [];
-            createDebug.skips = [];
-            createDebug.formatters = {};
-            function selectColor(namespace) {
-                let hash = 0;
-                
-                for (let i = 0; i < namespace.length; i++) {
-                    hash = (hash << 5) - hash + namespace.charCodeAt(i);
-                    hash |= 0;
-                }
-                
-                return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
-            }
-            
-            createDebug.selectColor = selectColor;
-            function createDebug(namespace) {
-                let prevTime;
-                let enableOverride = null;
-                let namespacesCache;
-                let enabledCache;
-                
-                function debug2(...args) {
-                    if (!debug2.enabled) {
-                        return;
-                    }
-                    
-                    const self = debug2;
-                    const curr = Number(                    /* @__PURE__ */new Date());
-                    const ms = curr - (prevTime || curr);
-                    
-                    self.diff = ms;
-                    self.prev = prevTime;
-                    self.curr = curr;
-                    prevTime = curr;
-                    args[0] = createDebug.coerce(args[0]);
-                    
-                    if (typeof args[0] !== 'string') {
-                        args.unshift('%O');
-                    }
-                    
-                    let index2 = 0;
-                    
-                    args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-                        if (match === '%%') {
-                            return '%';
-                        }
-                        
-                        index2++;
-                        const formatter = createDebug.formatters[format];
-                        
-                        if (typeof formatter === 'function') {
-                            const val = args[index2];
-                            
-                            match = formatter.call(self, val);
-                            args.splice(index2, 1);
-                            index2--;
-                        }
-                        
-                        return match;
-                    });
-                    createDebug.formatArgs.call(self, args);
-                    const logFn = self.log || createDebug.log;
-                    logFn.apply(self, args);
-                }
-                
-                debug2.namespace = namespace;
-                debug2.useColors = createDebug.useColors();
-                debug2.color = createDebug.selectColor(namespace);
-                debug2.extend = extend;
-                debug2.destroy = createDebug.destroy;
-                Object.defineProperty(debug2, 'enabled', {
-                    enumerable: true,
-                    configurable: false,
-                    get: () => {
-                        if (enableOverride !== null) {
-                            return enableOverride;
-                        }
-                        
-                        if (namespacesCache !== createDebug.namespaces) {
-                            namespacesCache = createDebug.namespaces;
-                            enabledCache = createDebug.enabled(namespace);
-                        }
-                        
-                        return enabledCache;
-                    },
-                    set: (v) => {
-                        enableOverride = v;
-                    },
-                });
-                
-                if (typeof createDebug.init === 'function') {
-                    createDebug.init(debug2);
-                }
-                
-                return debug2;
-            }
-            
-            function extend(namespace, delimiter) {
-                const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
-                
-                newDebug.log = this.log;
-                return newDebug;
-            }
-            
-            function enable(namespaces) {
-                createDebug.save(namespaces);
-                createDebug.namespaces = namespaces;
-                createDebug.names = [];
-                createDebug.skips = [];
-                const split = (typeof namespaces === 'string' ? namespaces : '')
-                    .trim()
-                    .replace(/\s+/g, ',')
-                    .split(',')
-                    .filter(Boolean);
-                
-                for (const ns of split) {
-                    if (ns[0] === '-') {
-                        createDebug.skips.push(ns.slice(1));
-                    } else {
-                        createDebug.names.push(ns);
-                    }
-                }
-            }
-            
-            function matchesTemplate(search, template) {
-                let searchIndex = 0;
-                let templateIndex = 0;
-                let starIndex = -1;
-                let matchIndex = 0;
-                
-                while (searchIndex < search.length) {
-                    if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
-                        if (template[templateIndex] === '*') {
-                            starIndex = templateIndex;
-                            matchIndex = searchIndex;
-                            templateIndex++;
-                        } else {
-                            searchIndex++;
-                            templateIndex++;
-                        }
-                    } else if (starIndex !== -1) {
-                        templateIndex = starIndex + 1;
-                        matchIndex++;
-                        searchIndex = matchIndex;
-                    } else {
-                        return false;
-                    }
-                }
-                
-                while (templateIndex < template.length && template[templateIndex] === '*') {
-                    templateIndex++;
-                }
-                
-                return templateIndex === template.length;
-            }
-            
-            function disable() {
-                const namespaces = [
-                    ...createDebug.names,
-                    ...createDebug.skips.map((namespace) => '-' + namespace),
-                ].join(',');
-                
-                createDebug.enable('');
-                return namespaces;
-            }
-            
-            function enabled(name) {
-                for (const skip2 of createDebug.skips) {
-                    if (matchesTemplate(name, skip2)) {
-                        return false;
-                    }
-                }
-                
-                for (const ns of createDebug.names) {
-                    if (matchesTemplate(name, ns)) {
-                        return true;
-                    }
-                }
-                
-                return false;
-            }
-            
-            function coerce(val) {
-                if (val instanceof Error) {
-                    return val.stack || val.message;
-                }
-                
-                return val;
-            }
-            
-            function destroy() {
-                console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-            }
-            
-            createDebug.enable(createDebug.load());
-            
-            return createDebug;
-        }
-        
-        module2.exports = setup2;
-    },
-});
+var require_common = () => () => {};
 
 // node_modules/debug/src/browser.js
-var require_browser = __commonJS({
-    'node_modules/debug/src/browser.js'(exports2, module2) {
-        exports2.formatArgs = formatArgs;
-        exports2.save = save;
-        exports2.load = load;
-        exports2.useColors = useColors;
-        exports2.storage = localstorage();
-        exports2.destroy =         /* @__PURE__ */(() => {
-            let warned = false;
-            
-            return () => {
-                if (!warned) {
-                    warned = true;
-                    console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-                }
-            };
-        })();
-        exports2.colors = [
-            '#0000CC',
-            '#0000FF',
-            '#0033CC',
-            '#0033FF',
-            '#0066CC',
-            '#0066FF',
-            '#0099CC',
-            '#0099FF',
-            '#00CC00',
-            '#00CC33',
-            '#00CC66',
-            '#00CC99',
-            '#00CCCC',
-            '#00CCFF',
-            '#3300CC',
-            '#3300FF',
-            '#3333CC',
-            '#3333FF',
-            '#3366CC',
-            '#3366FF',
-            '#3399CC',
-            '#3399FF',
-            '#33CC00',
-            '#33CC33',
-            '#33CC66',
-            '#33CC99',
-            '#33CCCC',
-            '#33CCFF',
-            '#6600CC',
-            '#6600FF',
-            '#6633CC',
-            '#6633FF',
-            '#66CC00',
-            '#66CC33',
-            '#9900CC',
-            '#9900FF',
-            '#9933CC',
-            '#9933FF',
-            '#99CC00',
-            '#99CC33',
-            '#CC0000',
-            '#CC0033',
-            '#CC0066',
-            '#CC0099',
-            '#CC00CC',
-            '#CC00FF',
-            '#CC3300',
-            '#CC3333',
-            '#CC3366',
-            '#CC3399',
-            '#CC33CC',
-            '#CC33FF',
-            '#CC6600',
-            '#CC6633',
-            '#CC9900',
-            '#CC9933',
-            '#CCCC00',
-            '#CCCC33',
-            '#FF0000',
-            '#FF0033',
-            '#FF0066',
-            '#FF0099',
-            '#FF00CC',
-            '#FF00FF',
-            '#FF3300',
-            '#FF3333',
-            '#FF3366',
-            '#FF3399',
-            '#FF33CC',
-            '#FF33FF',
-            '#FF6600',
-            '#FF6633',
-            '#FF9900',
-            '#FF9933',
-            '#FFCC00',
-            '#FFCC33',
-        ];
-        function useColors() {
-            if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
-                return true;
-            }
-            
-            if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-                return false;
-            }
-            
-            let m;
-            
-            return typeof document !== 'undefined'
-                && document.documentElement
-                && document.documentElement.style
-                && document.documentElement.style.WebkitAppearance
-                ||             // Is firebug? http://stackoverflow.com/a/398120/376773
-typeof window !== 'undefined'
-                && window.console
-                && (window.console.firebug
-                || window.console.exception
-                && window.console.table)
-                ||             // Is firefox >= v31?
-            // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-typeof navigator !== 'undefined'
-                && navigator.userAgent
-                && (m = navigator.userAgent
-                .toLowerCase()
-                .match(/firefox\/(\d+)/))
-                && parseInt(m[1], 10) >= 31
-                ||             // Double check webkit in userAgent just in case we are in a worker
-typeof navigator !== 'undefined'
-                && navigator.userAgent
-                && navigator.userAgent
-                .toLowerCase()
-                .match(/applewebkit\/(\d+)/);
-        }
-        
-        function formatArgs(args) {
-            args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module2.exports.humanize(this.diff);
-            
-            if (!this.useColors) {
-                return;
-            }
-            
-            const c = 'color: ' + this.color;
-            args.splice(1, 0, c, 'color: inherit');
-            let index2 = 0;
-            let lastC = 0;
-            
-            args[0].replace(/%[a-zA-Z%]/g, (match) => {
-                if (match === '%%') {
-                    return;
-                }
-                
-                index2++;
-                
-                if (match === '%c') {
-                    lastC = index2;
-                }
-            });
-            args.splice(lastC, 0, c);
-        }
-        
-        exports2.log = console.debug || console.log || (() => {});
-        function save(namespaces) {
-            try {
-                if (namespaces) {
-                    exports2.storage.setItem('debug', namespaces);
-                } else {
-                    exports2.storage.removeItem('debug');
-                }
-            } catch(error) {}
-        }
-        
-        function load() {
-            let r;
-            
-            try {
-                r = exports2.storage.getItem('debug') || exports2.storage.getItem('DEBUG');
-            } catch(error) {}
-
-
-                        if (!r && typeof process !== 'undefined' && 'env' in process) {
-                r = process.env.DEBUG;
-            }
-            
-            return r;
-        }
-        
-        function localstorage() {
-            try {
-                return localStorage;
-            } catch(error) {}
-        }
-        
-        module2.exports = require_common()(exports2);
-        var {formatters} = module2.exports;
-        
-        formatters.j = function(v) {
-            try {
-                return JSON.stringify(v);
-            } catch(error) {
-                return '[UnexpectedJSONParseError]: ' + error.message;
-            }
-        };
-    },
-});
+var require_browser = () => () => {};
 
 // node_modules/has-flag/index.js
 var require_has_flag = __commonJS({
@@ -1713,212 +1158,7 @@ var require_supports_color = __commonJS({
 });
 
 // node_modules/debug/src/node.js
-var require_node = __commonJS({
-    'node_modules/debug/src/node.js'(exports2, module2) {
-        var tty = require('tty');
-        var util = require('util');
-        
-        exports2.init = init;
-        exports2.log = log;
-        exports2.formatArgs = formatArgs;
-        exports2.save = save;
-        exports2.load = load;
-        exports2.useColors = useColors;
-        exports2.destroy = util.deprecate(() => {}, 'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-        exports2.colors = [
-            6,
-            2,
-            3,
-            4,
-            5,
-            1,
-        ];
-        try {
-            const supportsColor = require_supports_color();
-            
-            if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
-                exports2.colors = [
-                    20,
-                    21,
-                    26,
-                    27,
-                    32,
-                    33,
-                    38,
-                    39,
-                    40,
-                    41,
-                    42,
-                    43,
-                    44,
-                    45,
-                    56,
-                    57,
-                    62,
-                    63,
-                    68,
-                    69,
-                    74,
-                    75,
-                    76,
-                    77,
-                    78,
-                    79,
-                    80,
-                    81,
-                    92,
-                    93,
-                    98,
-                    99,
-                    112,
-                    113,
-                    128,
-                    129,
-                    134,
-                    135,
-                    148,
-                    149,
-                    160,
-                    161,
-                    162,
-                    163,
-                    164,
-                    165,
-                    166,
-                    167,
-                    168,
-                    169,
-                    170,
-                    171,
-                    172,
-                    173,
-                    178,
-                    179,
-                    184,
-                    185,
-                    196,
-                    197,
-                    198,
-                    199,
-                    200,
-                    201,
-                    202,
-                    203,
-                    204,
-                    205,
-                    206,
-                    207,
-                    208,
-                    209,
-                    214,
-                    215,
-                    220,
-                    221,
-                ];
-            }
-        } catch(error) {}
-
-
-                exports2.inspectOpts = Object
-            .keys(process.env)
-            .filter((key) => {
-            return /^debug_/i.test(key);
-        })
-            .reduce((obj, key) => {
-            const prop = key
-                .substring(6)
-                .toLowerCase()
-                .replace(/_([a-z])/g, (_, k) => {
-                return k.toUpperCase();
-            });
-            
-            let val = process.env[key];
-            
-            if (/^(yes|on|true|enabled)$/i.test(val)) {
-                val = true;
-            } else if (/^(no|off|false|disabled)$/i.test(val)) {
-                val = false;
-            } else if (val === 'null') {
-                val = null;
-            } else {
-                val = Number(val);
-            }
-            
-            obj[prop] = val;
-            return obj;
-        }, {});
-        function useColors() {
-            return 'colors' in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
-        }
-        
-        function formatArgs(args) {
-            const {namespace: name, useColors: useColors2} = this;
-            
-            if (useColors2) {
-                const c = this.color;
-                const colorCode = '\x1B[3' + (c < 8 ? c : '8;5;' + c);
-                const prefix2 = `  ${colorCode};1m${name} \x1B[0m`;
-                
-                args[0] = prefix2 + args[0]
-                    .split('\n')
-                    .join('\n' + prefix2);
-                args.push(colorCode + 'm+' + module2.exports.humanize(this.diff) + '\x1B[0m');
-            } else {
-                args[0] = getDate() + name + ' ' + args[0];
-            }
-        }
-        
-        function getDate() {
-            if (exports2.inspectOpts.hideDate) {
-                return '';
-            }
-            
-            return             /* @__PURE__ */new Date().toISOString() + ' ';
-        }
-        
-        function log(...args) {
-            return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + '\n');
-        }
-        
-        function save(namespaces) {
-            if (namespaces) {
-                process.env.DEBUG = namespaces;
-            } else {
-                delete process.env.DEBUG;
-            }
-        }
-        
-        function load() {
-            return process.env.DEBUG;
-        }
-        
-        function init(debug2) {
-            debug2.inspectOpts = {};
-            const keys2 = Object.keys(exports2.inspectOpts);
-            
-            for (let i = 0; i < keys2.length; i++) {
-                debug2.inspectOpts[keys2[i]] = exports2.inspectOpts[keys2[i]];
-            }
-        }
-        
-        module2.exports = require_common()(exports2);
-        var {formatters} = module2.exports;
-        
-        formatters.o = function(v) {
-            this.inspectOpts.colors = this.useColors;
-            return util
-                .inspect(v, this
-                .inspectOpts)
-                .split('\n')
-                .map((str) => str.trim())
-                .join(' ');
-        };
-        formatters.O = function(v) {
-            this.inspectOpts.colors = this.useColors;
-            return util.inspect(v, this.inspectOpts);
-        };
-    },
-});
+var require_node = () => () => {};
 
 // node_modules/debug/src/index.js
 var require_src = __commonJS({
@@ -8259,117 +7499,25 @@ function isPrivate(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isFlow(node, opts) {
+function isFlow() {}
+
+function isFlowType() {}
+
+function isFlowBaseAnnotation() {}
+
+function isFlowDeclaration() {}
+
+function isFlowPredicate() {}
+
+function isEnumBody(node, opts) {
     if (!node)
         return false;
     
     switch(node.type) {
-    case 'AnyTypeAnnotation':    
-    case 'ArrayTypeAnnotation':    
-    case 'BooleanTypeAnnotation':    
-    case 'BooleanLiteralTypeAnnotation':    
-    case 'NullLiteralTypeAnnotation':    
-    case 'ClassImplements':    
-    case 'DeclareClass':    
-    case 'DeclareFunction':    
-    case 'DeclareInterface':    
-    case 'DeclareModule':    
-    case 'DeclareModuleExports':    
-    case 'DeclareTypeAlias':    
-    case 'DeclareOpaqueType':    
-    case 'DeclareVariable':    
-    case 'DeclareExportDeclaration':    
-    case 'DeclareExportAllDeclaration':    
-    case 'DeclaredPredicate':    
-    case 'ExistsTypeAnnotation':    
-    case 'FunctionTypeAnnotation':    
-    case 'FunctionTypeParam':    
-    case 'GenericTypeAnnotation':    
-    case 'InferredPredicate':    
-    case 'InterfaceExtends':    
-    case 'InterfaceDeclaration':    
-    case 'InterfaceTypeAnnotation':    
-    case 'IntersectionTypeAnnotation':    
-    case 'MixedTypeAnnotation':    
-    case 'EmptyTypeAnnotation':    
-    case 'NullableTypeAnnotation':    
-    case 'NumberLiteralTypeAnnotation':    
-    case 'NumberTypeAnnotation':    
-    case 'ObjectTypeAnnotation':    
-    case 'ObjectTypeInternalSlot':    
-    case 'ObjectTypeCallProperty':    
-    case 'ObjectTypeIndexer':    
-    case 'ObjectTypeProperty':    
-    case 'ObjectTypeSpreadProperty':    
-    case 'OpaqueType':    
-    case 'QualifiedTypeIdentifier':    
-    case 'StringLiteralTypeAnnotation':    
-    case 'StringTypeAnnotation':    
-    case 'SymbolTypeAnnotation':    
-    case 'ThisTypeAnnotation':    
-    case 'TupleTypeAnnotation':    
-    case 'TypeofTypeAnnotation':    
-    case 'TypeAlias':    
-    case 'TypeAnnotation':    
-    case 'TypeCastExpression':    
-    case 'TypeParameter':    
-    case 'TypeParameterDeclaration':    
-    case 'TypeParameterInstantiation':    
-    case 'UnionTypeAnnotation':    
-    case 'Variance':    
-    case 'VoidTypeAnnotation':    
-    case 'EnumDeclaration':    
     case 'EnumBooleanBody':    
     case 'EnumNumberBody':    
     case 'EnumStringBody':    
-    case 'EnumSymbolBody':    
-    case 'EnumBooleanMember':    
-    case 'EnumNumberMember':    
-    case 'EnumStringMember':    
-    case 'EnumDefaultedMember':    
-    case 'IndexedAccessType':    
-    case 'OptionalIndexedAccessType':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
-function isFlowType(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'AnyTypeAnnotation':    
-    case 'ArrayTypeAnnotation':    
-    case 'BooleanTypeAnnotation':    
-    case 'BooleanLiteralTypeAnnotation':    
-    case 'NullLiteralTypeAnnotation':    
-    case 'ExistsTypeAnnotation':    
-    case 'FunctionTypeAnnotation':    
-    case 'GenericTypeAnnotation':    
-    case 'InterfaceTypeAnnotation':    
-    case 'IntersectionTypeAnnotation':    
-    case 'MixedTypeAnnotation':    
-    case 'EmptyTypeAnnotation':    
-    case 'NullableTypeAnnotation':    
-    case 'NumberLiteralTypeAnnotation':    
-    case 'NumberTypeAnnotation':    
-    case 'ObjectTypeAnnotation':    
-    case 'StringLiteralTypeAnnotation':    
-    case 'StringTypeAnnotation':    
-    case 'SymbolTypeAnnotation':    
-    case 'ThisTypeAnnotation':    
-    case 'TupleTypeAnnotation':    
-    case 'TypeofTypeAnnotation':    
-    case 'UnionTypeAnnotation':    
-    case 'VoidTypeAnnotation':    
-    case 'IndexedAccessType':    
-    case 'OptionalIndexedAccessType':
+    case 'EnumSymbolBody':
         break;
     
     default:
@@ -8380,21 +7528,15 @@ function isFlowType(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isFlowBaseAnnotation(node, opts) {
+function isEnumMember(node, opts) {
     if (!node)
         return false;
     
     switch(node.type) {
-    case 'AnyTypeAnnotation':    
-    case 'BooleanTypeAnnotation':    
-    case 'NullLiteralTypeAnnotation':    
-    case 'MixedTypeAnnotation':    
-    case 'EmptyTypeAnnotation':    
-    case 'NumberTypeAnnotation':    
-    case 'StringTypeAnnotation':    
-    case 'SymbolTypeAnnotation':    
-    case 'ThisTypeAnnotation':    
-    case 'VoidTypeAnnotation':
+    case 'EnumBooleanMember':    
+    case 'EnumNumberMember':    
+    case 'EnumStringMember':    
+    case 'EnumDefaultedMember':
         break;
     
     default:
@@ -8405,90 +7547,7 @@ function isFlowBaseAnnotation(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isFlowDeclaration(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'DeclareClass':    
-    case 'DeclareFunction':    
-    case 'DeclareInterface':    
-    case 'DeclareModule':    
-    case 'DeclareModuleExports':    
-    case 'DeclareTypeAlias':    
-    case 'DeclareOpaqueType':    
-    case 'DeclareVariable':    
-    case 'DeclareExportDeclaration':    
-    case 'DeclareExportAllDeclaration':    
-    case 'InterfaceDeclaration':    
-    case 'OpaqueType':    
-    case 'TypeAlias':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
-function isFlowPredicate(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'DeclaredPredicate':    
-    case 'InferredPredicate':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
-function isEnumBody(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'EnumBooleanBody':    
-    case 'EnumNumberBody':    
-    case 'EnumStringBody':    
-    case 'EnumSymbolBody':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
-function isEnumMember(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'EnumBooleanMember':    
-    case 'EnumNumberMember':    
-    case 'EnumStringMember':    
-    case 'EnumDefaultedMember':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
-function isJSX(node, opts) {
+function isJSX(node, opts) {
     if (!node)
         return false;
     
@@ -22431,59 +21490,6 @@ var reservedTypes = /* @__PURE__ */new Set([
     'void',
 ]);
 
-var FlowErrors = ParseErrorEnum`flow`({
-    AmbiguousConditionalArrow: 'Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.',
-    AmbiguousDeclareModuleKind: 'Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.',
-    AssignReservedType: ({reservedType}) => `Cannot overwrite reserved type ${reservedType}.`,
-    DeclareClassElement: 'The `declare` modifier can only appear on class fields.',
-    DeclareClassFieldInitializer: 'Initializers are not allowed in fields with the `declare` modifier.',
-    DuplicateDeclareModuleExports: 'Duplicate `declare module.exports` statement.',
-    EnumBooleanMemberNotInitialized: ({memberName, enumName}) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
-    EnumDuplicateMemberName: ({memberName, enumName}) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
-    EnumInconsistentMemberValues: ({enumName}) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
-    EnumInvalidExplicitType: ({invalidEnumType, enumName}) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-    EnumInvalidExplicitTypeUnknownSupplied: ({enumName}) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-    EnumInvalidMemberInitializerPrimaryType: ({enumName, memberName, explicitType}) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
-    EnumInvalidMemberInitializerSymbolType: ({enumName, memberName}) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
-    EnumInvalidMemberInitializerUnknownType: ({enumName, memberName}) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
-    EnumInvalidMemberName: ({enumName, memberName, suggestion}) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
-    EnumNumberMemberNotInitialized: ({enumName, memberName}) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
-    EnumStringMemberInconsistentlyInitialized: ({enumName}) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
-    GetterMayNotHaveThisParam: 'A getter cannot have a `this` parameter.',
-    ImportReflectionHasImportType: 'An `import module` declaration can not use `type` or `typeof` keyword.',
-    ImportTypeShorthandOnlyInPureImport: 'The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.',
-    InexactInsideExact: 'Explicit inexact syntax cannot appear inside an explicit exact object type.',
-    InexactInsideNonObject: 'Explicit inexact syntax cannot appear in class or interface definitions.',
-    InexactVariance: 'Explicit inexact syntax cannot have variance.',
-    InvalidNonTypeImportInDeclareModule: 'Imports within a `declare module` body must always be `import type` or `import typeof`.',
-    MissingTypeParamDefault: 'Type parameter declaration needs a default, since a preceding type parameter declaration has a default.',
-    NestedDeclareModule: '`declare module` cannot be used inside another `declare module`.',
-    NestedFlowComment: 'Cannot have a flow comment inside another flow comment.',
-    PatternIsOptional: Object.assign({
-        message: 'A binding pattern parameter cannot be optional in an implementation signature.',
-    }, {}),
-    SetterMayNotHaveThisParam: 'A setter cannot have a `this` parameter.',
-    SpreadVariance: 'Spread properties cannot have variance.',
-    ThisParamAnnotationRequired: 'A type annotation is required for the `this` parameter.',
-    ThisParamBannedInConstructor: 'Constructors cannot have a `this` parameter; constructors don\'t bind `this` like other functions.',
-    ThisParamMayNotBeOptional: 'The `this` parameter cannot be optional.',
-    ThisParamMustBeFirst: 'The `this` parameter must be the first function parameter.',
-    ThisParamNoDefault: 'The `this` parameter may not have a default value.',
-    TypeBeforeInitializer: 'Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.',
-    TypeCastInPattern: 'The type cast expression is expected to be wrapped with parenthesis.',
-    UnexpectedExplicitInexactInObject: 'Explicit inexact syntax must appear at the end of an inexact object.',
-    UnexpectedReservedType: ({reservedType}) => `Unexpected reserved type ${reservedType}.`,
-    UnexpectedReservedUnderscore: '`_` is only allowed as a type argument to call or new.',
-    UnexpectedSpaceBetweenModuloChecks: 'Spaces between `%` and `checks` are not allowed here.',
-    UnexpectedSpreadType: 'Spread operator cannot appear in class or interface definitions.',
-    UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".',
-    UnexpectedTokenAfterTypeParameter: 'Expected an arrow function after this type parameter declaration.',
-    UnexpectedTypeParameterBeforeAsyncArrowFunction: 'Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.',
-    UnsupportedDeclareExportKind: ({unsupportedExportKind, suggestion}) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
-    UnsupportedStatementInDeclareModule: 'Only declares and type imports are allowed inside declare module.',
-    UnterminatedFlowComment: 'Unterminated flow-comment.',
-});
-
 function isEsModuleType(bodyElement) {
     return bodyElement.type === 'DeclareExportAllDeclaration'
         || bodyElement.type === 'DeclareExportDeclaration'
@@ -22516,2893 +21522,6 @@ function partition(list, test) {
 
 var FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
 
-var flow = (superClass) => class FlowParserMixin extends superClass {
-    constructor() {
-        super(...arguments);
-        __publicField(this, 'flowPragma');
-    }
-    
-    getScopeHandler() {
-        return FlowScopeHandler;
-    }
-    
-    shouldParseTypes() {
-        return this.getPluginOption('flow', 'all') || this.flowPragma === 'flow';
-    }
-    
-    finishToken(type, val) {
-        if (type !== 134 && type !== 13 && type !== 28) {
-            if (this.flowPragma === void 0) {
-                this.flowPragma = null;
-            }
-        }
-        
-        super.finishToken(type, val);
-    }
-    
-    addComment(comment) {
-        if (this.flowPragma === void 0) {
-            const matches = FLOW_PRAGMA_REGEX.exec(comment.value);
-            
-            if (!matches);
- else if (matches[1] === 'flow') {
-                this.flowPragma = 'flow';
-            } else if (matches[1] === 'noflow') {
-                this.flowPragma = 'noflow';
-            } else {
-                throw new Error('Unexpected flow pragma');
-            }
-
-        }
-        
-        super.addComment(comment);
-    }
-    
-    flowParseTypeInitialiser(tok) {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        this.expect(tok || 14);
-        const type = this.flowParseType();
-        
-        this.state.inType = oldInType;
-        return type;
-    }
-    
-    flowParsePredicate() {
-        const node = this.startNode();
-        const moduloLoc = this.state.startLoc;
-        this.next();
-        this.expectContextual(110);
-        
-        if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {
-            this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
-        }
-        
-        if (this.eat(10)) {
-            node.value = super.parseExpression();
-            this.expect(11);
-            return this.finishNode(node, 'DeclaredPredicate');
-        } else {
-            return this.finishNode(node, 'InferredPredicate');
-        }
-    }
-    
-    flowParseTypeAndPredicateInitialiser() {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        this.expect(14);
-        let type = null;
-        let predicate = null;
-        
-        if (this.match(54)) {
-            this.state.inType = oldInType;
-            predicate = this.flowParsePredicate();
-        } else {
-            type = this.flowParseType();
-            this.state.inType = oldInType;
-            
-            if (this.match(54)) {
-                predicate = this.flowParsePredicate();
-            }
-        }
-        
-        return [type, predicate];
-    }
-    
-    flowParseDeclareClass(node) {
-        this.next();
-        this.flowParseInterfaceish(node, true);
-        return this.finishNode(node, 'DeclareClass');
-    }
-    
-    flowParseDeclareFunction(node) {
-        this.next();
-        const id = node.id = this.parseIdentifier();
-        const typeNode = this.startNode();
-        const typeContainer = this.startNode();
-        
-        if (this.match(47)) {
-            typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            typeNode.typeParameters = null;
-        }
-        
-        this.expect(10);
-        const tmp = this.flowParseFunctionTypeParams();
-        
-        typeNode.params = tmp.params;
-        typeNode.rest = tmp.rest;
-        typeNode.this = tmp._this;
-        this.expect(11);
-        [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-        typeContainer.typeAnnotation = this.finishNode(typeNode, 'FunctionTypeAnnotation');
-        id.typeAnnotation = this.finishNode(typeContainer, 'TypeAnnotation');
-        this.resetEndLocation(id);
-        this.semicolon();
-        this.scope.declareName(node.id.name, 2048, node.id.loc.start);
-        return this.finishNode(node, 'DeclareFunction');
-    }
-    
-    flowParseDeclare(node, insideModule) {
-        if (this.match(80)) {
-            return this.flowParseDeclareClass(node);
-        } else if (this.match(68)) {
-            return this.flowParseDeclareFunction(node);
-        } else if (this.match(74)) {
-            return this.flowParseDeclareVariable(node);
-        } else if (this.eatContextual(127)) {
-            if (this.match(16)) {
-                return this.flowParseDeclareModuleExports(node);
-            } else {
-                if (insideModule) {
-                    this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);
-                }
-                
-                return this.flowParseDeclareModule(node);
-            }
-        } else if (this.isContextual(130)) {
-            return this.flowParseDeclareTypeAlias(node);
-        } else if (this.isContextual(131)) {
-            return this.flowParseDeclareOpaqueType(node);
-        } else if (this.isContextual(129)) {
-            return this.flowParseDeclareInterface(node);
-        } else if (this.match(82)) {
-            return this.flowParseDeclareExportDeclaration(node, insideModule);
-        } else {
-            this.unexpected();
-        }
-
-
-
-
-
-
-    }
-    
-    flowParseDeclareVariable(node) {
-        this.next();
-        node.id = this.flowParseTypeAnnotatableIdentifier(true);
-        this.scope.declareName(node.id.name, 5, node.id.loc.start);
-        this.semicolon();
-        return this.finishNode(node, 'DeclareVariable');
-    }
-    
-    flowParseDeclareModule(node) {
-        this.scope.enter(0);
-        
-        if (this.match(134)) {
-            node.id = super.parseExprAtom();
-        } else {
-            node.id = this.parseIdentifier();
-        }
-        
-        const bodyNode = node.body = this.startNode();
-        const body = bodyNode.body = [];
-        
-        this.expect(5);
-        while (!this.match(8)) {
-            let bodyNode2 = this.startNode();
-            
-            if (this.match(83)) {
-                this.next();
-                
-                if (!this.isContextual(130) && !this.match(87)) {
-                    this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
-                }
-                
-                super.parseImport(bodyNode2);
-            } else {
-                this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule);
-                bodyNode2 = this.flowParseDeclare(bodyNode2, true);
-            }
-            
-            body.push(bodyNode2);
-        }
-        
-        this.scope.exit();
-        this.expect(8);
-        this.finishNode(bodyNode, 'BlockStatement');
-        let kind = null;
-        let hasModuleExport = false;
-        
-        body.forEach((bodyElement) => {
-            if (isEsModuleType(bodyElement)) {
-                if (kind === 'CommonJS') {
-                    this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
-                }
-                
-                kind = 'ES';
-            } else if (bodyElement.type === 'DeclareModuleExports') {
-                if (hasModuleExport) {
-                    this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);
-                }
-                
-                if (kind === 'ES') {
-                    this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
-                }
-                
-                kind = 'CommonJS';
-                hasModuleExport = true;
-            }
-        });
-        node.kind = kind || 'CommonJS';
-        return this.finishNode(node, 'DeclareModule');
-    }
-    
-    flowParseDeclareExportDeclaration(node, insideModule) {
-        this.expect(82);
-        
-        if (this.eat(65)) {
-            if (this.match(68) || this.match(80)) {
-                node.declaration = this.flowParseDeclare(this.startNode());
-            } else {
-                node.declaration = this.flowParseType();
-                this.semicolon();
-            }
-            
-            node.default = true;
-            return this.finishNode(node, 'DeclareExportDeclaration');
-        } else {
-            if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {
-                const label = this.state.value;
-                
-                throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {
-                    unsupportedExportKind: label,
-                    suggestion: exportSuggestions[label],
-                });
-            }
-            
-            if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) {
-                node.declaration = this.flowParseDeclare(this.startNode());
-                node.default = false;
-                return this.finishNode(node, 'DeclareExportDeclaration');
-            } else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) {
-                node = this.parseExport(node, null);
-                
-                if (node.type === 'ExportNamedDeclaration') {
-                    node.default = false;
-                    delete node.exportKind;
-                    return this.castNodeTo(node, 'DeclareExportDeclaration');
-                } else {
-                    return this.castNodeTo(node, 'DeclareExportAllDeclaration');
-                }
-            }
-        }
-        
-        this.unexpected();
-    }
-    
-    flowParseDeclareModuleExports(node) {
-        this.next();
-        this.expectContextual(111);
-        node.typeAnnotation = this.flowParseTypeAnnotation();
-        this.semicolon();
-        return this.finishNode(node, 'DeclareModuleExports');
-    }
-    
-    flowParseDeclareTypeAlias(node) {
-        this.next();
-        const finished = this.flowParseTypeAlias(node);
-        this.castNodeTo(finished, 'DeclareTypeAlias');
-        return finished;
-    }
-    
-    flowParseDeclareOpaqueType(node) {
-        this.next();
-        const finished = this.flowParseOpaqueType(node, true);
-        this.castNodeTo(finished, 'DeclareOpaqueType');
-        return finished;
-    }
-    
-    flowParseDeclareInterface(node) {
-        this.next();
-        this.flowParseInterfaceish(node, false);
-        return this.finishNode(node, 'DeclareInterface');
-    }
-    
-    flowParseInterfaceish(node, isClass3) {
-        node.id = this.flowParseRestrictedIdentifier(!isClass3, true);
-        this.scope.declareName(node.id.name, isClass3 ? 17 : 8201, node.id.loc.start);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        node.extends = [];
-        
-        if (this.eat(81)) {
-            do {
-                node.extends.push(this.flowParseInterfaceExtends());
-            } while (!isClass3 && this.eat(12))
-        }
-        
-        if (isClass3) {
-            node.implements = [];
-            node.mixins = [];
-            
-            if (this.eatContextual(117)) {
-                do {
-                    node.mixins.push(this.flowParseInterfaceExtends());
-                } while (this.eat(12))
-            }
-            
-            if (this.eatContextual(113)) {
-                do {
-                    node.implements.push(this.flowParseInterfaceExtends());
-                } while (this.eat(12))
-            }
-        }
-        
-        node.body = this.flowParseObjectType({
-            allowStatic: isClass3,
-            allowExact: false,
-            allowSpread: false,
-            allowProto: isClass3,
-            allowInexact: false,
-        });
-    }
-    
-    flowParseInterfaceExtends() {
-        const node = this.startNode();
-        
-        node.id = this.flowParseQualifiedTypeIdentifier();
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterInstantiation();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        return this.finishNode(node, 'InterfaceExtends');
-    }
-    
-    flowParseInterface(node) {
-        this.flowParseInterfaceish(node, false);
-        return this.finishNode(node, 'InterfaceDeclaration');
-    }
-    
-    checkNotUnderscore(word) {
-        if (word === '_') {
-            this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);
-        }
-    }
-    
-    checkReservedType(word, startLoc, declaration) {
-        if (!reservedTypes.has(word))
-            return;
-        
-        this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, {
-            reservedType: word,
-        });
-    }
-    
-    flowParseRestrictedIdentifier(liberal, declaration) {
-        this.checkReservedType(this.state.value, this.state.startLoc, declaration);
-        return this.parseIdentifier(liberal);
-    }
-    
-    flowParseTypeAlias(node) {
-        node.id = this.flowParseRestrictedIdentifier(false, true);
-        this.scope.declareName(node.id.name, 8201, node.id.loc.start);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        node.right = this.flowParseTypeInitialiser(29);
-        this.semicolon();
-        return this.finishNode(node, 'TypeAlias');
-    }
-    
-    flowParseOpaqueType(node, declare) {
-        this.expectContextual(130);
-        node.id = this.flowParseRestrictedIdentifier(true, true);
-        this.scope.declareName(node.id.name, 8201, node.id.loc.start);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        node.supertype = null;
-        
-        if (this.match(14)) {
-            node.supertype = this.flowParseTypeInitialiser(14);
-        }
-        
-        node.impltype = null;
-        
-        if (!declare) {
-            node.impltype = this.flowParseTypeInitialiser(29);
-        }
-        
-        this.semicolon();
-        return this.finishNode(node, 'OpaqueType');
-    }
-    
-    flowParseTypeParameter(requireDefault = false) {
-        const nodeStartLoc = this.state.startLoc;
-        const node = this.startNode();
-        const variance2 = this.flowParseVariance();
-        const ident = this.flowParseTypeAnnotatableIdentifier();
-        
-        node.name = ident.name;
-        node.variance = variance2;
-        node.bound = ident.typeAnnotation;
-        
-        if (this.match(29)) {
-            this.eat(29);
-            node.default = this.flowParseType();
-        } else {
-            if (requireDefault) {
-                this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
-            }
-        }
-        
-        return this.finishNode(node, 'TypeParameter');
-    }
-    
-    flowParseTypeParameterDeclaration() {
-        const oldInType = this.state.inType;
-        const node = this.startNode();
-        
-        node.params = [];
-        this.state.inType = true;
-        
-        if (this.match(47) || this.match(143)) {
-            this.next();
-        } else {
-            this.unexpected();
-        }
-        
-        let defaultRequired = false;
-        
-        do {
-            const typeParameter2 = this.flowParseTypeParameter(defaultRequired);
-            node.params.push(typeParameter2);
-            
-            if (typeParameter2.default) {
-                defaultRequired = true;
-            }
-            
-            if (!this.match(48)) {
-                this.expect(12);
-            }
-        } while (!this.match(48))
-        this.expect(48);
-        this.state.inType = oldInType;
-        return this.finishNode(node, 'TypeParameterDeclaration');
-    }
-    
-    flowInTopLevelContext(cb) {
-        if (this.curContext() !== types.brace) {
-            const oldContext = this.state.context;
-            
-            this.state.context = [oldContext[0]];
-            try {
-                return cb();
-            } finally {
-                this.state.context = oldContext;
-            }
-        } else {
-            return cb();
-        }
-    }
-    
-    flowParseTypeParameterInstantiationInExpression() {
-        if (this.reScan_lt() !== 47)
-            return;
-        
-        return this.flowParseTypeParameterInstantiation();
-    }
-    
-    flowParseTypeParameterInstantiation() {
-        const node = this.startNode();
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        node.params = [];
-        this.flowInTopLevelContext(() => {
-            this.expect(47);
-            const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-            
-            this.state.noAnonFunctionType = false;
-            while (!this.match(48)) {
-                node.params.push(this.flowParseType());
-                
-                if (!this.match(48)) {
-                    this.expect(12);
-                }
-            }
-            
-            this.state.noAnonFunctionType = oldNoAnonFunctionType;
-        });
-        this.state.inType = oldInType;
-        
-        if (!this.state.inType && this.curContext() === types.brace) {
-            this.reScan_lt_gt();
-        }
-        
-        this.expect(48);
-        return this.finishNode(node, 'TypeParameterInstantiation');
-    }
-    
-    flowParseTypeParameterInstantiationCallOrNew() {
-        if (this.reScan_lt() !== 47)
-            return;
-        
-        const node = this.startNode();
-        const oldInType = this.state.inType;
-        
-        node.params = [];
-        this.state.inType = true;
-        this.expect(47);
-        while (!this.match(48)) {
-            node.params.push(this.flowParseTypeOrImplicitInstantiation());
-            
-            if (!this.match(48)) {
-                this.expect(12);
-            }
-        }
-        
-        this.expect(48);
-        this.state.inType = oldInType;
-        return this.finishNode(node, 'TypeParameterInstantiation');
-    }
-    
-    flowParseInterfaceType() {
-        const node = this.startNode();
-        this.expectContextual(129);
-        node.extends = [];
-        
-        if (this.eat(81)) {
-            do {
-                node.extends.push(this.flowParseInterfaceExtends());
-            } while (this.eat(12))
-        }
-        
-        node.body = this.flowParseObjectType({
-            allowStatic: false,
-            allowExact: false,
-            allowSpread: false,
-            allowProto: false,
-            allowInexact: false,
-        });
-        return this.finishNode(node, 'InterfaceTypeAnnotation');
-    }
-    
-    flowParseObjectPropertyKey() {
-        return this.match(135) || this.match(134) ? super.parseExprAtom() : this.parseIdentifier(true);
-    }
-    
-    flowParseObjectTypeIndexer(node, isStatic2, variance2) {
-        node.static = isStatic2;
-        
-        if (this.lookahead().type === 14) {
-            node.id = this.flowParseObjectPropertyKey();
-            node.key = this.flowParseTypeInitialiser();
-        } else {
-            node.id = null;
-            node.key = this.flowParseType();
-        }
-        
-        this.expect(3);
-        node.value = this.flowParseTypeInitialiser();
-        node.variance = variance2;
-        return this.finishNode(node, 'ObjectTypeIndexer');
-    }
-    
-    flowParseObjectTypeInternalSlot(node, isStatic2) {
-        node.static = isStatic2;
-        node.id = this.flowParseObjectPropertyKey();
-        this.expect(3);
-        this.expect(3);
-        
-        if (this.match(47) || this.match(10)) {
-            node.method = true;
-            node.optional = false;
-            node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
-        } else {
-            node.method = false;
-            
-            if (this.eat(17)) {
-                node.optional = true;
-            }
-            
-            node.value = this.flowParseTypeInitialiser();
-        }
-        
-        return this.finishNode(node, 'ObjectTypeInternalSlot');
-    }
-    
-    flowParseObjectTypeMethodish(node) {
-        node.params = [];
-        node.rest = null;
-        node.typeParameters = null;
-        node.this = null;
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        this.expect(10);
-        
-        if (this.match(78)) {
-            node.this = this.flowParseFunctionTypeParam(true);
-            node.this.name = null;
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        while (!this.match(11) && !this.match(21)) {
-            node.params.push(this.flowParseFunctionTypeParam(false));
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        if (this.eat(21)) {
-            node.rest = this.flowParseFunctionTypeParam(false);
-        }
-        
-        this.expect(11);
-        node.returnType = this.flowParseTypeInitialiser();
-        return this.finishNode(node, 'FunctionTypeAnnotation');
-    }
-    
-    flowParseObjectTypeCallProperty(node, isStatic2) {
-        const valueNode = this.startNode();
-        
-        node.static = isStatic2;
-        node.value = this.flowParseObjectTypeMethodish(valueNode);
-        return this.finishNode(node, 'ObjectTypeCallProperty');
-    }
-    
-    flowParseObjectType({allowStatic, allowExact, allowSpread, allowProto, allowInexact}) {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        const nodeStart = this.startNode();
-        
-        nodeStart.callProperties = [];
-        nodeStart.properties = [];
-        nodeStart.indexers = [];
-        nodeStart.internalSlots = [];
-        let endDelim;
-        let exact;
-        let inexact = false;
-        
-        if (allowExact && this.match(6)) {
-            this.expect(6);
-            endDelim = 9;
-            exact = true;
-        } else {
-            this.expect(5);
-            endDelim = 8;
-            exact = false;
-        }
-        
-        nodeStart.exact = exact;
-        while (!this.match(endDelim)) {
-            let isStatic2 = false;
-            let protoStartLoc = null;
-            let inexactStartLoc = null;
-            const node = this.startNode();
-            
-            if (allowProto && this.isContextual(118)) {
-                const lookahead = this.lookahead();
-                
-                if (lookahead.type !== 14 && lookahead.type !== 17) {
-                    this.next();
-                    protoStartLoc = this.state.startLoc;
-                    allowStatic = false;
-                }
-            }
-            
-            if (allowStatic && this.isContextual(106)) {
-                const lookahead = this.lookahead();
-                
-                if (lookahead.type !== 14 && lookahead.type !== 17) {
-                    this.next();
-                    isStatic2 = true;
-                }
-            }
-            
-            const variance2 = this.flowParseVariance();
-            
-            if (this.eat(0)) {
-                if (protoStartLoc != null) {
-                    this.unexpected(protoStartLoc);
-                }
-                
-                if (this.eat(0)) {
-                    if (variance2) {
-                        this.unexpected(variance2.loc.start);
-                    }
-                    
-                    nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic2));
-                } else {
-                    nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic2, variance2));
-                }
-            } else if (this.match(10) || this.match(47)) {
-                if (protoStartLoc != null) {
-                    this.unexpected(protoStartLoc);
-                }
-                
-                if (variance2) {
-                    this.unexpected(variance2.loc.start);
-                }
-                
-                nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic2));
-            } else {
-                let kind = 'init';
-                
-                if (this.isContextual(99) || this.isContextual(104)) {
-                    const lookahead = this.lookahead();
-                    
-                    if (tokenIsLiteralPropertyName(lookahead.type)) {
-                        kind = this.state.value;
-                        this.next();
-                    }
-                }
-                
-                const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic2, protoStartLoc, variance2, kind, allowSpread, allowInexact ?? !exact);
-                
-                if (propOrInexact === null) {
-                    inexact = true;
-                    inexactStartLoc = this.state.lastTokStartLoc;
-                } else {
-                    nodeStart.properties.push(propOrInexact);
-                }
-            }
-            
-            this.flowObjectTypeSemicolon();
-            
-            if (inexactStartLoc && !this.match(8) && !this.match(9)) {
-                this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);
-            }
-        }
-        
-        this.expect(endDelim);
-        
-        if (allowSpread) {
-            nodeStart.inexact = inexact;
-        }
-        
-        const out = this.finishNode(nodeStart, 'ObjectTypeAnnotation');
-        
-        this.state.inType = oldInType;
-        return out;
-    }
-    
-    flowParseObjectTypeProperty(node, isStatic2, protoStartLoc, variance2, kind, allowSpread, allowInexact) {
-        if (this.eat(21)) {
-            const isInexactToken = this.match(12)
-                || this.match(13)
-                || this.match(8)
-                || this.match(9);
-            
-            if (isInexactToken) {
-                if (!allowSpread) {
-                    this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);
-                } else if (!allowInexact) {
-                    this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);
-                }
-                
-                if (variance2) {
-                    this.raise(FlowErrors.InexactVariance, variance2);
-                }
-                
-                return null;
-            }
-            
-            if (!allowSpread) {
-                this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);
-            }
-            
-            if (protoStartLoc != null) {
-                this.unexpected(protoStartLoc);
-            }
-            
-            if (variance2) {
-                this.raise(FlowErrors.SpreadVariance, variance2);
-            }
-            
-            node.argument = this.flowParseType();
-            return this.finishNode(node, 'ObjectTypeSpreadProperty');
-        } else {
-            node.key = this.flowParseObjectPropertyKey();
-            node.static = isStatic2;
-            node.proto = protoStartLoc != null;
-            node.kind = kind;
-            let optional = false;
-            
-            if (this.match(47) || this.match(10)) {
-                node.method = true;
-                
-                if (protoStartLoc != null) {
-                    this.unexpected(protoStartLoc);
-                }
-                
-                if (variance2) {
-                    this.unexpected(variance2.loc.start);
-                }
-                
-                node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
-                
-                if (kind === 'get' || kind === 'set') {
-                    this.flowCheckGetterSetterParams(node);
-                }
-                
-                if (!allowSpread && node.key.name === 'constructor' && node.value.this) {
-                    this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);
-                }
-            } else {
-                if (kind !== 'init')
-                    this.unexpected();
-                
-                node.method = false;
-                
-                if (this.eat(17)) {
-                    optional = true;
-                }
-                
-                node.value = this.flowParseTypeInitialiser();
-                node.variance = variance2;
-            }
-            
-            node.optional = optional;
-            return this.finishNode(node, 'ObjectTypeProperty');
-        }
-    }
-    
-    flowCheckGetterSetterParams(property) {
-        const paramCount = property.kind === 'get' ? 0 : 1;
-        const length = property.value.params.length + (property.value.rest ? 1 : 0);
-        
-        if (property.value.this) {
-            this.raise(property.kind === 'get' ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value.this);
-        }
-        
-        if (length !== paramCount) {
-            this.raise(property.kind === 'get' ? Errors.BadGetterArity : Errors.BadSetterArity, property);
-        }
-        
-        if (property.kind === 'set' && property.value.rest) {
-            this.raise(Errors.BadSetterRestParameter, property);
-        }
-    }
-    
-    flowObjectTypeSemicolon() {
-        if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
-            this.unexpected();
-        }
-    }
-    
-    flowParseQualifiedTypeIdentifier(startLoc, id) {
-        startLoc ?? (startLoc = this.state.startLoc);
-        let node = id || this.flowParseRestrictedIdentifier(true);
-        
-        while (this.eat(16)) {
-            const node2 = this.startNodeAt(startLoc);
-            
-            node2.qualification = node;
-            node2.id = this.flowParseRestrictedIdentifier(true);
-            node = this.finishNode(node2, 'QualifiedTypeIdentifier');
-        }
-        
-        return node;
-    }
-    
-    flowParseGenericType(startLoc, id) {
-        const node = this.startNodeAt(startLoc);
-        
-        node.typeParameters = null;
-        node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterInstantiation();
-        }
-        
-        return this.finishNode(node, 'GenericTypeAnnotation');
-    }
-    
-    flowParseTypeofType() {
-        const node = this.startNode();
-        this.expect(87);
-        node.argument = this.flowParsePrimaryType();
-        return this.finishNode(node, 'TypeofTypeAnnotation');
-    }
-    
-    flowParseTupleType() {
-        const node = this.startNode();
-        
-        node.types = [];
-        this.expect(0);
-        while (this.state.pos < this.length && !this.match(3)) {
-            node.types.push(this.flowParseType());
-            
-            if (this.match(3))
-                break;
-            
-            this.expect(12);
-        }
-        
-        this.expect(3);
-        return this.finishNode(node, 'TupleTypeAnnotation');
-    }
-    
-    flowParseFunctionTypeParam(first) {
-        let name = null;
-        let optional = false;
-        let typeAnnotation2 = null;
-        const node = this.startNode();
-        const lh = this.lookahead();
-        const isThis = this.state.type === 78;
-        
-        if (lh.type === 14 || lh.type === 17) {
-            if (isThis && !first) {
-                this.raise(FlowErrors.ThisParamMustBeFirst, node);
-            }
-            
-            name = this.parseIdentifier(isThis);
-            
-            if (this.eat(17)) {
-                optional = true;
-                
-                if (isThis) {
-                    this.raise(FlowErrors.ThisParamMayNotBeOptional, node);
-                }
-            }
-            
-            typeAnnotation2 = this.flowParseTypeInitialiser();
-        } else {
-            typeAnnotation2 = this.flowParseType();
-        }
-        
-        node.name = name;
-        node.optional = optional;
-        node.typeAnnotation = typeAnnotation2;
-        return this.finishNode(node, 'FunctionTypeParam');
-    }
-    
-    reinterpretTypeAsFunctionTypeParam(type) {
-        const node = this.startNodeAt(type.loc.start);
-        
-        node.name = null;
-        node.optional = false;
-        node.typeAnnotation = type;
-        return this.finishNode(node, 'FunctionTypeParam');
-    }
-    
-    flowParseFunctionTypeParams(params = []) {
-        let rest = null;
-        let _this = null;
-        
-        if (this.match(78)) {
-            _this = this.flowParseFunctionTypeParam(true);
-            _this.name = null;
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        while (!this.match(11) && !this.match(21)) {
-            params.push(this.flowParseFunctionTypeParam(false));
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        if (this.eat(21)) {
-            rest = this.flowParseFunctionTypeParam(false);
-        }
-        
-        return {
-            params,
-            rest,
-            _this,
-        };
-    }
-    
-    flowIdentToTypeAnnotation(startLoc, node, id) {
-        switch(id.name) {
-        case 'any':
-            return this.finishNode(node, 'AnyTypeAnnotation');
-        
-        case 'bool':        
-        case 'boolean':
-            return this.finishNode(node, 'BooleanTypeAnnotation');
-        
-        case 'mixed':
-            return this.finishNode(node, 'MixedTypeAnnotation');
-        
-        case 'empty':
-            return this.finishNode(node, 'EmptyTypeAnnotation');
-        
-        case 'number':
-            return this.finishNode(node, 'NumberTypeAnnotation');
-        
-        case 'string':
-            return this.finishNode(node, 'StringTypeAnnotation');
-        
-        case 'symbol':
-            return this.finishNode(node, 'SymbolTypeAnnotation');
-        
-        default:
-            this.checkNotUnderscore(id.name);
-            return this.flowParseGenericType(startLoc, id);
-        }
-    }
-    
-    flowParsePrimaryType() {
-        const startLoc = this.state.startLoc;
-        const node = this.startNode();
-        let tmp;
-        let type;
-        let isGroupedType = false;
-        const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-        
-        switch(this.state.type) {
-        case 5:
-            return this.flowParseObjectType({
-                allowStatic: false,
-                allowExact: false,
-                allowSpread: true,
-                allowProto: false,
-                allowInexact: true,
-            });
-        
-        case 6:
-            return this.flowParseObjectType({
-                allowStatic: false,
-                allowExact: true,
-                allowSpread: true,
-                allowProto: false,
-                allowInexact: false,
-            });
-        
-        case 0:
-            this.state.noAnonFunctionType = false;
-            type = this.flowParseTupleType();
-            this.state.noAnonFunctionType = oldNoAnonFunctionType;
-            return type;
-        
-        case 47: {
-            const node2 = this.startNode();
-            
-            node2.typeParameters = this.flowParseTypeParameterDeclaration();
-            this.expect(10);
-            tmp = this.flowParseFunctionTypeParams();
-            node2.params = tmp.params;
-            node2.rest = tmp.rest;
-            node2.this = tmp._this;
-            this.expect(11);
-            this.expect(19);
-            node2.returnType = this.flowParseType();
-            return this.finishNode(node2, 'FunctionTypeAnnotation');
-        }
-        
-        case 10: {
-            const node2 = this.startNode();
-            this.next();
-            
-            if (!this.match(11) && !this.match(21)) {
-                if (tokenIsIdentifier(this.state.type) || this.match(78)) {
-                    const token = this.lookahead().type;
-                    isGroupedType = token !== 17 && token !== 14;
-                } else {
-                    isGroupedType = true;
-                }
-            }
-            
-            if (isGroupedType) {
-                this.state.noAnonFunctionType = false;
-                type = this.flowParseType();
-                this.state.noAnonFunctionType = oldNoAnonFunctionType;
-                
-                if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
-                    this.expect(11);
-                    return type;
-                } else {
-                    this.eat(12);
-                }
-            }
-            
-            if (type) {
-                tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
-            } else {
-                tmp = this.flowParseFunctionTypeParams();
-            }
-            
-            node2.params = tmp.params;
-            node2.rest = tmp.rest;
-            node2.this = tmp._this;
-            this.expect(11);
-            this.expect(19);
-            node2.returnType = this.flowParseType();
-            node2.typeParameters = null;
-            return this.finishNode(node2, 'FunctionTypeAnnotation');
-        }
-        
-        case 134:
-            return this.parseLiteral(this.state.value, 'StringLiteralTypeAnnotation');
-        
-        case 85:        
-        case 86:
-            node.value = this.match(85);
-            this.next();
-            return this.finishNode(node, 'BooleanLiteralTypeAnnotation');
-        
-        case 53:
-            if (this.state.value === '-') {
-                this.next();
-                
-                if (this.match(135)) {
-                    return this.parseLiteralAtNode(-this.state.value, 'NumberLiteralTypeAnnotation', node);
-                }
-                
-                if (this.match(136)) {
-                    return this.parseLiteralAtNode(-this.state.value, 'BigIntLiteralTypeAnnotation', node);
-                }
-                
-                throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);
-            }
-            
-            this.unexpected();
-            return;
-        
-        case 135:
-            return this.parseLiteral(this.state.value, 'NumberLiteralTypeAnnotation');
-        
-        case 136:
-            return this.parseLiteral(this.state.value, 'BigIntLiteralTypeAnnotation');
-        
-        case 88:
-            this.next();
-            return this.finishNode(node, 'VoidTypeAnnotation');
-        
-        case 84:
-            this.next();
-            return this.finishNode(node, 'NullLiteralTypeAnnotation');
-        
-        case 78:
-            this.next();
-            return this.finishNode(node, 'ThisTypeAnnotation');
-        
-        case 55:
-            this.next();
-            return this.finishNode(node, 'ExistsTypeAnnotation');
-        
-        case 87:
-            return this.flowParseTypeofType();
-        
-        default:
-            if (tokenIsKeyword(this.state.type)) {
-                const label = tokenLabelName(this.state.type);
-                this.next();
-                return super.createIdentifier(node, label);
-            } else if (tokenIsIdentifier(this.state.type)) {
-                if (this.isContextual(129)) {
-                    return this.flowParseInterfaceType();
-                }
-                
-                return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
-            }
-        }
-        
-        this.unexpected();
-    }
-    
-    flowParsePostfixType() {
-        const startLoc = this.state.startLoc;
-        let type = this.flowParsePrimaryType();
-        let seenOptionalIndexedAccess = false;
-        
-        while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
-            const node = this.startNodeAt(startLoc);
-            const optional = this.eat(18);
-            
-            seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
-            this.expect(0);
-            
-            if (!optional && this.match(3)) {
-                node.elementType = type;
-                this.next();
-                type = this.finishNode(node, 'ArrayTypeAnnotation');
-            } else {
-                node.objectType = type;
-                node.indexType = this.flowParseType();
-                this.expect(3);
-                
-                if (seenOptionalIndexedAccess) {
-                    node.optional = optional;
-                    type = this.finishNode(node, 'OptionalIndexedAccessType');
-                } else {
-                    type = this.finishNode(node, 'IndexedAccessType');
-                }
-            }
-        }
-        
-        return type;
-    }
-    
-    flowParsePrefixType() {
-        const node = this.startNode();
-        
-        if (this.eat(17)) {
-            node.typeAnnotation = this.flowParsePrefixType();
-            return this.finishNode(node, 'NullableTypeAnnotation');
-        } else {
-            return this.flowParsePostfixType();
-        }
-    }
-    
-    flowParseAnonFunctionWithoutParens() {
-        const param = this.flowParsePrefixType();
-        
-        if (!this.state.noAnonFunctionType && this.eat(19)) {
-            const node = this.startNodeAt(param.loc.start);
-            
-            node.params = [
-                this.reinterpretTypeAsFunctionTypeParam(param),
-            ];
-            node.rest = null;
-            node.this = null;
-            node.returnType = this.flowParseType();
-            node.typeParameters = null;
-            return this.finishNode(node, 'FunctionTypeAnnotation');
-        }
-        
-        return param;
-    }
-    
-    flowParseIntersectionType() {
-        const node = this.startNode();
-        this.eat(45);
-        const type = this.flowParseAnonFunctionWithoutParens();
-        
-        node.types = [type];
-        while (this.eat(45)) {
-            node.types.push(this.flowParseAnonFunctionWithoutParens());
-        }
-        
-        return node.types.length === 1 ? type : this.finishNode(node, 'IntersectionTypeAnnotation');
-    }
-    
-    flowParseUnionType() {
-        const node = this.startNode();
-        this.eat(43);
-        const type = this.flowParseIntersectionType();
-        
-        node.types = [type];
-        while (this.eat(43)) {
-            node.types.push(this.flowParseIntersectionType());
-        }
-        
-        return node.types.length === 1 ? type : this.finishNode(node, 'UnionTypeAnnotation');
-    }
-    
-    flowParseType() {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        const type = this.flowParseUnionType();
-        
-        this.state.inType = oldInType;
-        return type;
-    }
-    
-    flowParseTypeOrImplicitInstantiation() {
-        if (this.state.type === 132 && this.state.value === '_') {
-            const startLoc = this.state.startLoc;
-            const node = this.parseIdentifier();
-            
-            return this.flowParseGenericType(startLoc, node);
-        } else {
-            return this.flowParseType();
-        }
-    }
-    
-    flowParseTypeAnnotation() {
-        const node = this.startNode();
-        
-        node.typeAnnotation = this.flowParseTypeInitialiser();
-        return this.finishNode(node, 'TypeAnnotation');
-    }
-    
-    flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
-        const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
-        
-        if (this.match(14)) {
-            ident.typeAnnotation = this.flowParseTypeAnnotation();
-            this.resetEndLocation(ident);
-        }
-        
-        return ident;
-    }
-    
-    typeCastToParameter(node) {
-        node.expression.typeAnnotation = node.typeAnnotation;
-        this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
-        return node.expression;
-    }
-    
-    flowParseVariance() {
-        let variance2 = null;
-        
-        if (this.match(53)) {
-            variance2 = this.startNode();
-            
-            if (this.state.value === '+') {
-                variance2.kind = 'plus';
-            } else {
-                variance2.kind = 'minus';
-            }
-            
-            this.next();
-            return this.finishNode(variance2, 'Variance');
-        }
-        
-        return variance2;
-    }
-    
-    parseFunctionBody(node, allowExpressionBody, isMethod3 = false) {
-        if (allowExpressionBody) {
-            this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod3));
-            return;
-        }
-        
-        super.parseFunctionBody(node, false, isMethod3);
-    }
-    
-    parseFunctionBodyAndFinish(node, type, isMethod3 = false) {
-        if (this.match(14)) {
-            const typeNode = this.startNode();
-            
-            [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-            node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, 'TypeAnnotation') : null;
-        }
-        
-        return super.parseFunctionBodyAndFinish(node, type, isMethod3);
-    }
-    
-    parseStatementLike(flags) {
-        if (this.state.strict && this.isContextual(129)) {
-            const lookahead = this.lookahead();
-            
-            if (tokenIsKeywordOrIdentifier(lookahead.type)) {
-                const node = this.startNode();
-                this.next();
-                return this.flowParseInterface(node);
-            }
-        } else if (this.isContextual(126)) {
-            const node = this.startNode();
-            this.next();
-            return this.flowParseEnumDeclaration(node);
-        }
-        
-        const stmt = super.parseStatementLike(flags);
-        
-        if (this.flowPragma === void 0 && !this.isValidDirective(stmt)) {
-            this.flowPragma = null;
-        }
-        
-        return stmt;
-    }
-    
-    parseExpressionStatement(node, expr, decorators) {
-        if (expr.type === 'Identifier') {
-            if (expr.name === 'declare') {
-                if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {
-                    return this.flowParseDeclare(node);
-                }
-            } else if (tokenIsIdentifier(this.state.type)) {
-                if (expr.name === 'interface') {
-                    return this.flowParseInterface(node);
-                } else if (expr.name === 'type') {
-                    return this.flowParseTypeAlias(node);
-                } else if (expr.name === 'opaque') {
-                    return this.flowParseOpaqueType(node, false);
-                }
-
-            }
-        }
-        
-        return super.parseExpressionStatement(node, expr, decorators);
-    }
-    
-    shouldParseExportDeclaration() {
-        const {type} = this.state;
-        
-        if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
-            return !this.state.containsEsc;
-        }
-        
-        return super.shouldParseExportDeclaration();
-    }
-    
-    isExportDefaultSpecifier() {
-        const {type} = this.state;
-        
-        if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
-            return this.state.containsEsc;
-        }
-        
-        return super.isExportDefaultSpecifier();
-    }
-    
-    parseExportDefaultExpression() {
-        if (this.isContextual(126)) {
-            const node = this.startNode();
-            this.next();
-            return this.flowParseEnumDeclaration(node);
-        }
-        
-        return super.parseExportDefaultExpression();
-    }
-    
-    parseConditional(expr, startLoc, refExpressionErrors) {
-        if (!this.match(17))
-            return expr;
-        
-        if (this.state.maybeInArrowParameters) {
-            const nextCh = this.lookaheadCharCode();
-            
-            if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
-                this.setOptionalParametersError(refExpressionErrors);
-                return expr;
-            }
-        }
-        
-        this.expect(17);
-        const state = this.state.clone();
-        const originalNoArrowAt = this.state.noArrowAt;
-        const node = this.startNodeAt(startLoc);
-        
-        let {consequent, failed} = this.tryParseConditionalConsequent();
-        
-        let [valid, invalid] = this.getArrowLikeExpressions(consequent);
-        
-        if (failed || invalid.length > 0) {
-            const noArrowAt = [...originalNoArrowAt];
-            
-            if (invalid.length > 0) {
-                this.state = state;
-                this.state.noArrowAt = noArrowAt;
-                for (let i = 0; i < invalid.length; i++) {
-                    noArrowAt.push(invalid[i].start);
-                }
-                
-                ({
-                    consequent,
-                    failed,
-                } = this.tryParseConditionalConsequent());
-                [valid, invalid] = this.getArrowLikeExpressions(consequent);
-            }
-            
-            if (failed && valid.length > 1) {
-                this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);
-            }
-            
-            if (failed && valid.length === 1) {
-                this.state = state;
-                noArrowAt.push(valid[0].start);
-                this.state.noArrowAt = noArrowAt;
-                ({
-                    consequent,
-                    failed,
-                } = this.tryParseConditionalConsequent());
-            }
-        }
-        
-        this.getArrowLikeExpressions(consequent, true);
-        this.state.noArrowAt = originalNoArrowAt;
-        this.expect(14);
-        node.test = expr;
-        node.consequent = consequent;
-        node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(void 0, void 0));
-        
-        return this.finishNode(node, 'ConditionalExpression');
-    }
-    
-    tryParseConditionalConsequent() {
-        this.state.noArrowParamsConversionAt.push(this.state.start);
-        const consequent = this.parseMaybeAssignAllowIn();
-        const failed = !this.match(14);
-        
-        this.state.noArrowParamsConversionAt.pop();
-        return {
-            consequent,
-            failed,
-        };
-    }
-    
-    getArrowLikeExpressions(node, disallowInvalid) {
-        const stack = [node];
-        const arrows = [];
-        
-        while (stack.length !== 0) {
-            const node2 = stack.pop();
-            
-            if (node2.type === 'ArrowFunctionExpression' && node2.body.type !== 'BlockStatement') {
-                if (node2.typeParameters || !node2.returnType) {
-                    this.finishArrowValidation(node2);
-                } else {
-                    arrows.push(node2);
-                }
-                
-                stack.push(node2.body);
-            } else if (node2.type === 'ConditionalExpression') {
-                stack.push(node2.consequent);
-                stack.push(node2.alternate);
-            }
-        }
-        
-        if (disallowInvalid) {
-            arrows.forEach((node2) => this.finishArrowValidation(node2));
-            return [
-                arrows,
-                [],
-            ];
-        }
-        
-        return partition(arrows, (node2) => node2.params.every((param) => this.isAssignable(param, true)));
-    }
-    
-    finishArrowValidation(node) {
-        this.toAssignableList(node.params, node.extra?.trailingCommaLoc, false);
-        this.scope.enter(514 | 4);
-        super.checkParams(node, false, true);
-        this.scope.exit();
-    }
-    
-    forwardNoArrowParamsConversionAt(node, parse3) {
-        let result;
-        
-        if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
-            this.state.noArrowParamsConversionAt.push(this.state.start);
-            result = parse3();
-            this.state.noArrowParamsConversionAt.pop();
-        } else {
-            result = parse3();
-        }
-        
-        return result;
-    }
-    
-    parseParenItem(node, startLoc) {
-        const newNode = super.parseParenItem(node, startLoc);
-        
-        if (this.eat(17)) {
-            newNode.optional = true;
-            this.resetEndLocation(node);
-        }
-        
-        if (this.match(14)) {
-            const typeCastNode = this.startNodeAt(startLoc);
-            
-            typeCastNode.expression = newNode;
-            typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
-            return this.finishNode(typeCastNode, 'TypeCastExpression');
-        }
-        
-        return newNode;
-    }
-    
-    assertModuleNodeAllowed(node) {
-        if (node.type === 'ImportDeclaration' && (node.importKind === 'type' || node.importKind === 'typeof') || node.type === 'ExportNamedDeclaration' && node.exportKind === 'type' || node.type === 'ExportAllDeclaration' && node.exportKind === 'type') {
-            return;
-        }
-        
-        super.assertModuleNodeAllowed(node);
-    }
-    
-    parseExportDeclaration(node) {
-        if (this.isContextual(130)) {
-            node.exportKind = 'type';
-            const declarationNode = this.startNode();
-            this.next();
-            
-            if (this.match(5)) {
-                node.specifiers = this.parseExportSpecifiers(true);
-                super.parseExportFrom(node);
-                return null;
-            } else {
-                return this.flowParseTypeAlias(declarationNode);
-            }
-        } else if (this.isContextual(131)) {
-            node.exportKind = 'type';
-            const declarationNode = this.startNode();
-            this.next();
-            return this.flowParseOpaqueType(declarationNode, false);
-        } else if (this.isContextual(129)) {
-            node.exportKind = 'type';
-            const declarationNode = this.startNode();
-            this.next();
-            return this.flowParseInterface(declarationNode);
-        } else if (this.isContextual(126)) {
-            node.exportKind = 'value';
-            const declarationNode = this.startNode();
-            this.next();
-            return this.flowParseEnumDeclaration(declarationNode);
-        } else {
-            return super.parseExportDeclaration(node);
-        }
-
-
-    }
-    
-    eatExportStar(node) {
-        if (super.eatExportStar(node))
-            return true;
-        
-        if (this.isContextual(130) && this.lookahead().type === 55) {
-            node.exportKind = 'type';
-            this.next();
-            this.next();
-            return true;
-        }
-        
-        return false;
-    }
-    
-    maybeParseExportNamespaceSpecifier(node) {
-        const {startLoc} = this.state;
-        
-        const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
-        
-        if (hasNamespace && node.exportKind === 'type') {
-            this.unexpected(startLoc);
-        }
-        
-        return hasNamespace;
-    }
-    
-    parseClassId(node, isStatement5, optionalId) {
-        super.parseClassId(node, isStatement5, optionalId);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-    }
-    
-    parseClassMember(classBody2, member, state) {
-        const {startLoc} = this.state;
-        
-        if (this.isContextual(125)) {
-            if (super.parseClassMemberFromModifier(classBody2, member)) {
-                return;
-            }
-            
-            member.declare = true;
-        }
-        
-        super.parseClassMember(classBody2, member, state);
-        
-        if (member.declare) {
-            if (member.type !== 'ClassProperty' && member.type !== 'ClassPrivateProperty' && member.type !== 'PropertyDefinition') {
-                this.raise(FlowErrors.DeclareClassElement, startLoc);
-            } else if (member.value) {
-                this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);
-            }
-        }
-    }
-    
-    isIterator(word) {
-        return word === 'iterator' || word === 'asyncIterator';
-    }
-    
-    readIterator() {
-        const word = super.readWord1();
-        const fullWord = '@@' + word;
-        
-        if (!this.isIterator(word) || !this.state.inType) {
-            this.raise(Errors.InvalidIdentifier, this.state.curPosition(), {
-                identifierName: fullWord,
-            });
-        }
-        
-        this.finishToken(132, fullWord);
-    }
-    
-    getTokenFromCode(code2) {
-        const next = this.input.charCodeAt(this.state.pos + 1);
-        
-        if (code2 === 123 && next === 124) {
-            this.finishOp(6, 2);
-        } else if (this.state.inType && (code2 === 62 || code2 === 60)) {
-            this.finishOp(code2 === 62 ? 48 : 47, 1);
-        } else if (this.state.inType && code2 === 63) {
-            if (next === 46) {
-                this.finishOp(18, 2);
-            } else {
-                this.finishOp(17, 1);
-            }
-        } else if (isIteratorStart(code2, next, this.input.charCodeAt(this.state.pos + 2))) {
-            this.state.pos += 2;
-            this.readIterator();
-        } else {
-            super.getTokenFromCode(code2);
-        }
-
-
-    }
-    
-    isAssignable(node, isBinding3) {
-        if (node.type === 'TypeCastExpression') {
-            return this.isAssignable(node.expression, isBinding3);
-        } else {
-            return super.isAssignable(node, isBinding3);
-        }
-    }
-    
-    toAssignable(node, isLHS = false) {
-        if (!isLHS && node.type === 'AssignmentExpression' && node.left.type === 'TypeCastExpression') {
-            node.left = this.typeCastToParameter(node.left);
-        }
-        
-        super.toAssignable(node, isLHS);
-    }
-    
-    toAssignableList(exprList, trailingCommaLoc, isLHS) {
-        for (let i = 0; i < exprList.length; i++) {
-            const expr = exprList[i];
-            
-            if (expr?.type === 'TypeCastExpression') {
-                exprList[i] = this.typeCastToParameter(expr);
-            }
-        }
-        
-        super.toAssignableList(exprList, trailingCommaLoc, isLHS);
-    }
-    
-    toReferencedList(exprList, isParenthesizedExpr) {
-        for (let i = 0; i < exprList.length; i++) {
-            const expr = exprList[i];
-            
-            if (expr && expr.type === 'TypeCastExpression' && !expr.extra?.parenthesized && (exprList.length > 1 || !isParenthesizedExpr)) {
-                this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
-            }
-        }
-        
-        return exprList;
-    }
-    
-    parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
-        const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
-        
-        if (canBePattern && !this.state.maybeInArrowParameters) {
-            this.toReferencedList(node.elements);
-        }
-        
-        return node;
-    }
-    
-    isValidLVal(type, isParenthesized, binding) {
-        return type === 'TypeCastExpression' || super.isValidLVal(type, isParenthesized, binding);
-    }
-    
-    parseClassProperty(node) {
-        if (this.match(14)) {
-            node.typeAnnotation = this.flowParseTypeAnnotation();
-        }
-        
-        return super.parseClassProperty(node);
-    }
-    
-    parseClassPrivateProperty(node) {
-        if (this.match(14)) {
-            node.typeAnnotation = this.flowParseTypeAnnotation();
-        }
-        
-        return super.parseClassPrivateProperty(node);
-    }
-    
-    isClassMethod() {
-        return this.match(47) || super.isClassMethod();
-    }
-    
-    isClassProperty() {
-        return this.match(14) || super.isClassProperty();
-    }
-    
-    isNonstaticConstructor(method) {
-        return !this.match(14) && super.isNonstaticConstructor(method);
-    }
-    
-    pushClassMethod(classBody2, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-        if (method.variance) {
-            this.unexpected(method.variance.loc.start);
-        }
-        
-        delete method.variance;
-        
-        if (this.match(47)) {
-            method.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        super.pushClassMethod(classBody2, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
-        
-        if (method.params && isConstructor) {
-            const params = method.params;
-            
-            if (params.length > 0 && this.isThisParam(params[0])) {
-                this.raise(FlowErrors.ThisParamBannedInConstructor, method);
-            }
-        } else if (method.type === 'MethodDefinition' && isConstructor && method.value.params) {
-            const params = method.value.params;
-            
-            if (params.length > 0 && this.isThisParam(params[0])) {
-                this.raise(FlowErrors.ThisParamBannedInConstructor, method);
-            }
-        }
-    }
-    
-    pushClassPrivateMethod(classBody2, method, isGenerator, isAsync) {
-        if (method.variance) {
-            this.unexpected(method.variance.loc.start);
-        }
-        
-        delete method.variance;
-        
-        if (this.match(47)) {
-            method.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        super.pushClassPrivateMethod(classBody2, method, isGenerator, isAsync);
-    }
-    
-    parseClassSuper(node) {
-        super.parseClassSuper(node);
-        
-        if (node.superClass && (this.match(47) || this.match(51))) {
-            {
-                node.superTypeArguments = this.flowParseTypeParameterInstantiationInExpression();
-            }
-        }
-        
-        if (this.isContextual(113)) {
-            this.next();
-            const implemented = node.implements = [];
-            
-            do {
-                const node2 = this.startNode();
-                
-                node2.id = this.flowParseRestrictedIdentifier(true);
-                
-                if (this.match(47)) {
-                    node2.typeParameters = this.flowParseTypeParameterInstantiation();
-                } else {
-                    node2.typeParameters = null;
-                }
-                
-                implemented.push(this.finishNode(node2, 'ClassImplements'));
-            } while (this.eat(12))
-        }
-    }
-    
-    checkGetterSetterParams(method) {
-        super.checkGetterSetterParams(method);
-        const params = this.getObjectOrClassMethodParams(method);
-        
-        if (params.length > 0) {
-            const param = params[0];
-            
-            if (this.isThisParam(param) && method.kind === 'get') {
-                this.raise(FlowErrors.GetterMayNotHaveThisParam, param);
-            } else if (this.isThisParam(param)) {
-                this.raise(FlowErrors.SetterMayNotHaveThisParam, param);
-            }
-        }
-    }
-    
-    parsePropertyNamePrefixOperator(node) {
-        node.variance = this.flowParseVariance();
-    }
-    
-    parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern3, isAccessor2, refExpressionErrors) {
-        if (prop.variance) {
-            this.unexpected(prop.variance.loc.start);
-        }
-        
-        delete prop.variance;
-        let typeParameters;
-        
-        if (this.match(47) && !isAccessor2) {
-            typeParameters = this.flowParseTypeParameterDeclaration();
-            
-            if (!this.match(10))
-                this.unexpected();
-        }
-        
-        const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern3, isAccessor2, refExpressionErrors);
-        
-        if (typeParameters) {
-            (result.value || result).typeParameters = typeParameters;
-        }
-        
-        return result;
-    }
-    
-    parseFunctionParamType(param) {
-        if (this.eat(17)) {
-            if (param.type !== 'Identifier') {
-                this.raise(FlowErrors.PatternIsOptional, param);
-            }
-            
-            if (this.isThisParam(param)) {
-                this.raise(FlowErrors.ThisParamMayNotBeOptional, param);
-            }
-            
-            param.optional = true;
-        }
-        
-        if (this.match(14)) {
-            param.typeAnnotation = this.flowParseTypeAnnotation();
-        } else if (this.isThisParam(param)) {
-            this.raise(FlowErrors.ThisParamAnnotationRequired, param);
-        }
-        
-        if (this.match(29) && this.isThisParam(param)) {
-            this.raise(FlowErrors.ThisParamNoDefault, param);
-        }
-        
-        this.resetEndLocation(param);
-        return param;
-    }
-    
-    parseMaybeDefault(startLoc, left) {
-        const node = super.parseMaybeDefault(startLoc, left);
-        
-        if (node.type === 'AssignmentPattern' && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-            this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);
-        }
-        
-        return node;
-    }
-    
-    checkImportReflection(node) {
-        super.checkImportReflection(node);
-        
-        if (node.module && node.importKind !== 'value') {
-            this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
-        }
-    }
-    
-    parseImportSpecifierLocal(node, specifier, type) {
-        specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
-        node.specifiers.push(this.finishImportSpecifier(specifier, type));
-    }
-    
-    isPotentialImportPhase(isExport) {
-        if (super.isPotentialImportPhase(isExport))
-            return true;
-        
-        if (this.isContextual(130)) {
-            if (!isExport)
-                return true;
-            
-            const ch = this.lookaheadCharCode();
-            
-            return ch === 123 || ch === 42;
-        }
-        
-        return !isExport && this.isContextual(87);
-    }
-    
-    applyImportPhase(node, isExport, phase, loc) {
-        super.applyImportPhase(node, isExport, phase, loc);
-        
-        if (isExport) {
-            if (!phase && this.match(65)) {
-                return;
-            }
-            
-            node.exportKind = phase === 'type' ? phase : 'value';
-        } else {
-            if (phase === 'type' && this.match(55))
-                this.unexpected();
-            
-            node.importKind = phase === 'type' || phase === 'typeof' ? phase : 'value';
-        }
-    }
-    
-    parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
-        const firstIdent = specifier.imported;
-        let specifierTypeKind = null;
-        
-        if (firstIdent.type === 'Identifier') {
-            if (firstIdent.name === 'type') {
-                specifierTypeKind = 'type';
-            } else if (firstIdent.name === 'typeof') {
-                specifierTypeKind = 'typeof';
-            }
-        }
-        
-        let isBinding3 = false;
-        
-        if (this.isContextual(93) && !this.isLookaheadContextual('as')) {
-            const as_ident = this.parseIdentifier(true);
-            
-            if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
-                specifier.imported = as_ident;
-                specifier.importKind = specifierTypeKind;
-                specifier.local = this.cloneIdentifier(as_ident);
-            } else {
-                specifier.imported = firstIdent;
-                specifier.importKind = null;
-                specifier.local = this.parseIdentifier();
-            }
-        } else {
-            if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {
-                specifier.imported = this.parseIdentifier(true);
-                specifier.importKind = specifierTypeKind;
-            } else {
-                if (importedIsString) {
-                    throw this.raise(Errors.ImportBindingIsString, specifier, {
-                        importName: firstIdent.value,
-                    });
-                }
-                
-                specifier.imported = firstIdent;
-                specifier.importKind = null;
-            }
-            
-            if (this.eatContextual(93)) {
-                specifier.local = this.parseIdentifier();
-            } else {
-                isBinding3 = true;
-                specifier.local = this.cloneIdentifier(specifier.imported);
-            }
-        }
-        
-        const specifierIsTypeImport = hasTypeImportKind(specifier);
-        
-        if (isInTypeOnlyImport && specifierIsTypeImport) {
-            this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
-        }
-        
-        if (isInTypeOnlyImport || specifierIsTypeImport) {
-            this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
-        }
-        
-        if (isBinding3 && !isInTypeOnlyImport && !specifierIsTypeImport) {
-            this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
-        }
-        
-        return this.finishImportSpecifier(specifier, 'ImportSpecifier');
-    }
-    
-    parseBindingAtom() {
-        switch(this.state.type) {
-        case 78:
-            return this.parseIdentifier(true);
-        
-        default:
-            return super.parseBindingAtom();
-        }
-    }
-    
-    parseFunctionParams(node, isConstructor) {
-        const kind = node.kind;
-        
-        if (kind !== 'get' && kind !== 'set' && this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        super.parseFunctionParams(node, isConstructor);
-    }
-    
-    parseVarId(decl, kind) {
-        super.parseVarId(decl, kind);
-        
-        if (this.match(14)) {
-            decl.id.typeAnnotation = this.flowParseTypeAnnotation();
-            this.resetEndLocation(decl.id);
-        }
-    }
-    
-    parseAsyncArrowFromCallExpression(node, call2) {
-        if (this.match(14)) {
-            const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-            
-            this.state.noAnonFunctionType = true;
-            node.returnType = this.flowParseTypeAnnotation();
-            this.state.noAnonFunctionType = oldNoAnonFunctionType;
-        }
-        
-        return super.parseAsyncArrowFromCallExpression(node, call2);
-    }
-    
-    shouldParseAsyncArrow() {
-        return this.match(14) || super.shouldParseAsyncArrow();
-    }
-    
-    parseMaybeAssign(refExpressionErrors, afterLeftParse) {
-        let state = null;
-        let jsx2;
-        
-        if (this.hasPlugin('jsx') && (this.match(143) || this.match(47))) {
-            state = this.state.clone();
-            jsx2 = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
-            
-            if (!jsx2.error)
-                return jsx2.node;
-            
-            const {context} = this.state;
-            
-            const currentContext = context[context.length - 1];
-            
-            if (currentContext === types.j_oTag || currentContext === types.j_expr) {
-                context.pop();
-            }
-        }
-        
-        if (jsx2?.error || this.match(47)) {
-            state = state || this.state.clone();
-            let typeParameters;
-            const arrow = this.tryParse((abort) => {
-                typeParameters = this.flowParseTypeParameterDeclaration();
-                const arrowExpression2 = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
-                    const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
-                    this.resetStartLocationFromNode(result, typeParameters);
-                    return result;
-                });
-                
-                if (arrowExpression2.extra?.parenthesized)
-                    abort();
-                
-                const expr = this.maybeUnwrapTypeCastExpression(arrowExpression2);
-                
-                if (expr.type !== 'ArrowFunctionExpression')
-                    abort();
-                
-                expr.typeParameters = typeParameters;
-                this.resetStartLocationFromNode(expr, typeParameters);
-                return arrowExpression2;
-            }, state);
-            
-            let arrowExpression = null;
-            
-            if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === 'ArrowFunctionExpression') {
-                if (!arrow.error && !arrow.aborted) {
-                    if (arrow.node.async) {
-                        this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);
-                    }
-                    
-                    return arrow.node;
-                }
-                
-                arrowExpression = arrow.node;
-            }
-            
-            if (jsx2?.node) {
-                this.state = jsx2.failState;
-                return jsx2.node;
-            }
-            
-            if (arrowExpression) {
-                this.state = arrow.failState;
-                return arrowExpression;
-            }
-            
-            if (jsx2?.thrown)
-                throw jsx2.error;
-            
-            if (arrow.thrown)
-                throw arrow.error;
-            
-            throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);
-        }
-        
-        return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
-    }
-    
-    parseArrow(node) {
-        if (this.match(14)) {
-            const result = this.tryParse(() => {
-                const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-                
-                this.state.noAnonFunctionType = true;
-                const typeNode = this.startNode();
-                
-                [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-                this.state.noAnonFunctionType = oldNoAnonFunctionType;
-                
-                if (this.canInsertSemicolon())
-                    this.unexpected();
-                
-                if (!this.match(19))
-                    this.unexpected();
-                
-                return typeNode;
-            });
-            
-            if (result.thrown)
-                return null;
-            
-            if (result.error)
-                this.state = result.failState;
-            
-            node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, 'TypeAnnotation') : null;
-        }
-        
-        return super.parseArrow(node);
-    }
-    
-    shouldParseArrow(params) {
-        return this.match(14) || super.shouldParseArrow(params);
-    }
-    
-    setArrowFunctionParameters(node, params) {
-        if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
-            node.params = params;
-        } else {
-            super.setArrowFunctionParameters(node, params);
-        }
-    }
-    
-    checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
-        if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
-            return;
-        }
-        
-        for (let i = 0; i < node.params.length; i++) {
-            if (this.isThisParam(node.params[i]) && i > 0) {
-                this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);
-            }
-        }
-        
-        super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
-    }
-    
-    parseParenAndDistinguishExpression(canBeArrow) {
-        return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
-    }
-    
-    parseSubscripts(base, startLoc, noCalls) {
-        if (base.type === 'Identifier' && base.name === 'async' && this.state.noArrowAt.includes(startLoc.index)) {
-            this.next();
-            const node = this.startNodeAt(startLoc);
-            
-            node.callee = base;
-            node.arguments = super.parseCallExpressionArguments();
-            base = this.finishNode(node, 'CallExpression');
-        } else if (base.type === 'Identifier' && base.name === 'async' && this.match(47)) {
-            const state = this.state.clone();
-            const arrow = this.tryParse((abort) => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);
-            
-            if (!arrow.error && !arrow.aborted)
-                return arrow.node;
-            
-            const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state);
-            
-            if (result.node && !result.error)
-                return result.node;
-            
-            if (arrow.node) {
-                this.state = arrow.failState;
-                return arrow.node;
-            }
-            
-            if (result.node) {
-                this.state = result.failState;
-                return result.node;
-            }
-            
-            throw arrow.error || result.error;
-        }
-        
-        return super.parseSubscripts(base, startLoc, noCalls);
-    }
-    
-    parseSubscript(base, startLoc, noCalls, subscriptState) {
-        if (this.match(18) && this.isLookaheadToken_lt()) {
-            subscriptState.optionalChainMember = true;
-            
-            if (noCalls) {
-                subscriptState.stop = true;
-                return base;
-            }
-            
-            this.next();
-            const node = this.startNodeAt(startLoc);
-            
-            node.callee = base;
-            node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
-            this.expect(10);
-            node.arguments = this.parseCallExpressionArguments();
-            node.optional = true;
-            return this.finishCallExpression(node, true);
-        } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
-            const node = this.startNodeAt(startLoc);
-            
-            node.callee = base;
-            const result = this.tryParse(() => {
-                node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
-                this.expect(10);
-                node.arguments = super.parseCallExpressionArguments();
-                
-                if (subscriptState.optionalChainMember) {
-                    node.optional = false;
-                }
-                
-                return this.finishCallExpression(node, subscriptState.optionalChainMember);
-            });
-            
-            if (result.node) {
-                if (result.error)
-                    this.state = result.failState;
-                
-                return result.node;
-            }
-        }
-        
-        return super.parseSubscript(base, startLoc, noCalls, subscriptState);
-    }
-    
-    parseNewCallee(node) {
-        super.parseNewCallee(node);
-        let targs = null;
-        
-        if (this.shouldParseTypes() && this.match(47)) {
-            targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
-        }
-        
-        node.typeArguments = targs;
-    }
-    
-    parseAsyncArrowWithTypeParameters(startLoc) {
-        const node = this.startNodeAt(startLoc);
-        this.parseFunctionParams(node, false);
-        
-        if (!this.parseArrow(node))
-            return;
-        
-        return super.parseArrowExpression(node, void 0, true);
-    }
-    
-    readToken_mult_modulo(code2) {
-        const next = this.input.charCodeAt(this.state.pos + 1);
-        
-        if (code2 === 42 && next === 47 && this.state.hasFlowComment) {
-            this.state.hasFlowComment = false;
-            this.state.pos += 2;
-            this.nextToken();
-            return;
-        }
-        
-        super.readToken_mult_modulo(code2);
-    }
-    
-    readToken_pipe_amp(code2) {
-        const next = this.input.charCodeAt(this.state.pos + 1);
-        
-        if (code2 === 124 && next === 125) {
-            this.finishOp(9, 2);
-            return;
-        }
-        
-        super.readToken_pipe_amp(code2);
-    }
-    
-    parseTopLevel(file2, program3) {
-        const fileNode = super.parseTopLevel(file2, program3);
-        
-        if (this.state.hasFlowComment) {
-            this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());
-        }
-        
-        return fileNode;
-    }
-    
-    skipBlockComment() {
-        if (this.hasPlugin('flowComments') && this.skipFlowComment()) {
-            if (this.state.hasFlowComment) {
-                throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);
-            }
-            
-            this.hasFlowCommentCompletion();
-            const commentSkip = this.skipFlowComment();
-            
-            if (commentSkip) {
-                this.state.pos += commentSkip;
-                this.state.hasFlowComment = true;
-            }
-            
-            return;
-        }
-        
-        return super.skipBlockComment(this.state.hasFlowComment ? '*-/' : '*/');
-    }
-    
-    skipFlowComment() {
-        const {pos} = this.state;
-        
-        let shiftToFirstNonWhiteSpace = 2;
-        
-        while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
-            shiftToFirstNonWhiteSpace++;
-        }
-        
-        const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
-        const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
-        
-        if (ch2 === 58 && ch3 === 58) {
-            return shiftToFirstNonWhiteSpace + 2;
-        }
-        
-        if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === 'flow-include') {
-            return shiftToFirstNonWhiteSpace + 12;
-        }
-        
-        if (ch2 === 58 && ch3 !== 58) {
-            return shiftToFirstNonWhiteSpace;
-        }
-        
-        return false;
-    }
-    
-    hasFlowCommentCompletion() {
-        const end = this.input.indexOf('*/', this.state.pos);
-        
-        if (end === -1) {
-            throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
-        }
-    }
-    
-    flowEnumErrorBooleanMemberNotInitialized(loc, {enumName, memberName}) {
-        this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {
-            memberName,
-            enumName,
-        });
-    }
-    
-    flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
-        return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === 'symbol' ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
-    }
-    
-    flowEnumErrorNumberMemberNotInitialized(loc, details) {
-        this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);
-    }
-    
-    flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {
-        this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);
-    }
-    
-    flowEnumMemberInit() {
-        const startLoc = this.state.startLoc;
-        const endOfInit = () => this.match(12) || this.match(8);
-        
-        switch(this.state.type) {
-        case 135: {
-            const literal = this.parseNumericLiteral(this.state.value);
-            
-            if (endOfInit()) {
-                return {
-                    type: 'number',
-                    loc: literal.loc.start,
-                    value: literal,
-                };
-            }
-            
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
-        
-        case 134: {
-            const literal = this.parseStringLiteral(this.state.value);
-            
-            if (endOfInit()) {
-                return {
-                    type: 'string',
-                    loc: literal.loc.start,
-                    value: literal,
-                };
-            }
-            
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
-        
-        case 85:        
-        case 86: {
-            const literal = this.parseBooleanLiteral(this.match(85));
-            
-            if (endOfInit()) {
-                return {
-                    type: 'boolean',
-                    loc: literal.loc.start,
-                    value: literal,
-                };
-            }
-            
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
-        
-        default:
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
-    }
-    
-    flowEnumMemberRaw() {
-        const loc = this.state.startLoc;
-        const id = this.parseIdentifier(true);
-        const init = this.eat(29) ? this.flowEnumMemberInit() : {
-            type: 'none',
-            loc,
-        };
-        
-        return {
-            id,
-            init,
-        };
-    }
-    
-    flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
-        const {explicitType} = context;
-        
-        if (explicitType === null) {
-            return;
-        }
-        
-        if (explicitType !== expectedType) {
-            this.flowEnumErrorInvalidMemberInitializer(loc, context);
-        }
-    }
-    
-    flowEnumMembers({enumName, explicitType}) {
-        const seenNames =         /* @__PURE__ */new Set();
-        const members = {
-            booleanMembers: [],
-            numberMembers: [],
-            stringMembers: [],
-            defaultedMembers: [],
-        };
-        
-        let hasUnknownMembers = false;
-        
-        while (!this.match(8)) {
-            if (this.eat(21)) {
-                hasUnknownMembers = true;
-                break;
-            }
-            
-            const memberNode = this.startNode();
-            const {id, init} = this.flowEnumMemberRaw();
-            
-            const memberName = id.name;
-            
-            if (memberName === '') {
-                continue;
-            }
-            
-            if (/^[a-z]/.test(memberName)) {
-                this.raise(FlowErrors.EnumInvalidMemberName, id, {
-                    memberName,
-                    suggestion: memberName[0].toUpperCase() + memberName.slice(1),
-                    enumName,
-                });
-            }
-            
-            if (seenNames.has(memberName)) {
-                this.raise(FlowErrors.EnumDuplicateMemberName, id, {
-                    memberName,
-                    enumName,
-                });
-            }
-            
-            seenNames.add(memberName);
-            const context = {
-                enumName,
-                explicitType,
-                memberName,
-            };
-            
-            memberNode.id = id;
-            switch(init.type) {
-            case 'boolean': {
-                this.flowEnumCheckExplicitTypeMismatch(init.loc, context, 'boolean');
-                memberNode.init = init.value;
-                members.booleanMembers.push(this.finishNode(memberNode, 'EnumBooleanMember'));
-                break;
-            }
-            
-            case 'number': {
-                this.flowEnumCheckExplicitTypeMismatch(init.loc, context, 'number');
-                memberNode.init = init.value;
-                members.numberMembers.push(this.finishNode(memberNode, 'EnumNumberMember'));
-                break;
-            }
-            
-            case 'string': {
-                this.flowEnumCheckExplicitTypeMismatch(init.loc, context, 'string');
-                memberNode.init = init.value;
-                members.stringMembers.push(this.finishNode(memberNode, 'EnumStringMember'));
-                break;
-            }
-            
-            case 'invalid': {
-                throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
-            }
-            
-            case 'none': {
-                switch(explicitType) {
-                case 'boolean':
-                    this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
-                    break;
-                
-                case 'number':
-                    this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
-                    break;
-                
-                default:
-                    members.defaultedMembers.push(this.finishNode(memberNode, 'EnumDefaultedMember'));
-                }
-            }
-            }
-            
-            if (!this.match(8)) {
-                this.expect(12);
-            }
-        }
-        
-        return {
-            members,
-            hasUnknownMembers,
-        };
-    }
-    
-    flowEnumStringMembers(initializedMembers, defaultedMembers, {enumName}) {
-        if (initializedMembers.length === 0) {
-            return defaultedMembers;
-        } else if (defaultedMembers.length === 0) {
-            return initializedMembers;
-        } else if (defaultedMembers.length > initializedMembers.length) {
-            for (const member of initializedMembers) {
-                this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {
-                    enumName,
-                });
-            }
-            
-            return defaultedMembers;
-        } else {
-            for (const member of defaultedMembers) {
-                this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {
-                    enumName,
-                });
-            }
-            
-            return initializedMembers;
-        }
-
-    }
-    
-    flowEnumParseExplicitType({enumName}) {
-        if (!this.eatContextual(102))
-            return null;
-        
-        if (!tokenIsIdentifier(this.state.type)) {
-            throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, {
-                enumName,
-            });
-        }
-        
-        const {value} = this.state;
-        
-        this.next();
-        
-        if (value !== 'boolean' && value !== 'number' && value !== 'string' && value !== 'symbol') {
-            this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {
-                enumName,
-                invalidEnumType: value,
-            });
-        }
-        
-        return value;
-    }
-    
-    flowEnumBody(node, id) {
-        const enumName = id.name;
-        const nameLoc = id.loc.start;
-        const explicitType = this.flowEnumParseExplicitType({
-            enumName,
-        });
-        
-        this.expect(5);
-        const {
-            members,
-            hasUnknownMembers,
-        } = this.flowEnumMembers({
-            enumName,
-            explicitType,
-        });
-        
-        node.hasUnknownMembers = hasUnknownMembers;
-        switch(explicitType) {
-        case 'boolean':
-            node.explicitType = true;
-            node.members = members.booleanMembers;
-            this.expect(8);
-            return this.finishNode(node, 'EnumBooleanBody');
-        
-        case 'number':
-            node.explicitType = true;
-            node.members = members.numberMembers;
-            this.expect(8);
-            return this.finishNode(node, 'EnumNumberBody');
-        
-        case 'string':
-            node.explicitType = true;
-            node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
-                enumName,
-            });
-            this.expect(8);
-            return this.finishNode(node, 'EnumStringBody');
-        
-        case 'symbol':
-            node.members = members.defaultedMembers;
-            this.expect(8);
-            return this.finishNode(node, 'EnumSymbolBody');
-        
-        default: {
-            const empty = () => {
-                node.members = [];
-                this.expect(8);
-                return this.finishNode(node, 'EnumStringBody');
-            };
-            
-            node.explicitType = false;
-            const boolsLen = members.booleanMembers.length;
-            const numsLen = members.numberMembers.length;
-            const strsLen = members.stringMembers.length;
-            const defaultedLen = members.defaultedMembers.length;
-            
-            if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
-                return empty();
-            } else if (!boolsLen && !numsLen) {
-                node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
-                    enumName,
-                });
-                this.expect(8);
-                return this.finishNode(node, 'EnumStringBody');
-            } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
-                for (const member of members.defaultedMembers) {
-                    this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
-                        enumName,
-                        memberName: member.id.name,
-                    });
-                }
-                
-                node.members = members.booleanMembers;
-                this.expect(8);
-                
-                return this.finishNode(node, 'EnumBooleanBody');
-            } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
-                for (const member of members.defaultedMembers) {
-                    this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
-                        enumName,
-                        memberName: member.id.name,
-                    });
-                }
-                
-                node.members = members.numberMembers;
-                this.expect(8);
-                
-                return this.finishNode(node, 'EnumNumberBody');
-            } else {
-                this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {
-                    enumName,
-                });
-                return empty();
-            }
-
-
-        }
-        }
-    }
-    
-    flowParseEnumDeclaration(node) {
-        const id = this.parseIdentifier();
-        
-        node.id = id;
-        node.body = this.flowEnumBody(this.startNode(), id);
-        return this.finishNode(node, 'EnumDeclaration');
-    }
-    
-    jsxParseOpeningElementAfterName(node) {
-        if (this.shouldParseTypes()) {
-            if (this.match(47) || this.match(51)) {
-                node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
-            }
-        }
-        
-        return super.jsxParseOpeningElementAfterName(node);
-    }
-    
-    isLookaheadToken_lt() {
-        const next = this.nextTokenStart();
-        
-        if (this.input.charCodeAt(next) === 60) {
-            const afterNext = this.input.charCodeAt(next + 1);
-            return afterNext !== 60 && afterNext !== 61;
-        }
-        
-        return false;
-    }
-    
-    reScan_lt_gt() {
-        const {type} = this.state;
-        
-        if (type === 47) {
-            this.state.pos -= 1;
-            this.readToken_lt();
-        } else if (type === 48) {
-            this.state.pos -= 1;
-            this.readToken_gt();
-        }
-    }
-    
-    reScan_lt() {
-        const {type} = this.state;
-        
-        if (type === 51) {
-            this.state.pos -= 2;
-            this.finishOp(47, 1);
-            return 47;
-        }
-        
-        return type;
-    }
-    
-    maybeUnwrapTypeCastExpression(node) {
-        return node.type === 'TypeCastExpression' ? node.expression : node;
-    }
-};
-
 var entities = {
     __proto__: null,
     quot: '"',
@@ -33696,7 +29815,6 @@ function validatePlugins(pluginsMap) {
 var mixinPlugins = {
     estree,
     jsx,
-    flow,
     typescript,
     v8intrinsic,
     placeholders,