Docs

1 files changed, 1105 insertions, 0 deletions

diff --git a/node_modules/sucrase/dist/parser/plugins/flow.js b/node_modules/sucrase/dist/parser/plugins/flow.js
new file mode 100644
index 0000000..9401895
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/plugins/flow.js
@@ -0,0 +1,1105 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});/* eslint max-len: 0 */
+
+
+
+
+
+
+
+
+
+
+var _index = require('../tokenizer/index');
+var _keywords = require('../tokenizer/keywords');
+var _types = require('../tokenizer/types');
+var _base = require('../traverser/base');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _expression = require('../traverser/expression');
+
+
+
+
+
+
+
+
+var _statement = require('../traverser/statement');
+
+
+
+
+
+
+
+
+
+var _util = require('../traverser/util');
+
+function isMaybeDefaultImport(lookahead) {
+  return (
+    (lookahead.type === _types.TokenType.name || !!(lookahead.type & _types.TokenType.IS_KEYWORD)) &&
+    lookahead.contextualKeyword !== _keywords.ContextualKeyword._from
+  );
+}
+
+function flowParseTypeInitialiser(tok) {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  _util.expect.call(void 0, tok || _types.TokenType.colon);
+  flowParseType();
+  _index.popTypeContext.call(void 0, oldIsType);
+}
+
+function flowParsePredicate() {
+  _util.expect.call(void 0, _types.TokenType.modulo);
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._checks);
+  if (_index.eat.call(void 0, _types.TokenType.parenL)) {
+    _expression.parseExpression.call(void 0, );
+    _util.expect.call(void 0, _types.TokenType.parenR);
+  }
+}
+
+function flowParseTypeAndPredicateInitialiser() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  _util.expect.call(void 0, _types.TokenType.colon);
+  if (_index.match.call(void 0, _types.TokenType.modulo)) {
+    flowParsePredicate();
+  } else {
+    flowParseType();
+    if (_index.match.call(void 0, _types.TokenType.modulo)) {
+      flowParsePredicate();
+    }
+  }
+  _index.popTypeContext.call(void 0, oldIsType);
+}
+
+function flowParseDeclareClass() {
+  _index.next.call(void 0, );
+  flowParseInterfaceish(/* isClass */ true);
+}
+
+function flowParseDeclareFunction() {
+  _index.next.call(void 0, );
+  _expression.parseIdentifier.call(void 0, );
+
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterDeclaration();
+  }
+
+  _util.expect.call(void 0, _types.TokenType.parenL);
+  flowParseFunctionTypeParams();
+  _util.expect.call(void 0, _types.TokenType.parenR);
+
+  flowParseTypeAndPredicateInitialiser();
+
+  _util.semicolon.call(void 0, );
+}
+
+function flowParseDeclare() {
+  if (_index.match.call(void 0, _types.TokenType._class)) {
+    flowParseDeclareClass();
+  } else if (_index.match.call(void 0, _types.TokenType._function)) {
+    flowParseDeclareFunction();
+  } else if (_index.match.call(void 0, _types.TokenType._var)) {
+    flowParseDeclareVariable();
+  } else if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._module)) {
+    if (_index.eat.call(void 0, _types.TokenType.dot)) {
+      flowParseDeclareModuleExports();
+    } else {
+      flowParseDeclareModule();
+    }
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
+    flowParseDeclareTypeAlias();
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
+    flowParseDeclareOpaqueType();
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
+    flowParseDeclareInterface();
+  } else if (_index.match.call(void 0, _types.TokenType._export)) {
+    flowParseDeclareExportDeclaration();
+  } else {
+    _util.unexpected.call(void 0, );
+  }
+}
+
+function flowParseDeclareVariable() {
+  _index.next.call(void 0, );
+  flowParseTypeAnnotatableIdentifier();
+  _util.semicolon.call(void 0, );
+}
+
+function flowParseDeclareModule() {
+  if (_index.match.call(void 0, _types.TokenType.string)) {
+    _expression.parseExprAtom.call(void 0, );
+  } else {
+    _expression.parseIdentifier.call(void 0, );
+  }
+
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  while (!_index.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    if (_index.match.call(void 0, _types.TokenType._import)) {
+      _index.next.call(void 0, );
+      _statement.parseImport.call(void 0, );
+    } else {
+      _util.unexpected.call(void 0, );
+    }
+  }
+  _util.expect.call(void 0, _types.TokenType.braceR);
+}
+
+function flowParseDeclareExportDeclaration() {
+  _util.expect.call(void 0, _types.TokenType._export);
+
+  if (_index.eat.call(void 0, _types.TokenType._default)) {
+    if (_index.match.call(void 0, _types.TokenType._function) || _index.match.call(void 0, _types.TokenType._class)) {
+      // declare export default class ...
+      // declare export default function ...
+      flowParseDeclare();
+    } else {
+      // declare export default [type];
+      flowParseType();
+      _util.semicolon.call(void 0, );
+    }
+  } else if (
+    _index.match.call(void 0, _types.TokenType._var) || // declare export var ...
+    _index.match.call(void 0, _types.TokenType._function) || // declare export function ...
+    _index.match.call(void 0, _types.TokenType._class) || // declare export class ...
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque) // declare export opaque ..
+  ) {
+    flowParseDeclare();
+  } else if (
+    _index.match.call(void 0, _types.TokenType.star) || // declare export * from ''
+    _index.match.call(void 0, _types.TokenType.braceL) || // declare export {} ...
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._interface) || // declare export interface ...
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._type) || // declare export type ...
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque) // declare export opaque type ...
+  ) {
+    _statement.parseExport.call(void 0, );
+  } else {
+    _util.unexpected.call(void 0, );
+  }
+}
+
+function flowParseDeclareModuleExports() {
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._exports);
+  flowParseTypeAnnotation();
+  _util.semicolon.call(void 0, );
+}
+
+function flowParseDeclareTypeAlias() {
+  _index.next.call(void 0, );
+  flowParseTypeAlias();
+}
+
+function flowParseDeclareOpaqueType() {
+  _index.next.call(void 0, );
+  flowParseOpaqueType(true);
+}
+
+function flowParseDeclareInterface() {
+  _index.next.call(void 0, );
+  flowParseInterfaceish();
+}
+
+// Interfaces
+
+function flowParseInterfaceish(isClass = false) {
+  flowParseRestrictedIdentifier();
+
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterDeclaration();
+  }
+
+  if (_index.eat.call(void 0, _types.TokenType._extends)) {
+    do {
+      flowParseInterfaceExtends();
+    } while (!isClass && _index.eat.call(void 0, _types.TokenType.comma));
+  }
+
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._mixins)) {
+    _index.next.call(void 0, );
+    do {
+      flowParseInterfaceExtends();
+    } while (_index.eat.call(void 0, _types.TokenType.comma));
+  }
+
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
+    _index.next.call(void 0, );
+    do {
+      flowParseInterfaceExtends();
+    } while (_index.eat.call(void 0, _types.TokenType.comma));
+  }
+
+  flowParseObjectType(isClass, false, isClass);
+}
+
+function flowParseInterfaceExtends() {
+  flowParseQualifiedTypeIdentifier(false);
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterInstantiation();
+  }
+}
+
+function flowParseInterface() {
+  flowParseInterfaceish();
+}
+
+function flowParseRestrictedIdentifier() {
+  _expression.parseIdentifier.call(void 0, );
+}
+
+function flowParseTypeAlias() {
+  flowParseRestrictedIdentifier();
+
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterDeclaration();
+  }
+
+  flowParseTypeInitialiser(_types.TokenType.eq);
+  _util.semicolon.call(void 0, );
+}
+
+function flowParseOpaqueType(declare) {
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
+  flowParseRestrictedIdentifier();
+
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterDeclaration();
+  }
+
+  // Parse the supertype
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    flowParseTypeInitialiser(_types.TokenType.colon);
+  }
+
+  if (!declare) {
+    flowParseTypeInitialiser(_types.TokenType.eq);
+  }
+  _util.semicolon.call(void 0, );
+}
+
+function flowParseTypeParameter() {
+  flowParseVariance();
+  flowParseTypeAnnotatableIdentifier();
+
+  if (_index.eat.call(void 0, _types.TokenType.eq)) {
+    flowParseType();
+  }
+}
+
+ function flowParseTypeParameterDeclaration() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  // istanbul ignore else: this condition is already checked at all call sites
+  if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.typeParameterStart)) {
+    _index.next.call(void 0, );
+  } else {
+    _util.unexpected.call(void 0, );
+  }
+
+  do {
+    flowParseTypeParameter();
+    if (!_index.match.call(void 0, _types.TokenType.greaterThan)) {
+      _util.expect.call(void 0, _types.TokenType.comma);
+    }
+  } while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error);
+  _util.expect.call(void 0, _types.TokenType.greaterThan);
+  _index.popTypeContext.call(void 0, oldIsType);
+} exports.flowParseTypeParameterDeclaration = flowParseTypeParameterDeclaration;
+
+function flowParseTypeParameterInstantiation() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  _util.expect.call(void 0, _types.TokenType.lessThan);
+  while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
+    flowParseType();
+    if (!_index.match.call(void 0, _types.TokenType.greaterThan)) {
+      _util.expect.call(void 0, _types.TokenType.comma);
+    }
+  }
+  _util.expect.call(void 0, _types.TokenType.greaterThan);
+  _index.popTypeContext.call(void 0, oldIsType);
+}
+
+function flowParseInterfaceType() {
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._interface);
+  if (_index.eat.call(void 0, _types.TokenType._extends)) {
+    do {
+      flowParseInterfaceExtends();
+    } while (_index.eat.call(void 0, _types.TokenType.comma));
+  }
+  flowParseObjectType(false, false, false);
+}
+
+function flowParseObjectPropertyKey() {
+  if (_index.match.call(void 0, _types.TokenType.num) || _index.match.call(void 0, _types.TokenType.string)) {
+    _expression.parseExprAtom.call(void 0, );
+  } else {
+    _expression.parseIdentifier.call(void 0, );
+  }
+}
+
+function flowParseObjectTypeIndexer() {
+  // Note: bracketL has already been consumed
+  if (_index.lookaheadType.call(void 0, ) === _types.TokenType.colon) {
+    flowParseObjectPropertyKey();
+    flowParseTypeInitialiser();
+  } else {
+    flowParseType();
+  }
+  _util.expect.call(void 0, _types.TokenType.bracketR);
+  flowParseTypeInitialiser();
+}
+
+function flowParseObjectTypeInternalSlot() {
+  // Note: both bracketL have already been consumed
+  flowParseObjectPropertyKey();
+  _util.expect.call(void 0, _types.TokenType.bracketR);
+  _util.expect.call(void 0, _types.TokenType.bracketR);
+  if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.parenL)) {
+    flowParseObjectTypeMethodish();
+  } else {
+    _index.eat.call(void 0, _types.TokenType.question);
+    flowParseTypeInitialiser();
+  }
+}
+
+function flowParseObjectTypeMethodish() {
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterDeclaration();
+  }
+
+  _util.expect.call(void 0, _types.TokenType.parenL);
+  while (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis) && !_base.state.error) {
+    flowParseFunctionTypeParam();
+    if (!_index.match.call(void 0, _types.TokenType.parenR)) {
+      _util.expect.call(void 0, _types.TokenType.comma);
+    }
+  }
+
+  if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
+    flowParseFunctionTypeParam();
+  }
+  _util.expect.call(void 0, _types.TokenType.parenR);
+  flowParseTypeInitialiser();
+}
+
+function flowParseObjectTypeCallProperty() {
+  flowParseObjectTypeMethodish();
+}
+
+function flowParseObjectType(allowStatic, allowExact, allowProto) {
+  let endDelim;
+  if (allowExact && _index.match.call(void 0, _types.TokenType.braceBarL)) {
+    _util.expect.call(void 0, _types.TokenType.braceBarL);
+    endDelim = _types.TokenType.braceBarR;
+  } else {
+    _util.expect.call(void 0, _types.TokenType.braceL);
+    endDelim = _types.TokenType.braceR;
+  }
+
+  while (!_index.match.call(void 0, endDelim) && !_base.state.error) {
+    if (allowProto && _util.isContextual.call(void 0, _keywords.ContextualKeyword._proto)) {
+      const lookahead = _index.lookaheadType.call(void 0, );
+      if (lookahead !== _types.TokenType.colon && lookahead !== _types.TokenType.question) {
+        _index.next.call(void 0, );
+        allowStatic = false;
+      }
+    }
+    if (allowStatic && _util.isContextual.call(void 0, _keywords.ContextualKeyword._static)) {
+      const lookahead = _index.lookaheadType.call(void 0, );
+      if (lookahead !== _types.TokenType.colon && lookahead !== _types.TokenType.question) {
+        _index.next.call(void 0, );
+      }
+    }
+
+    flowParseVariance();
+
+    if (_index.eat.call(void 0, _types.TokenType.bracketL)) {
+      if (_index.eat.call(void 0, _types.TokenType.bracketL)) {
+        flowParseObjectTypeInternalSlot();
+      } else {
+        flowParseObjectTypeIndexer();
+      }
+    } else if (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan)) {
+      flowParseObjectTypeCallProperty();
+    } else {
+      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._get) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._set)) {
+        const lookahead = _index.lookaheadType.call(void 0, );
+        if (lookahead === _types.TokenType.name || lookahead === _types.TokenType.string || lookahead === _types.TokenType.num) {
+          _index.next.call(void 0, );
+        }
+      }
+
+      flowParseObjectTypeProperty();
+    }
+
+    flowObjectTypeSemicolon();
+  }
+
+  _util.expect.call(void 0, endDelim);
+}
+
+function flowParseObjectTypeProperty() {
+  if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
+    _util.expect.call(void 0, _types.TokenType.ellipsis);
+    if (!_index.eat.call(void 0, _types.TokenType.comma)) {
+      _index.eat.call(void 0, _types.TokenType.semi);
+    }
+    // Explicit inexact object syntax.
+    if (_index.match.call(void 0, _types.TokenType.braceR)) {
+      return;
+    }
+    flowParseType();
+  } else {
+    flowParseObjectPropertyKey();
+    if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.parenL)) {
+      // This is a method property
+      flowParseObjectTypeMethodish();
+    } else {
+      _index.eat.call(void 0, _types.TokenType.question);
+      flowParseTypeInitialiser();
+    }
+  }
+}
+
+function flowObjectTypeSemicolon() {
+  if (!_index.eat.call(void 0, _types.TokenType.semi) && !_index.eat.call(void 0, _types.TokenType.comma) && !_index.match.call(void 0, _types.TokenType.braceR) && !_index.match.call(void 0, _types.TokenType.braceBarR)) {
+    _util.unexpected.call(void 0, );
+  }
+}
+
+function flowParseQualifiedTypeIdentifier(initialIdAlreadyParsed) {
+  if (!initialIdAlreadyParsed) {
+    _expression.parseIdentifier.call(void 0, );
+  }
+  while (_index.eat.call(void 0, _types.TokenType.dot)) {
+    _expression.parseIdentifier.call(void 0, );
+  }
+}
+
+function flowParseGenericType() {
+  flowParseQualifiedTypeIdentifier(true);
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterInstantiation();
+  }
+}
+
+function flowParseTypeofType() {
+  _util.expect.call(void 0, _types.TokenType._typeof);
+  flowParsePrimaryType();
+}
+
+function flowParseTupleType() {
+  _util.expect.call(void 0, _types.TokenType.bracketL);
+  // We allow trailing commas
+  while (_base.state.pos < _base.input.length && !_index.match.call(void 0, _types.TokenType.bracketR)) {
+    flowParseType();
+    if (_index.match.call(void 0, _types.TokenType.bracketR)) {
+      break;
+    }
+    _util.expect.call(void 0, _types.TokenType.comma);
+  }
+  _util.expect.call(void 0, _types.TokenType.bracketR);
+}
+
+function flowParseFunctionTypeParam() {
+  const lookahead = _index.lookaheadType.call(void 0, );
+  if (lookahead === _types.TokenType.colon || lookahead === _types.TokenType.question) {
+    _expression.parseIdentifier.call(void 0, );
+    _index.eat.call(void 0, _types.TokenType.question);
+    flowParseTypeInitialiser();
+  } else {
+    flowParseType();
+  }
+}
+
+function flowParseFunctionTypeParams() {
+  while (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis) && !_base.state.error) {
+    flowParseFunctionTypeParam();
+    if (!_index.match.call(void 0, _types.TokenType.parenR)) {
+      _util.expect.call(void 0, _types.TokenType.comma);
+    }
+  }
+  if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
+    flowParseFunctionTypeParam();
+  }
+}
+
+// The parsing of types roughly parallels the parsing of expressions, and
+// primary types are kind of like primary expressions...they're the
+// primitives with which other types are constructed.
+function flowParsePrimaryType() {
+  let isGroupedType = false;
+  const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
+
+  switch (_base.state.type) {
+    case _types.TokenType.name: {
+      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
+        flowParseInterfaceType();
+        return;
+      }
+      _expression.parseIdentifier.call(void 0, );
+      flowParseGenericType();
+      return;
+    }
+
+    case _types.TokenType.braceL:
+      flowParseObjectType(false, false, false);
+      return;
+
+    case _types.TokenType.braceBarL:
+      flowParseObjectType(false, true, false);
+      return;
+
+    case _types.TokenType.bracketL:
+      flowParseTupleType();
+      return;
+
+    case _types.TokenType.lessThan:
+      flowParseTypeParameterDeclaration();
+      _util.expect.call(void 0, _types.TokenType.parenL);
+      flowParseFunctionTypeParams();
+      _util.expect.call(void 0, _types.TokenType.parenR);
+      _util.expect.call(void 0, _types.TokenType.arrow);
+      flowParseType();
+      return;
+
+    case _types.TokenType.parenL:
+      _index.next.call(void 0, );
+
+      // Check to see if this is actually a grouped type
+      if (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis)) {
+        if (_index.match.call(void 0, _types.TokenType.name)) {
+          const token = _index.lookaheadType.call(void 0, );
+          isGroupedType = token !== _types.TokenType.question && token !== _types.TokenType.colon;
+        } else {
+          isGroupedType = true;
+        }
+      }
+
+      if (isGroupedType) {
+        _base.state.noAnonFunctionType = false;
+        flowParseType();
+        _base.state.noAnonFunctionType = oldNoAnonFunctionType;
+
+        // A `,` or a `) =>` means this is an anonymous function type
+        if (
+          _base.state.noAnonFunctionType ||
+          !(_index.match.call(void 0, _types.TokenType.comma) || (_index.match.call(void 0, _types.TokenType.parenR) && _index.lookaheadType.call(void 0, ) === _types.TokenType.arrow))
+        ) {
+          _util.expect.call(void 0, _types.TokenType.parenR);
+          return;
+        } else {
+          // Eat a comma if there is one
+          _index.eat.call(void 0, _types.TokenType.comma);
+        }
+      }
+
+      flowParseFunctionTypeParams();
+
+      _util.expect.call(void 0, _types.TokenType.parenR);
+      _util.expect.call(void 0, _types.TokenType.arrow);
+      flowParseType();
+      return;
+
+    case _types.TokenType.minus:
+      _index.next.call(void 0, );
+      _expression.parseLiteral.call(void 0, );
+      return;
+
+    case _types.TokenType.string:
+    case _types.TokenType.num:
+    case _types.TokenType._true:
+    case _types.TokenType._false:
+    case _types.TokenType._null:
+    case _types.TokenType._this:
+    case _types.TokenType._void:
+    case _types.TokenType.star:
+      _index.next.call(void 0, );
+      return;
+
+    default:
+      if (_base.state.type === _types.TokenType._typeof) {
+        flowParseTypeofType();
+        return;
+      } else if (_base.state.type & _types.TokenType.IS_KEYWORD) {
+        _index.next.call(void 0, );
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.name;
+        return;
+      }
+  }
+
+  _util.unexpected.call(void 0, );
+}
+
+function flowParsePostfixType() {
+  flowParsePrimaryType();
+  while (!_util.canInsertSemicolon.call(void 0, ) && (_index.match.call(void 0, _types.TokenType.bracketL) || _index.match.call(void 0, _types.TokenType.questionDot))) {
+    _index.eat.call(void 0, _types.TokenType.questionDot);
+    _util.expect.call(void 0, _types.TokenType.bracketL);
+    if (_index.eat.call(void 0, _types.TokenType.bracketR)) {
+      // Array type
+    } else {
+      // Indexed access type
+      flowParseType();
+      _util.expect.call(void 0, _types.TokenType.bracketR);
+    }
+  }
+}
+
+function flowParsePrefixType() {
+  if (_index.eat.call(void 0, _types.TokenType.question)) {
+    flowParsePrefixType();
+  } else {
+    flowParsePostfixType();
+  }
+}
+
+function flowParseAnonFunctionWithoutParens() {
+  flowParsePrefixType();
+  if (!_base.state.noAnonFunctionType && _index.eat.call(void 0, _types.TokenType.arrow)) {
+    flowParseType();
+  }
+}
+
+function flowParseIntersectionType() {
+  _index.eat.call(void 0, _types.TokenType.bitwiseAND);
+  flowParseAnonFunctionWithoutParens();
+  while (_index.eat.call(void 0, _types.TokenType.bitwiseAND)) {
+    flowParseAnonFunctionWithoutParens();
+  }
+}
+
+function flowParseUnionType() {
+  _index.eat.call(void 0, _types.TokenType.bitwiseOR);
+  flowParseIntersectionType();
+  while (_index.eat.call(void 0, _types.TokenType.bitwiseOR)) {
+    flowParseIntersectionType();
+  }
+}
+
+function flowParseType() {
+  flowParseUnionType();
+}
+
+ function flowParseTypeAnnotation() {
+  flowParseTypeInitialiser();
+} exports.flowParseTypeAnnotation = flowParseTypeAnnotation;
+
+function flowParseTypeAnnotatableIdentifier() {
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    flowParseTypeAnnotation();
+  }
+}
+
+ function flowParseVariance() {
+  if (_index.match.call(void 0, _types.TokenType.plus) || _index.match.call(void 0, _types.TokenType.minus)) {
+    _index.next.call(void 0, );
+    _base.state.tokens[_base.state.tokens.length - 1].isType = true;
+  }
+} exports.flowParseVariance = flowParseVariance;
+
+// ==================================
+// Overrides
+// ==================================
+
+ function flowParseFunctionBodyAndFinish(funcContextId) {
+  // For arrow functions, `parseArrow` handles the return type itself.
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    flowParseTypeAndPredicateInitialiser();
+  }
+
+  _expression.parseFunctionBody.call(void 0, false, funcContextId);
+} exports.flowParseFunctionBodyAndFinish = flowParseFunctionBodyAndFinish;
+
+ function flowParseSubscript(
+  startTokenIndex,
+  noCalls,
+  stopState,
+) {
+  if (_index.match.call(void 0, _types.TokenType.questionDot) && _index.lookaheadType.call(void 0, ) === _types.TokenType.lessThan) {
+    if (noCalls) {
+      stopState.stop = true;
+      return;
+    }
+    _index.next.call(void 0, );
+    flowParseTypeParameterInstantiation();
+    _util.expect.call(void 0, _types.TokenType.parenL);
+    _expression.parseCallExpressionArguments.call(void 0, );
+    return;
+  } else if (!noCalls && _index.match.call(void 0, _types.TokenType.lessThan)) {
+    const snapshot = _base.state.snapshot();
+    flowParseTypeParameterInstantiation();
+    _util.expect.call(void 0, _types.TokenType.parenL);
+    _expression.parseCallExpressionArguments.call(void 0, );
+    if (_base.state.error) {
+      _base.state.restoreFromSnapshot(snapshot);
+    } else {
+      return;
+    }
+  }
+  _expression.baseParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
+} exports.flowParseSubscript = flowParseSubscript;
+
+ function flowStartParseNewArguments() {
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    const snapshot = _base.state.snapshot();
+    flowParseTypeParameterInstantiation();
+    if (_base.state.error) {
+      _base.state.restoreFromSnapshot(snapshot);
+    }
+  }
+} exports.flowStartParseNewArguments = flowStartParseNewArguments;
+
+// interfaces
+ function flowTryParseStatement() {
+  if (_index.match.call(void 0, _types.TokenType.name) && _base.state.contextualKeyword === _keywords.ContextualKeyword._interface) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 0);
+    _index.next.call(void 0, );
+    flowParseInterface();
+    _index.popTypeContext.call(void 0, oldIsType);
+    return true;
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
+    flowParseEnumDeclaration();
+    return true;
+  }
+  return false;
+} exports.flowTryParseStatement = flowTryParseStatement;
+
+ function flowTryParseExportDefaultExpression() {
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
+    flowParseEnumDeclaration();
+    return true;
+  }
+  return false;
+} exports.flowTryParseExportDefaultExpression = flowTryParseExportDefaultExpression;
+
+// declares, interfaces and type aliases
+ function flowParseIdentifierStatement(contextualKeyword) {
+  if (contextualKeyword === _keywords.ContextualKeyword._declare) {
+    if (
+      _index.match.call(void 0, _types.TokenType._class) ||
+      _index.match.call(void 0, _types.TokenType.name) ||
+      _index.match.call(void 0, _types.TokenType._function) ||
+      _index.match.call(void 0, _types.TokenType._var) ||
+      _index.match.call(void 0, _types.TokenType._export)
+    ) {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      flowParseDeclare();
+      _index.popTypeContext.call(void 0, oldIsType);
+    }
+  } else if (_index.match.call(void 0, _types.TokenType.name)) {
+    if (contextualKeyword === _keywords.ContextualKeyword._interface) {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      flowParseInterface();
+      _index.popTypeContext.call(void 0, oldIsType);
+    } else if (contextualKeyword === _keywords.ContextualKeyword._type) {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      flowParseTypeAlias();
+      _index.popTypeContext.call(void 0, oldIsType);
+    } else if (contextualKeyword === _keywords.ContextualKeyword._opaque) {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      flowParseOpaqueType(false);
+      _index.popTypeContext.call(void 0, oldIsType);
+    }
+  }
+  _util.semicolon.call(void 0, );
+} exports.flowParseIdentifierStatement = flowParseIdentifierStatement;
+
+// export type
+ function flowShouldParseExportDeclaration() {
+  return (
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._type) ||
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._interface) ||
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque) ||
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)
+  );
+} exports.flowShouldParseExportDeclaration = flowShouldParseExportDeclaration;
+
+ function flowShouldDisallowExportDefaultSpecifier() {
+  return (
+    _index.match.call(void 0, _types.TokenType.name) &&
+    (_base.state.contextualKeyword === _keywords.ContextualKeyword._type ||
+      _base.state.contextualKeyword === _keywords.ContextualKeyword._interface ||
+      _base.state.contextualKeyword === _keywords.ContextualKeyword._opaque ||
+      _base.state.contextualKeyword === _keywords.ContextualKeyword._enum)
+  );
+} exports.flowShouldDisallowExportDefaultSpecifier = flowShouldDisallowExportDefaultSpecifier;
+
+ function flowParseExportDeclaration() {
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 1);
+    _index.next.call(void 0, );
+
+    if (_index.match.call(void 0, _types.TokenType.braceL)) {
+      // export type { foo, bar };
+      _statement.parseExportSpecifiers.call(void 0, );
+      _statement.parseExportFrom.call(void 0, );
+    } else {
+      // export type Foo = Bar;
+      flowParseTypeAlias();
+    }
+    _index.popTypeContext.call(void 0, oldIsType);
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 1);
+    _index.next.call(void 0, );
+    // export opaque type Foo = Bar;
+    flowParseOpaqueType(false);
+    _index.popTypeContext.call(void 0, oldIsType);
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 1);
+    _index.next.call(void 0, );
+    flowParseInterface();
+    _index.popTypeContext.call(void 0, oldIsType);
+  } else {
+    _statement.parseStatement.call(void 0, true);
+  }
+} exports.flowParseExportDeclaration = flowParseExportDeclaration;
+
+ function flowShouldParseExportStar() {
+  return _index.match.call(void 0, _types.TokenType.star) || (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type) && _index.lookaheadType.call(void 0, ) === _types.TokenType.star);
+} exports.flowShouldParseExportStar = flowShouldParseExportStar;
+
+ function flowParseExportStar() {
+  if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._type)) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 2);
+    _statement.baseParseExportStar.call(void 0, );
+    _index.popTypeContext.call(void 0, oldIsType);
+  } else {
+    _statement.baseParseExportStar.call(void 0, );
+  }
+} exports.flowParseExportStar = flowParseExportStar;
+
+// parse a the super class type parameters and implements
+ function flowAfterParseClassSuper(hasSuper) {
+  if (hasSuper && _index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterInstantiation();
+  }
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 0);
+    _index.next.call(void 0, );
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._implements;
+    do {
+      flowParseRestrictedIdentifier();
+      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+        flowParseTypeParameterInstantiation();
+      }
+    } while (_index.eat.call(void 0, _types.TokenType.comma));
+    _index.popTypeContext.call(void 0, oldIsType);
+  }
+} exports.flowAfterParseClassSuper = flowAfterParseClassSuper;
+
+// parse type parameters for object method shorthand
+ function flowStartParseObjPropValue() {
+  // method shorthand
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    flowParseTypeParameterDeclaration();
+    if (!_index.match.call(void 0, _types.TokenType.parenL)) _util.unexpected.call(void 0, );
+  }
+} exports.flowStartParseObjPropValue = flowStartParseObjPropValue;
+
+ function flowParseAssignableListItemTypes() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  _index.eat.call(void 0, _types.TokenType.question);
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    flowParseTypeAnnotation();
+  }
+  _index.popTypeContext.call(void 0, oldIsType);
+} exports.flowParseAssignableListItemTypes = flowParseAssignableListItemTypes;
+
+// parse typeof and type imports
+ function flowStartParseImportSpecifiers() {
+  if (_index.match.call(void 0, _types.TokenType._typeof) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
+    const lh = _index.lookaheadTypeAndKeyword.call(void 0, );
+    if (isMaybeDefaultImport(lh) || lh.type === _types.TokenType.braceL || lh.type === _types.TokenType.star) {
+      _index.next.call(void 0, );
+    }
+  }
+} exports.flowStartParseImportSpecifiers = flowStartParseImportSpecifiers;
+
+// parse import-type/typeof shorthand
+ function flowParseImportSpecifier() {
+  const isTypeKeyword =
+    _base.state.contextualKeyword === _keywords.ContextualKeyword._type || _base.state.type === _types.TokenType._typeof;
+  if (isTypeKeyword) {
+    _index.next.call(void 0, );
+  } else {
+    _expression.parseIdentifier.call(void 0, );
+  }
+
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._as) && !_util.isLookaheadContextual.call(void 0, _keywords.ContextualKeyword._as)) {
+    _expression.parseIdentifier.call(void 0, );
+    if (isTypeKeyword && !_index.match.call(void 0, _types.TokenType.name) && !(_base.state.type & _types.TokenType.IS_KEYWORD)) {
+      // `import {type as ,` or `import {type as }`
+    } else {
+      // `import {type as foo`
+      _expression.parseIdentifier.call(void 0, );
+    }
+  } else {
+    if (isTypeKeyword && (_index.match.call(void 0, _types.TokenType.name) || !!(_base.state.type & _types.TokenType.IS_KEYWORD))) {
+      // `import {type foo`
+      _expression.parseIdentifier.call(void 0, );
+    }
+    if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
+      _expression.parseIdentifier.call(void 0, );
+    }
+  }
+} exports.flowParseImportSpecifier = flowParseImportSpecifier;
+
+// parse function type parameters - function foo<T>() {}
+ function flowStartParseFunctionParams() {
+  // Originally this checked if the method is a getter/setter, but if it was, we'd crash soon
+  // anyway, so don't try to propagate that information.
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 0);
+    flowParseTypeParameterDeclaration();
+    _index.popTypeContext.call(void 0, oldIsType);
+  }
+} exports.flowStartParseFunctionParams = flowStartParseFunctionParams;
+
+// parse flow type annotations on variable declarator heads - let foo: string = bar
+ function flowAfterParseVarHead() {
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    flowParseTypeAnnotation();
+  }
+} exports.flowAfterParseVarHead = flowAfterParseVarHead;
+
+// parse the return type of an async arrow function - let foo = (async (): number => {});
+ function flowStartParseAsyncArrowFromCallExpression() {
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
+    _base.state.noAnonFunctionType = true;
+    flowParseTypeAnnotation();
+    _base.state.noAnonFunctionType = oldNoAnonFunctionType;
+  }
+} exports.flowStartParseAsyncArrowFromCallExpression = flowStartParseAsyncArrowFromCallExpression;
+
+// We need to support type parameter declarations for arrow functions. This
+// is tricky. There are three situations we need to handle
+//
+// 1. This is either JSX or an arrow function. We'll try JSX first. If that
+//    fails, we'll try an arrow function. If that fails, we'll throw the JSX
+//    error.
+// 2. This is an arrow function. We'll parse the type parameter declaration,
+//    parse the rest, make sure the rest is an arrow function, and go from
+//    there
+// 3. This is neither. Just call the super method
+ function flowParseMaybeAssign(noIn, isWithinParens) {
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    const snapshot = _base.state.snapshot();
+    let wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+    if (_base.state.error) {
+      _base.state.restoreFromSnapshot(snapshot);
+      _base.state.type = _types.TokenType.typeParameterStart;
+    } else {
+      return wasArrow;
+    }
+
+    const oldIsType = _index.pushTypeContext.call(void 0, 0);
+    flowParseTypeParameterDeclaration();
+    _index.popTypeContext.call(void 0, oldIsType);
+    wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+    if (wasArrow) {
+      return true;
+    }
+    _util.unexpected.call(void 0, );
+  }
+
+  return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+} exports.flowParseMaybeAssign = flowParseMaybeAssign;
+
+// handle return types for arrow functions
+ function flowParseArrow() {
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    const oldIsType = _index.pushTypeContext.call(void 0, 0);
+    const snapshot = _base.state.snapshot();
+
+    const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
+    _base.state.noAnonFunctionType = true;
+    flowParseTypeAndPredicateInitialiser();
+    _base.state.noAnonFunctionType = oldNoAnonFunctionType;
+
+    if (_util.canInsertSemicolon.call(void 0, )) _util.unexpected.call(void 0, );
+    if (!_index.match.call(void 0, _types.TokenType.arrow)) _util.unexpected.call(void 0, );
+
+    if (_base.state.error) {
+      _base.state.restoreFromSnapshot(snapshot);
+    }
+    _index.popTypeContext.call(void 0, oldIsType);
+  }
+  return _index.eat.call(void 0, _types.TokenType.arrow);
+} exports.flowParseArrow = flowParseArrow;
+
+ function flowParseSubscripts(startTokenIndex, noCalls = false) {
+  if (
+    _base.state.tokens[_base.state.tokens.length - 1].contextualKeyword === _keywords.ContextualKeyword._async &&
+    _index.match.call(void 0, _types.TokenType.lessThan)
+  ) {
+    const snapshot = _base.state.snapshot();
+    const wasArrow = parseAsyncArrowWithTypeParameters();
+    if (wasArrow && !_base.state.error) {
+      return;
+    }
+    _base.state.restoreFromSnapshot(snapshot);
+  }
+
+  _expression.baseParseSubscripts.call(void 0, startTokenIndex, noCalls);
+} exports.flowParseSubscripts = flowParseSubscripts;
+
+// Returns true if there was an arrow function here.
+function parseAsyncArrowWithTypeParameters() {
+  _base.state.scopeDepth++;
+  const startTokenIndex = _base.state.tokens.length;
+  _statement.parseFunctionParams.call(void 0, );
+  if (!_expression.parseArrow.call(void 0, )) {
+    return false;
+  }
+  _expression.parseArrowExpression.call(void 0, startTokenIndex);
+  return true;
+}
+
+function flowParseEnumDeclaration() {
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._enum);
+  _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
+  _expression.parseIdentifier.call(void 0, );
+  flowParseEnumBody();
+}
+
+function flowParseEnumBody() {
+  if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._of)) {
+    _index.next.call(void 0, );
+  }
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  flowParseEnumMembers();
+  _util.expect.call(void 0, _types.TokenType.braceR);
+}
+
+function flowParseEnumMembers() {
+  while (!_index.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
+      break;
+    }
+    flowParseEnumMember();
+    if (!_index.match.call(void 0, _types.TokenType.braceR)) {
+      _util.expect.call(void 0, _types.TokenType.comma);
+    }
+  }
+}
+
+function flowParseEnumMember() {
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.eat.call(void 0, _types.TokenType.eq)) {
+    // Flow enum values are always just one token (a string, number, or boolean literal).
+    _index.next.call(void 0, );
+  }
+}