Docs

21 files changed, 8554 insertions, 0 deletions

diff --git a/node_modules/sucrase/dist/parser/index.js b/node_modules/sucrase/dist/parser/index.js
new file mode 100644
index 0000000..35d832a
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/index.js
@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _base = require('./traverser/base');
+var _index = require('./traverser/index');
+
+ class File {
+  
+  
+
+  constructor(tokens, scopes) {
+    this.tokens = tokens;
+    this.scopes = scopes;
+  }
+} exports.File = File;
+
+ function parse(
+  input,
+  isJSXEnabled,
+  isTypeScriptEnabled,
+  isFlowEnabled,
+) {
+  if (isFlowEnabled && isTypeScriptEnabled) {
+    throw new Error("Cannot combine flow and typescript plugins.");
+  }
+  _base.initParser.call(void 0, input, isJSXEnabled, isTypeScriptEnabled, isFlowEnabled);
+  const result = _index.parseFile.call(void 0, );
+  if (_base.state.error) {
+    throw _base.augmentError.call(void 0, _base.state.error);
+  }
+  return result;
+} exports.parse = parse;
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, );
+  }
+}
diff --git a/node_modules/sucrase/dist/parser/plugins/jsx/index.js b/node_modules/sucrase/dist/parser/plugins/jsx/index.js
new file mode 100644
index 0000000..41797de
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/plugins/jsx/index.js
@@ -0,0 +1,367 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+var _index = require('../../tokenizer/index');
+var _types = require('../../tokenizer/types');
+var _base = require('../../traverser/base');
+var _expression = require('../../traverser/expression');
+var _util = require('../../traverser/util');
+var _charcodes = require('../../util/charcodes');
+var _identifier = require('../../util/identifier');
+var _typescript = require('../typescript');
+
+/**
+ * Read token with JSX contents.
+ *
+ * In addition to detecting jsxTagStart and also regular tokens that might be
+ * part of an expression, this code detects the start and end of text ranges
+ * within JSX children. In order to properly count the number of children, we
+ * distinguish jsxText from jsxEmptyText, which is a text range that simplifies
+ * to the empty string after JSX whitespace trimming.
+ *
+ * It turns out that a JSX text range will simplify to the empty string if and
+ * only if both of these conditions hold:
+ * - The range consists entirely of whitespace characters (only counting space,
+ *   tab, \r, and \n).
+ * - The range has at least one newline.
+ * This can be proven by analyzing any implementation of whitespace trimming,
+ * e.g. formatJSXTextLiteral in Sucrase or cleanJSXElementLiteralChild in Babel.
+ */
+function jsxReadToken() {
+  let sawNewline = false;
+  let sawNonWhitespace = false;
+  while (true) {
+    if (_base.state.pos >= _base.input.length) {
+      _util.unexpected.call(void 0, "Unterminated JSX contents");
+      return;
+    }
+
+    const ch = _base.input.charCodeAt(_base.state.pos);
+    if (ch === _charcodes.charCodes.lessThan || ch === _charcodes.charCodes.leftCurlyBrace) {
+      if (_base.state.pos === _base.state.start) {
+        if (ch === _charcodes.charCodes.lessThan) {
+          _base.state.pos++;
+          _index.finishToken.call(void 0, _types.TokenType.jsxTagStart);
+          return;
+        }
+        _index.getTokenFromCode.call(void 0, ch);
+        return;
+      }
+      if (sawNewline && !sawNonWhitespace) {
+        _index.finishToken.call(void 0, _types.TokenType.jsxEmptyText);
+      } else {
+        _index.finishToken.call(void 0, _types.TokenType.jsxText);
+      }
+      return;
+    }
+
+    // This is part of JSX text.
+    if (ch === _charcodes.charCodes.lineFeed) {
+      sawNewline = true;
+    } else if (ch !== _charcodes.charCodes.space && ch !== _charcodes.charCodes.carriageReturn && ch !== _charcodes.charCodes.tab) {
+      sawNonWhitespace = true;
+    }
+    _base.state.pos++;
+  }
+}
+
+function jsxReadString(quote) {
+  _base.state.pos++;
+  for (;;) {
+    if (_base.state.pos >= _base.input.length) {
+      _util.unexpected.call(void 0, "Unterminated string constant");
+      return;
+    }
+
+    const ch = _base.input.charCodeAt(_base.state.pos);
+    if (ch === quote) {
+      _base.state.pos++;
+      break;
+    }
+    _base.state.pos++;
+  }
+  _index.finishToken.call(void 0, _types.TokenType.string);
+}
+
+// Read a JSX identifier (valid tag or attribute name).
+//
+// Optimized version since JSX identifiers can't contain
+// escape characters and so can be read as single slice.
+// Also assumes that first character was already checked
+// by isIdentifierStart in readToken.
+
+function jsxReadWord() {
+  let ch;
+  do {
+    if (_base.state.pos > _base.input.length) {
+      _util.unexpected.call(void 0, "Unexpectedly reached the end of input.");
+      return;
+    }
+    ch = _base.input.charCodeAt(++_base.state.pos);
+  } while (_identifier.IS_IDENTIFIER_CHAR[ch] || ch === _charcodes.charCodes.dash);
+  _index.finishToken.call(void 0, _types.TokenType.jsxName);
+}
+
+// Parse next token as JSX identifier
+function jsxParseIdentifier() {
+  nextJSXTagToken();
+}
+
+// Parse namespaced identifier.
+function jsxParseNamespacedName(identifierRole) {
+  jsxParseIdentifier();
+  if (!_index.eat.call(void 0, _types.TokenType.colon)) {
+    // Plain identifier, so this is an access.
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = identifierRole;
+    return;
+  }
+  // Process the second half of the namespaced name.
+  jsxParseIdentifier();
+}
+
+// Parses element name in any form - namespaced, member
+// or single identifier.
+function jsxParseElementName() {
+  const firstTokenIndex = _base.state.tokens.length;
+  jsxParseNamespacedName(_index.IdentifierRole.Access);
+  let hadDot = false;
+  while (_index.match.call(void 0, _types.TokenType.dot)) {
+    hadDot = true;
+    nextJSXTagToken();
+    jsxParseIdentifier();
+  }
+  // For tags like <div> with a lowercase letter and no dots, the name is
+  // actually *not* an identifier access, since it's referring to a built-in
+  // tag name. Remove the identifier role in this case so that it's not
+  // accidentally transformed by the imports transform when preserving JSX.
+  if (!hadDot) {
+    const firstToken = _base.state.tokens[firstTokenIndex];
+    const firstChar = _base.input.charCodeAt(firstToken.start);
+    if (firstChar >= _charcodes.charCodes.lowercaseA && firstChar <= _charcodes.charCodes.lowercaseZ) {
+      firstToken.identifierRole = null;
+    }
+  }
+}
+
+// Parses any type of JSX attribute value.
+function jsxParseAttributeValue() {
+  switch (_base.state.type) {
+    case _types.TokenType.braceL:
+      _index.next.call(void 0, );
+      _expression.parseExpression.call(void 0, );
+      nextJSXTagToken();
+      return;
+
+    case _types.TokenType.jsxTagStart:
+      jsxParseElement();
+      nextJSXTagToken();
+      return;
+
+    case _types.TokenType.string:
+      nextJSXTagToken();
+      return;
+
+    default:
+      _util.unexpected.call(void 0, "JSX value should be either an expression or a quoted JSX text");
+  }
+}
+
+// Parse JSX spread child, after already processing the {
+// Does not parse the closing }
+function jsxParseSpreadChild() {
+  _util.expect.call(void 0, _types.TokenType.ellipsis);
+  _expression.parseExpression.call(void 0, );
+}
+
+// Parses JSX opening tag starting after "<".
+// Returns true if the tag was self-closing.
+// Does not parse the last token.
+function jsxParseOpeningElement(initialTokenIndex) {
+  if (_index.match.call(void 0, _types.TokenType.jsxTagEnd)) {
+    // This is an open-fragment.
+    return false;
+  }
+  jsxParseElementName();
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsTryParseJSXTypeArgument.call(void 0, );
+  }
+  let hasSeenPropSpread = false;
+  while (!_index.match.call(void 0, _types.TokenType.slash) && !_index.match.call(void 0, _types.TokenType.jsxTagEnd) && !_base.state.error) {
+    if (_index.eat.call(void 0, _types.TokenType.braceL)) {
+      hasSeenPropSpread = true;
+      _util.expect.call(void 0, _types.TokenType.ellipsis);
+      _expression.parseMaybeAssign.call(void 0, );
+      // }
+      nextJSXTagToken();
+      continue;
+    }
+    if (
+      hasSeenPropSpread &&
+      _base.state.end - _base.state.start === 3 &&
+      _base.input.charCodeAt(_base.state.start) === _charcodes.charCodes.lowercaseK &&
+      _base.input.charCodeAt(_base.state.start + 1) === _charcodes.charCodes.lowercaseE &&
+      _base.input.charCodeAt(_base.state.start + 2) === _charcodes.charCodes.lowercaseY
+    ) {
+      _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.KeyAfterPropSpread;
+    }
+    jsxParseNamespacedName(_index.IdentifierRole.ObjectKey);
+    if (_index.match.call(void 0, _types.TokenType.eq)) {
+      nextJSXTagToken();
+      jsxParseAttributeValue();
+    }
+  }
+  const isSelfClosing = _index.match.call(void 0, _types.TokenType.slash);
+  if (isSelfClosing) {
+    // /
+    nextJSXTagToken();
+  }
+  return isSelfClosing;
+}
+
+// Parses JSX closing tag starting after "</".
+// Does not parse the last token.
+function jsxParseClosingElement() {
+  if (_index.match.call(void 0, _types.TokenType.jsxTagEnd)) {
+    // Fragment syntax, so we immediately have a tag end.
+    return;
+  }
+  jsxParseElementName();
+}
+
+// Parses entire JSX element, including its opening tag
+// (starting after "<"), attributes, contents and closing tag.
+// Does not parse the last token.
+function jsxParseElementAt() {
+  const initialTokenIndex = _base.state.tokens.length - 1;
+  _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.NoChildren;
+  let numExplicitChildren = 0;
+  const isSelfClosing = jsxParseOpeningElement(initialTokenIndex);
+  if (!isSelfClosing) {
+    nextJSXExprToken();
+    while (true) {
+      switch (_base.state.type) {
+        case _types.TokenType.jsxTagStart:
+          nextJSXTagToken();
+          if (_index.match.call(void 0, _types.TokenType.slash)) {
+            nextJSXTagToken();
+            jsxParseClosingElement();
+            // Key after prop spread takes precedence over number of children,
+            // since it means we switch to createElement, which doesn't care
+            // about number of children.
+            if (_base.state.tokens[initialTokenIndex].jsxRole !== _index.JSXRole.KeyAfterPropSpread) {
+              if (numExplicitChildren === 1) {
+                _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.OneChild;
+              } else if (numExplicitChildren > 1) {
+                _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.StaticChildren;
+              }
+            }
+            return;
+          }
+          numExplicitChildren++;
+          jsxParseElementAt();
+          nextJSXExprToken();
+          break;
+
+        case _types.TokenType.jsxText:
+          numExplicitChildren++;
+          nextJSXExprToken();
+          break;
+
+        case _types.TokenType.jsxEmptyText:
+          nextJSXExprToken();
+          break;
+
+        case _types.TokenType.braceL:
+          _index.next.call(void 0, );
+          if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
+            jsxParseSpreadChild();
+            nextJSXExprToken();
+            // Spread children are a mechanism to explicitly mark children as
+            // static, so count it as 2 children to satisfy the "more than one
+            // child" condition.
+            numExplicitChildren += 2;
+          } else {
+            // If we see {}, this is an empty pseudo-expression that doesn't
+            // count as a child.
+            if (!_index.match.call(void 0, _types.TokenType.braceR)) {
+              numExplicitChildren++;
+              _expression.parseExpression.call(void 0, );
+            }
+            nextJSXExprToken();
+          }
+
+          break;
+
+        // istanbul ignore next - should never happen
+        default:
+          _util.unexpected.call(void 0, );
+          return;
+      }
+    }
+  }
+}
+
+// Parses entire JSX element from current position.
+// Does not parse the last token.
+ function jsxParseElement() {
+  nextJSXTagToken();
+  jsxParseElementAt();
+} exports.jsxParseElement = jsxParseElement;
+
+// ==================================
+// Overrides
+// ==================================
+
+ function nextJSXTagToken() {
+  _base.state.tokens.push(new (0, _index.Token)());
+  _index.skipSpace.call(void 0, );
+  _base.state.start = _base.state.pos;
+  const code = _base.input.charCodeAt(_base.state.pos);
+
+  if (_identifier.IS_IDENTIFIER_START[code]) {
+    jsxReadWord();
+  } else if (code === _charcodes.charCodes.quotationMark || code === _charcodes.charCodes.apostrophe) {
+    jsxReadString(code);
+  } else {
+    // The following tokens are just one character each.
+    ++_base.state.pos;
+    switch (code) {
+      case _charcodes.charCodes.greaterThan:
+        _index.finishToken.call(void 0, _types.TokenType.jsxTagEnd);
+        break;
+      case _charcodes.charCodes.lessThan:
+        _index.finishToken.call(void 0, _types.TokenType.jsxTagStart);
+        break;
+      case _charcodes.charCodes.slash:
+        _index.finishToken.call(void 0, _types.TokenType.slash);
+        break;
+      case _charcodes.charCodes.equalsTo:
+        _index.finishToken.call(void 0, _types.TokenType.eq);
+        break;
+      case _charcodes.charCodes.leftCurlyBrace:
+        _index.finishToken.call(void 0, _types.TokenType.braceL);
+        break;
+      case _charcodes.charCodes.dot:
+        _index.finishToken.call(void 0, _types.TokenType.dot);
+        break;
+      case _charcodes.charCodes.colon:
+        _index.finishToken.call(void 0, _types.TokenType.colon);
+        break;
+      default:
+        _util.unexpected.call(void 0, );
+    }
+  }
+} exports.nextJSXTagToken = nextJSXTagToken;
+
+function nextJSXExprToken() {
+  _base.state.tokens.push(new (0, _index.Token)());
+  _base.state.start = _base.state.pos;
+  jsxReadToken();
+}
diff --git a/node_modules/sucrase/dist/parser/plugins/jsx/xhtml.js b/node_modules/sucrase/dist/parser/plugins/jsx/xhtml.js
new file mode 100644
index 0000000..d8e91c5
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/plugins/jsx/xhtml.js
@@ -0,0 +1,256 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// Use a Map rather than object to avoid unexpected __proto__ access.
+exports. default = new Map([
+  ["quot", "\u0022"],
+  ["amp", "&"],
+  ["apos", "\u0027"],
+  ["lt", "<"],
+  ["gt", ">"],
+  ["nbsp", "\u00A0"],
+  ["iexcl", "\u00A1"],
+  ["cent", "\u00A2"],
+  ["pound", "\u00A3"],
+  ["curren", "\u00A4"],
+  ["yen", "\u00A5"],
+  ["brvbar", "\u00A6"],
+  ["sect", "\u00A7"],
+  ["uml", "\u00A8"],
+  ["copy", "\u00A9"],
+  ["ordf", "\u00AA"],
+  ["laquo", "\u00AB"],
+  ["not", "\u00AC"],
+  ["shy", "\u00AD"],
+  ["reg", "\u00AE"],
+  ["macr", "\u00AF"],
+  ["deg", "\u00B0"],
+  ["plusmn", "\u00B1"],
+  ["sup2", "\u00B2"],
+  ["sup3", "\u00B3"],
+  ["acute", "\u00B4"],
+  ["micro", "\u00B5"],
+  ["para", "\u00B6"],
+  ["middot", "\u00B7"],
+  ["cedil", "\u00B8"],
+  ["sup1", "\u00B9"],
+  ["ordm", "\u00BA"],
+  ["raquo", "\u00BB"],
+  ["frac14", "\u00BC"],
+  ["frac12", "\u00BD"],
+  ["frac34", "\u00BE"],
+  ["iquest", "\u00BF"],
+  ["Agrave", "\u00C0"],
+  ["Aacute", "\u00C1"],
+  ["Acirc", "\u00C2"],
+  ["Atilde", "\u00C3"],
+  ["Auml", "\u00C4"],
+  ["Aring", "\u00C5"],
+  ["AElig", "\u00C6"],
+  ["Ccedil", "\u00C7"],
+  ["Egrave", "\u00C8"],
+  ["Eacute", "\u00C9"],
+  ["Ecirc", "\u00CA"],
+  ["Euml", "\u00CB"],
+  ["Igrave", "\u00CC"],
+  ["Iacute", "\u00CD"],
+  ["Icirc", "\u00CE"],
+  ["Iuml", "\u00CF"],
+  ["ETH", "\u00D0"],
+  ["Ntilde", "\u00D1"],
+  ["Ograve", "\u00D2"],
+  ["Oacute", "\u00D3"],
+  ["Ocirc", "\u00D4"],
+  ["Otilde", "\u00D5"],
+  ["Ouml", "\u00D6"],
+  ["times", "\u00D7"],
+  ["Oslash", "\u00D8"],
+  ["Ugrave", "\u00D9"],
+  ["Uacute", "\u00DA"],
+  ["Ucirc", "\u00DB"],
+  ["Uuml", "\u00DC"],
+  ["Yacute", "\u00DD"],
+  ["THORN", "\u00DE"],
+  ["szlig", "\u00DF"],
+  ["agrave", "\u00E0"],
+  ["aacute", "\u00E1"],
+  ["acirc", "\u00E2"],
+  ["atilde", "\u00E3"],
+  ["auml", "\u00E4"],
+  ["aring", "\u00E5"],
+  ["aelig", "\u00E6"],
+  ["ccedil", "\u00E7"],
+  ["egrave", "\u00E8"],
+  ["eacute", "\u00E9"],
+  ["ecirc", "\u00EA"],
+  ["euml", "\u00EB"],
+  ["igrave", "\u00EC"],
+  ["iacute", "\u00ED"],
+  ["icirc", "\u00EE"],
+  ["iuml", "\u00EF"],
+  ["eth", "\u00F0"],
+  ["ntilde", "\u00F1"],
+  ["ograve", "\u00F2"],
+  ["oacute", "\u00F3"],
+  ["ocirc", "\u00F4"],
+  ["otilde", "\u00F5"],
+  ["ouml", "\u00F6"],
+  ["divide", "\u00F7"],
+  ["oslash", "\u00F8"],
+  ["ugrave", "\u00F9"],
+  ["uacute", "\u00FA"],
+  ["ucirc", "\u00FB"],
+  ["uuml", "\u00FC"],
+  ["yacute", "\u00FD"],
+  ["thorn", "\u00FE"],
+  ["yuml", "\u00FF"],
+  ["OElig", "\u0152"],
+  ["oelig", "\u0153"],
+  ["Scaron", "\u0160"],
+  ["scaron", "\u0161"],
+  ["Yuml", "\u0178"],
+  ["fnof", "\u0192"],
+  ["circ", "\u02C6"],
+  ["tilde", "\u02DC"],
+  ["Alpha", "\u0391"],
+  ["Beta", "\u0392"],
+  ["Gamma", "\u0393"],
+  ["Delta", "\u0394"],
+  ["Epsilon", "\u0395"],
+  ["Zeta", "\u0396"],
+  ["Eta", "\u0397"],
+  ["Theta", "\u0398"],
+  ["Iota", "\u0399"],
+  ["Kappa", "\u039A"],
+  ["Lambda", "\u039B"],
+  ["Mu", "\u039C"],
+  ["Nu", "\u039D"],
+  ["Xi", "\u039E"],
+  ["Omicron", "\u039F"],
+  ["Pi", "\u03A0"],
+  ["Rho", "\u03A1"],
+  ["Sigma", "\u03A3"],
+  ["Tau", "\u03A4"],
+  ["Upsilon", "\u03A5"],
+  ["Phi", "\u03A6"],
+  ["Chi", "\u03A7"],
+  ["Psi", "\u03A8"],
+  ["Omega", "\u03A9"],
+  ["alpha", "\u03B1"],
+  ["beta", "\u03B2"],
+  ["gamma", "\u03B3"],
+  ["delta", "\u03B4"],
+  ["epsilon", "\u03B5"],
+  ["zeta", "\u03B6"],
+  ["eta", "\u03B7"],
+  ["theta", "\u03B8"],
+  ["iota", "\u03B9"],
+  ["kappa", "\u03BA"],
+  ["lambda", "\u03BB"],
+  ["mu", "\u03BC"],
+  ["nu", "\u03BD"],
+  ["xi", "\u03BE"],
+  ["omicron", "\u03BF"],
+  ["pi", "\u03C0"],
+  ["rho", "\u03C1"],
+  ["sigmaf", "\u03C2"],
+  ["sigma", "\u03C3"],
+  ["tau", "\u03C4"],
+  ["upsilon", "\u03C5"],
+  ["phi", "\u03C6"],
+  ["chi", "\u03C7"],
+  ["psi", "\u03C8"],
+  ["omega", "\u03C9"],
+  ["thetasym", "\u03D1"],
+  ["upsih", "\u03D2"],
+  ["piv", "\u03D6"],
+  ["ensp", "\u2002"],
+  ["emsp", "\u2003"],
+  ["thinsp", "\u2009"],
+  ["zwnj", "\u200C"],
+  ["zwj", "\u200D"],
+  ["lrm", "\u200E"],
+  ["rlm", "\u200F"],
+  ["ndash", "\u2013"],
+  ["mdash", "\u2014"],
+  ["lsquo", "\u2018"],
+  ["rsquo", "\u2019"],
+  ["sbquo", "\u201A"],
+  ["ldquo", "\u201C"],
+  ["rdquo", "\u201D"],
+  ["bdquo", "\u201E"],
+  ["dagger", "\u2020"],
+  ["Dagger", "\u2021"],
+  ["bull", "\u2022"],
+  ["hellip", "\u2026"],
+  ["permil", "\u2030"],
+  ["prime", "\u2032"],
+  ["Prime", "\u2033"],
+  ["lsaquo", "\u2039"],
+  ["rsaquo", "\u203A"],
+  ["oline", "\u203E"],
+  ["frasl", "\u2044"],
+  ["euro", "\u20AC"],
+  ["image", "\u2111"],
+  ["weierp", "\u2118"],
+  ["real", "\u211C"],
+  ["trade", "\u2122"],
+  ["alefsym", "\u2135"],
+  ["larr", "\u2190"],
+  ["uarr", "\u2191"],
+  ["rarr", "\u2192"],
+  ["darr", "\u2193"],
+  ["harr", "\u2194"],
+  ["crarr", "\u21B5"],
+  ["lArr", "\u21D0"],
+  ["uArr", "\u21D1"],
+  ["rArr", "\u21D2"],
+  ["dArr", "\u21D3"],
+  ["hArr", "\u21D4"],
+  ["forall", "\u2200"],
+  ["part", "\u2202"],
+  ["exist", "\u2203"],
+  ["empty", "\u2205"],
+  ["nabla", "\u2207"],
+  ["isin", "\u2208"],
+  ["notin", "\u2209"],
+  ["ni", "\u220B"],
+  ["prod", "\u220F"],
+  ["sum", "\u2211"],
+  ["minus", "\u2212"],
+  ["lowast", "\u2217"],
+  ["radic", "\u221A"],
+  ["prop", "\u221D"],
+  ["infin", "\u221E"],
+  ["ang", "\u2220"],
+  ["and", "\u2227"],
+  ["or", "\u2228"],
+  ["cap", "\u2229"],
+  ["cup", "\u222A"],
+  ["int", "\u222B"],
+  ["there4", "\u2234"],
+  ["sim", "\u223C"],
+  ["cong", "\u2245"],
+  ["asymp", "\u2248"],
+  ["ne", "\u2260"],
+  ["equiv", "\u2261"],
+  ["le", "\u2264"],
+  ["ge", "\u2265"],
+  ["sub", "\u2282"],
+  ["sup", "\u2283"],
+  ["nsub", "\u2284"],
+  ["sube", "\u2286"],
+  ["supe", "\u2287"],
+  ["oplus", "\u2295"],
+  ["otimes", "\u2297"],
+  ["perp", "\u22A5"],
+  ["sdot", "\u22C5"],
+  ["lceil", "\u2308"],
+  ["rceil", "\u2309"],
+  ["lfloor", "\u230A"],
+  ["rfloor", "\u230B"],
+  ["lang", "\u2329"],
+  ["rang", "\u232A"],
+  ["loz", "\u25CA"],
+  ["spades", "\u2660"],
+  ["clubs", "\u2663"],
+  ["hearts", "\u2665"],
+  ["diams", "\u2666"],
+]);
diff --git a/node_modules/sucrase/dist/parser/plugins/types.js b/node_modules/sucrase/dist/parser/plugins/types.js
new file mode 100644
index 0000000..c892994
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/plugins/types.js
@@ -0,0 +1,37 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _index = require('../tokenizer/index');
+var _types = require('../tokenizer/types');
+var _base = require('../traverser/base');
+var _expression = require('../traverser/expression');
+var _flow = require('./flow');
+var _typescript = require('./typescript');
+
+/**
+ * Common parser code for TypeScript and Flow.
+ */
+
+// An apparent conditional expression could actually be an optional parameter in an arrow function.
+ function typedParseConditional(noIn) {
+  // If we see ?:, this can't possibly be a valid conditional. typedParseParenItem will be called
+  // later to finish off the arrow parameter. We also need to handle bare ? tokens for optional
+  // parameters without type annotations, i.e. ?, and ?) .
+  if (_index.match.call(void 0, _types.TokenType.question)) {
+    const nextType = _index.lookaheadType.call(void 0, );
+    if (nextType === _types.TokenType.colon || nextType === _types.TokenType.comma || nextType === _types.TokenType.parenR) {
+      return;
+    }
+  }
+  _expression.baseParseConditional.call(void 0, noIn);
+} exports.typedParseConditional = typedParseConditional;
+
+// Note: These "type casts" are *not* valid TS expressions.
+// But we parse them here and change them when completing the arrow function.
+ function typedParseParenItem() {
+  _index.eatTypeToken.call(void 0, _types.TokenType.question);
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    if (_base.isTypeScriptEnabled) {
+      _typescript.tsParseTypeAnnotation.call(void 0, );
+    } else if (_base.isFlowEnabled) {
+      _flow.flowParseTypeAnnotation.call(void 0, );
+    }
+  }
+} exports.typedParseParenItem = typedParseParenItem;
diff --git a/node_modules/sucrase/dist/parser/plugins/typescript.js b/node_modules/sucrase/dist/parser/plugins/typescript.js
new file mode 100644
index 0000000..d1ec6d3
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/plugins/typescript.js
@@ -0,0 +1,1632 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+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 _lval = require('../traverser/lval');
+
+
+
+
+
+
+
+
+var _statement = require('../traverser/statement');
+
+
+
+
+
+
+
+
+
+
+
+var _util = require('../traverser/util');
+var _jsx = require('./jsx');
+
+function tsIsIdentifier() {
+  // TODO: actually a bit more complex in TypeScript, but shouldn't matter.
+  // See https://github.com/Microsoft/TypeScript/issues/15008
+  return _index.match.call(void 0, _types.TokenType.name);
+}
+
+function isLiteralPropertyName() {
+  return (
+    _index.match.call(void 0, _types.TokenType.name) ||
+    Boolean(_base.state.type & _types.TokenType.IS_KEYWORD) ||
+    _index.match.call(void 0, _types.TokenType.string) ||
+    _index.match.call(void 0, _types.TokenType.num) ||
+    _index.match.call(void 0, _types.TokenType.bigint) ||
+    _index.match.call(void 0, _types.TokenType.decimal)
+  );
+}
+
+function tsNextTokenCanFollowModifier() {
+  // Note: TypeScript's implementation is much more complicated because
+  // more things are considered modifiers there.
+  // This implementation only handles modifiers not handled by babylon itself. And "static".
+  // TODO: Would be nice to avoid lookahead. Want a hasLineBreakUpNext() method...
+  const snapshot = _base.state.snapshot();
+
+  _index.next.call(void 0, );
+  const canFollowModifier =
+    (_index.match.call(void 0, _types.TokenType.bracketL) ||
+      _index.match.call(void 0, _types.TokenType.braceL) ||
+      _index.match.call(void 0, _types.TokenType.star) ||
+      _index.match.call(void 0, _types.TokenType.ellipsis) ||
+      _index.match.call(void 0, _types.TokenType.hash) ||
+      isLiteralPropertyName()) &&
+    !_util.hasPrecedingLineBreak.call(void 0, );
+
+  if (canFollowModifier) {
+    return true;
+  } else {
+    _base.state.restoreFromSnapshot(snapshot);
+    return false;
+  }
+}
+
+ function tsParseModifiers(allowedModifiers) {
+  while (true) {
+    const modifier = tsParseModifier(allowedModifiers);
+    if (modifier === null) {
+      break;
+    }
+  }
+} exports.tsParseModifiers = tsParseModifiers;
+
+/** Parses a modifier matching one the given modifier names. */
+ function tsParseModifier(
+  allowedModifiers,
+) {
+  if (!_index.match.call(void 0, _types.TokenType.name)) {
+    return null;
+  }
+
+  const modifier = _base.state.contextualKeyword;
+  if (allowedModifiers.indexOf(modifier) !== -1 && tsNextTokenCanFollowModifier()) {
+    switch (modifier) {
+      case _keywords.ContextualKeyword._readonly:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._readonly;
+        break;
+      case _keywords.ContextualKeyword._abstract:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._abstract;
+        break;
+      case _keywords.ContextualKeyword._static:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._static;
+        break;
+      case _keywords.ContextualKeyword._public:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._public;
+        break;
+      case _keywords.ContextualKeyword._private:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._private;
+        break;
+      case _keywords.ContextualKeyword._protected:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._protected;
+        break;
+      case _keywords.ContextualKeyword._override:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._override;
+        break;
+      case _keywords.ContextualKeyword._declare:
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._declare;
+        break;
+      default:
+        break;
+    }
+    return modifier;
+  }
+  return null;
+} exports.tsParseModifier = tsParseModifier;
+
+function tsParseEntityName() {
+  _expression.parseIdentifier.call(void 0, );
+  while (_index.eat.call(void 0, _types.TokenType.dot)) {
+    _expression.parseIdentifier.call(void 0, );
+  }
+}
+
+function tsParseTypeReference() {
+  tsParseEntityName();
+  if (!_util.hasPrecedingLineBreak.call(void 0, ) && _index.match.call(void 0, _types.TokenType.lessThan)) {
+    tsParseTypeArguments();
+  }
+}
+
+function tsParseThisTypePredicate() {
+  _index.next.call(void 0, );
+  tsParseTypeAnnotation();
+}
+
+function tsParseThisTypeNode() {
+  _index.next.call(void 0, );
+}
+
+function tsParseTypeQuery() {
+  _util.expect.call(void 0, _types.TokenType._typeof);
+  if (_index.match.call(void 0, _types.TokenType._import)) {
+    tsParseImportType();
+  } else {
+    tsParseEntityName();
+  }
+  if (!_util.hasPrecedingLineBreak.call(void 0, ) && _index.match.call(void 0, _types.TokenType.lessThan)) {
+    tsParseTypeArguments();
+  }
+}
+
+function tsParseImportType() {
+  _util.expect.call(void 0, _types.TokenType._import);
+  _util.expect.call(void 0, _types.TokenType.parenL);
+  _util.expect.call(void 0, _types.TokenType.string);
+  _util.expect.call(void 0, _types.TokenType.parenR);
+  if (_index.eat.call(void 0, _types.TokenType.dot)) {
+    tsParseEntityName();
+  }
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    tsParseTypeArguments();
+  }
+}
+
+function tsParseTypeParameter() {
+  _index.eat.call(void 0, _types.TokenType._const);
+  const hadIn = _index.eat.call(void 0, _types.TokenType._in);
+  const hadOut = _util.eatContextual.call(void 0, _keywords.ContextualKeyword._out);
+  _index.eat.call(void 0, _types.TokenType._const);
+  if ((hadIn || hadOut) && !_index.match.call(void 0, _types.TokenType.name)) {
+    // The "in" or "out" keyword must have actually been the type parameter
+    // name, so set it as the name.
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.name;
+  } else {
+    _expression.parseIdentifier.call(void 0, );
+  }
+
+  if (_index.eat.call(void 0, _types.TokenType._extends)) {
+    tsParseType();
+  }
+  if (_index.eat.call(void 0, _types.TokenType.eq)) {
+    tsParseType();
+  }
+}
+
+ function tsTryParseTypeParameters() {
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    tsParseTypeParameters();
+  }
+} exports.tsTryParseTypeParameters = tsTryParseTypeParameters;
+
+function tsParseTypeParameters() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  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, );
+  }
+
+  while (!_index.eat.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
+    tsParseTypeParameter();
+    _index.eat.call(void 0, _types.TokenType.comma);
+  }
+  _index.popTypeContext.call(void 0, oldIsType);
+}
+
+// Note: In TypeScript implementation we must provide `yieldContext` and `awaitContext`,
+// but here it's always false, because this is only used for types.
+function tsFillSignature(returnToken) {
+  // Arrow fns *must* have return token (`=>`). Normal functions can omit it.
+  const returnTokenRequired = returnToken === _types.TokenType.arrow;
+  tsTryParseTypeParameters();
+  _util.expect.call(void 0, _types.TokenType.parenL);
+  // Create a scope even though we're doing type parsing so we don't accidentally
+  // treat params as top-level bindings.
+  _base.state.scopeDepth++;
+  tsParseBindingListForSignature(false /* isBlockScope */);
+  _base.state.scopeDepth--;
+  if (returnTokenRequired) {
+    tsParseTypeOrTypePredicateAnnotation(returnToken);
+  } else if (_index.match.call(void 0, returnToken)) {
+    tsParseTypeOrTypePredicateAnnotation(returnToken);
+  }
+}
+
+function tsParseBindingListForSignature(isBlockScope) {
+  _lval.parseBindingList.call(void 0, _types.TokenType.parenR, isBlockScope);
+}
+
+function tsParseTypeMemberSemicolon() {
+  if (!_index.eat.call(void 0, _types.TokenType.comma)) {
+    _util.semicolon.call(void 0, );
+  }
+}
+
+function tsParseSignatureMember() {
+  tsFillSignature(_types.TokenType.colon);
+  tsParseTypeMemberSemicolon();
+}
+
+function tsIsUnambiguouslyIndexSignature() {
+  const snapshot = _base.state.snapshot();
+  _index.next.call(void 0, ); // Skip '{'
+  const isIndexSignature = _index.eat.call(void 0, _types.TokenType.name) && _index.match.call(void 0, _types.TokenType.colon);
+  _base.state.restoreFromSnapshot(snapshot);
+  return isIndexSignature;
+}
+
+function tsTryParseIndexSignature() {
+  if (!(_index.match.call(void 0, _types.TokenType.bracketL) && tsIsUnambiguouslyIndexSignature())) {
+    return false;
+  }
+
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+
+  _util.expect.call(void 0, _types.TokenType.bracketL);
+  _expression.parseIdentifier.call(void 0, );
+  tsParseTypeAnnotation();
+  _util.expect.call(void 0, _types.TokenType.bracketR);
+
+  tsTryParseTypeAnnotation();
+  tsParseTypeMemberSemicolon();
+
+  _index.popTypeContext.call(void 0, oldIsType);
+  return true;
+}
+
+function tsParsePropertyOrMethodSignature(isReadonly) {
+  _index.eat.call(void 0, _types.TokenType.question);
+
+  if (!isReadonly && (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan))) {
+    tsFillSignature(_types.TokenType.colon);
+    tsParseTypeMemberSemicolon();
+  } else {
+    tsTryParseTypeAnnotation();
+    tsParseTypeMemberSemicolon();
+  }
+}
+
+function tsParseTypeMember() {
+  if (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan)) {
+    // call signature
+    tsParseSignatureMember();
+    return;
+  }
+  if (_index.match.call(void 0, _types.TokenType._new)) {
+    _index.next.call(void 0, );
+    if (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan)) {
+      // constructor signature
+      tsParseSignatureMember();
+    } else {
+      tsParsePropertyOrMethodSignature(false);
+    }
+    return;
+  }
+  const readonly = !!tsParseModifier([_keywords.ContextualKeyword._readonly]);
+
+  const found = tsTryParseIndexSignature();
+  if (found) {
+    return;
+  }
+  if (
+    (_util.isContextual.call(void 0, _keywords.ContextualKeyword._get) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._set)) &&
+    tsNextTokenCanFollowModifier()
+  ) {
+    // This is a getter/setter on a type. The tsNextTokenCanFollowModifier
+    // function already called next() for us, so continue parsing the name.
+  }
+  _expression.parsePropertyName.call(void 0, -1 /* Types don't need context IDs. */);
+  tsParsePropertyOrMethodSignature(readonly);
+}
+
+function tsParseTypeLiteral() {
+  tsParseObjectTypeMembers();
+}
+
+function tsParseObjectTypeMembers() {
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  while (!_index.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    tsParseTypeMember();
+  }
+}
+
+function tsLookaheadIsStartOfMappedType() {
+  const snapshot = _base.state.snapshot();
+  const isStartOfMappedType = tsIsStartOfMappedType();
+  _base.state.restoreFromSnapshot(snapshot);
+  return isStartOfMappedType;
+}
+
+function tsIsStartOfMappedType() {
+  _index.next.call(void 0, );
+  if (_index.eat.call(void 0, _types.TokenType.plus) || _index.eat.call(void 0, _types.TokenType.minus)) {
+    return _util.isContextual.call(void 0, _keywords.ContextualKeyword._readonly);
+  }
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._readonly)) {
+    _index.next.call(void 0, );
+  }
+  if (!_index.match.call(void 0, _types.TokenType.bracketL)) {
+    return false;
+  }
+  _index.next.call(void 0, );
+  if (!tsIsIdentifier()) {
+    return false;
+  }
+  _index.next.call(void 0, );
+  return _index.match.call(void 0, _types.TokenType._in);
+}
+
+function tsParseMappedTypeParameter() {
+  _expression.parseIdentifier.call(void 0, );
+  _util.expect.call(void 0, _types.TokenType._in);
+  tsParseType();
+}
+
+function tsParseMappedType() {
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  if (_index.match.call(void 0, _types.TokenType.plus) || _index.match.call(void 0, _types.TokenType.minus)) {
+    _index.next.call(void 0, );
+    _util.expectContextual.call(void 0, _keywords.ContextualKeyword._readonly);
+  } else {
+    _util.eatContextual.call(void 0, _keywords.ContextualKeyword._readonly);
+  }
+  _util.expect.call(void 0, _types.TokenType.bracketL);
+  tsParseMappedTypeParameter();
+  if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
+    tsParseType();
+  }
+  _util.expect.call(void 0, _types.TokenType.bracketR);
+  if (_index.match.call(void 0, _types.TokenType.plus) || _index.match.call(void 0, _types.TokenType.minus)) {
+    _index.next.call(void 0, );
+    _util.expect.call(void 0, _types.TokenType.question);
+  } else {
+    _index.eat.call(void 0, _types.TokenType.question);
+  }
+  tsTryParseType();
+  _util.semicolon.call(void 0, );
+  _util.expect.call(void 0, _types.TokenType.braceR);
+}
+
+function tsParseTupleType() {
+  _util.expect.call(void 0, _types.TokenType.bracketL);
+  while (!_index.eat.call(void 0, _types.TokenType.bracketR) && !_base.state.error) {
+    // Do not validate presence of either none or only labeled elements
+    tsParseTupleElementType();
+    _index.eat.call(void 0, _types.TokenType.comma);
+  }
+}
+
+function tsParseTupleElementType() {
+  // parses `...TsType[]`
+  if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
+    tsParseType();
+  } else {
+    // parses `TsType?`
+    tsParseType();
+    _index.eat.call(void 0, _types.TokenType.question);
+  }
+
+  // The type we parsed above was actually a label
+  if (_index.eat.call(void 0, _types.TokenType.colon)) {
+    // Labeled tuple types must affix the label with `...` or `?`, so no need to handle those here
+    tsParseType();
+  }
+}
+
+function tsParseParenthesizedType() {
+  _util.expect.call(void 0, _types.TokenType.parenL);
+  tsParseType();
+  _util.expect.call(void 0, _types.TokenType.parenR);
+}
+
+function tsParseTemplateLiteralType() {
+  // Finish `, read quasi
+  _index.nextTemplateToken.call(void 0, );
+  // Finish quasi, read ${
+  _index.nextTemplateToken.call(void 0, );
+  while (!_index.match.call(void 0, _types.TokenType.backQuote) && !_base.state.error) {
+    _util.expect.call(void 0, _types.TokenType.dollarBraceL);
+    tsParseType();
+    // Finish }, read quasi
+    _index.nextTemplateToken.call(void 0, );
+    // Finish quasi, read either ${ or `
+    _index.nextTemplateToken.call(void 0, );
+  }
+  _index.next.call(void 0, );
+}
+
+var FunctionType; (function (FunctionType) {
+  const TSFunctionType = 0; FunctionType[FunctionType["TSFunctionType"] = TSFunctionType] = "TSFunctionType";
+  const TSConstructorType = TSFunctionType + 1; FunctionType[FunctionType["TSConstructorType"] = TSConstructorType] = "TSConstructorType";
+  const TSAbstractConstructorType = TSConstructorType + 1; FunctionType[FunctionType["TSAbstractConstructorType"] = TSAbstractConstructorType] = "TSAbstractConstructorType";
+})(FunctionType || (FunctionType = {}));
+
+function tsParseFunctionOrConstructorType(type) {
+  if (type === FunctionType.TSAbstractConstructorType) {
+    _util.expectContextual.call(void 0, _keywords.ContextualKeyword._abstract);
+  }
+  if (type === FunctionType.TSConstructorType || type === FunctionType.TSAbstractConstructorType) {
+    _util.expect.call(void 0, _types.TokenType._new);
+  }
+  const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
+  _base.state.inDisallowConditionalTypesContext = false;
+  tsFillSignature(_types.TokenType.arrow);
+  _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+}
+
+function tsParseNonArrayType() {
+  switch (_base.state.type) {
+    case _types.TokenType.name:
+      tsParseTypeReference();
+      return;
+    case _types.TokenType._void:
+    case _types.TokenType._null:
+      _index.next.call(void 0, );
+      return;
+    case _types.TokenType.string:
+    case _types.TokenType.num:
+    case _types.TokenType.bigint:
+    case _types.TokenType.decimal:
+    case _types.TokenType._true:
+    case _types.TokenType._false:
+      _expression.parseLiteral.call(void 0, );
+      return;
+    case _types.TokenType.minus:
+      _index.next.call(void 0, );
+      _expression.parseLiteral.call(void 0, );
+      return;
+    case _types.TokenType._this: {
+      tsParseThisTypeNode();
+      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._is) && !_util.hasPrecedingLineBreak.call(void 0, )) {
+        tsParseThisTypePredicate();
+      }
+      return;
+    }
+    case _types.TokenType._typeof:
+      tsParseTypeQuery();
+      return;
+    case _types.TokenType._import:
+      tsParseImportType();
+      return;
+    case _types.TokenType.braceL:
+      if (tsLookaheadIsStartOfMappedType()) {
+        tsParseMappedType();
+      } else {
+        tsParseTypeLiteral();
+      }
+      return;
+    case _types.TokenType.bracketL:
+      tsParseTupleType();
+      return;
+    case _types.TokenType.parenL:
+      tsParseParenthesizedType();
+      return;
+    case _types.TokenType.backQuote:
+      tsParseTemplateLiteralType();
+      return;
+    default:
+      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;
+      }
+      break;
+  }
+
+  _util.unexpected.call(void 0, );
+}
+
+function tsParseArrayTypeOrHigher() {
+  tsParseNonArrayType();
+  while (!_util.hasPrecedingLineBreak.call(void 0, ) && _index.eat.call(void 0, _types.TokenType.bracketL)) {
+    if (!_index.eat.call(void 0, _types.TokenType.bracketR)) {
+      // If we hit ] immediately, this is an array type, otherwise it's an indexed access type.
+      tsParseType();
+      _util.expect.call(void 0, _types.TokenType.bracketR);
+    }
+  }
+}
+
+function tsParseInferType() {
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._infer);
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType._extends)) {
+    // Infer type constraints introduce an ambiguity about whether the "extends"
+    // is a constraint for this infer type or is another conditional type.
+    const snapshot = _base.state.snapshot();
+    _util.expect.call(void 0, _types.TokenType._extends);
+    const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
+    _base.state.inDisallowConditionalTypesContext = true;
+    tsParseType();
+    _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+    if (_base.state.error || (!_base.state.inDisallowConditionalTypesContext && _index.match.call(void 0, _types.TokenType.question))) {
+      _base.state.restoreFromSnapshot(snapshot);
+    }
+  }
+}
+
+function tsParseTypeOperatorOrHigher() {
+  if (
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._keyof) ||
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._unique) ||
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._readonly)
+  ) {
+    _index.next.call(void 0, );
+    tsParseTypeOperatorOrHigher();
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._infer)) {
+    tsParseInferType();
+  } else {
+    const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
+    _base.state.inDisallowConditionalTypesContext = false;
+    tsParseArrayTypeOrHigher();
+    _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+  }
+}
+
+function tsParseIntersectionTypeOrHigher() {
+  _index.eat.call(void 0, _types.TokenType.bitwiseAND);
+  tsParseTypeOperatorOrHigher();
+  if (_index.match.call(void 0, _types.TokenType.bitwiseAND)) {
+    while (_index.eat.call(void 0, _types.TokenType.bitwiseAND)) {
+      tsParseTypeOperatorOrHigher();
+    }
+  }
+}
+
+function tsParseUnionTypeOrHigher() {
+  _index.eat.call(void 0, _types.TokenType.bitwiseOR);
+  tsParseIntersectionTypeOrHigher();
+  if (_index.match.call(void 0, _types.TokenType.bitwiseOR)) {
+    while (_index.eat.call(void 0, _types.TokenType.bitwiseOR)) {
+      tsParseIntersectionTypeOrHigher();
+    }
+  }
+}
+
+function tsIsStartOfFunctionType() {
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    return true;
+  }
+  return _index.match.call(void 0, _types.TokenType.parenL) && tsLookaheadIsUnambiguouslyStartOfFunctionType();
+}
+
+function tsSkipParameterStart() {
+  if (_index.match.call(void 0, _types.TokenType.name) || _index.match.call(void 0, _types.TokenType._this)) {
+    _index.next.call(void 0, );
+    return true;
+  }
+  // If this is a possible array/object destructure, walk to the matching bracket/brace.
+  // The next token after will tell us definitively whether this is a function param.
+  if (_index.match.call(void 0, _types.TokenType.braceL) || _index.match.call(void 0, _types.TokenType.bracketL)) {
+    let depth = 1;
+    _index.next.call(void 0, );
+    while (depth > 0 && !_base.state.error) {
+      if (_index.match.call(void 0, _types.TokenType.braceL) || _index.match.call(void 0, _types.TokenType.bracketL)) {
+        depth++;
+      } else if (_index.match.call(void 0, _types.TokenType.braceR) || _index.match.call(void 0, _types.TokenType.bracketR)) {
+        depth--;
+      }
+      _index.next.call(void 0, );
+    }
+    return true;
+  }
+  return false;
+}
+
+function tsLookaheadIsUnambiguouslyStartOfFunctionType() {
+  const snapshot = _base.state.snapshot();
+  const isUnambiguouslyStartOfFunctionType = tsIsUnambiguouslyStartOfFunctionType();
+  _base.state.restoreFromSnapshot(snapshot);
+  return isUnambiguouslyStartOfFunctionType;
+}
+
+function tsIsUnambiguouslyStartOfFunctionType() {
+  _index.next.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.parenR) || _index.match.call(void 0, _types.TokenType.ellipsis)) {
+    // ( )
+    // ( ...
+    return true;
+  }
+  if (tsSkipParameterStart()) {
+    if (_index.match.call(void 0, _types.TokenType.colon) || _index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.question) || _index.match.call(void 0, _types.TokenType.eq)) {
+      // ( xxx :
+      // ( xxx ,
+      // ( xxx ?
+      // ( xxx =
+      return true;
+    }
+    if (_index.match.call(void 0, _types.TokenType.parenR)) {
+      _index.next.call(void 0, );
+      if (_index.match.call(void 0, _types.TokenType.arrow)) {
+        // ( xxx ) =>
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function tsParseTypeOrTypePredicateAnnotation(returnToken) {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  _util.expect.call(void 0, returnToken);
+  const finishedReturn = tsParseTypePredicateOrAssertsPrefix();
+  if (!finishedReturn) {
+    tsParseType();
+  }
+  _index.popTypeContext.call(void 0, oldIsType);
+}
+
+function tsTryParseTypeOrTypePredicateAnnotation() {
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    tsParseTypeOrTypePredicateAnnotation(_types.TokenType.colon);
+  }
+}
+
+ function tsTryParseTypeAnnotation() {
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    tsParseTypeAnnotation();
+  }
+} exports.tsTryParseTypeAnnotation = tsTryParseTypeAnnotation;
+
+function tsTryParseType() {
+  if (_index.eat.call(void 0, _types.TokenType.colon)) {
+    tsParseType();
+  }
+}
+
+/**
+ * Detect a few special return syntax cases: `x is T`, `asserts x`, `asserts x is T`,
+ * `asserts this is T`.
+ *
+ * Returns true if we parsed the return type, false if there's still a type to be parsed.
+ */
+function tsParseTypePredicateOrAssertsPrefix() {
+  const snapshot = _base.state.snapshot();
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._asserts)) {
+    // Normally this is `asserts x is T`, but at this point, it might be `asserts is T` (a user-
+    // defined type guard on the `asserts` variable) or just a type called `asserts`.
+    _index.next.call(void 0, );
+    if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._is)) {
+      // If we see `asserts is`, then this must be of the form `asserts is T`, since
+      // `asserts is is T` isn't valid.
+      tsParseType();
+      return true;
+    } else if (tsIsIdentifier() || _index.match.call(void 0, _types.TokenType._this)) {
+      _index.next.call(void 0, );
+      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._is)) {
+        // If we see `is`, then this is `asserts x is T`. Otherwise, it's `asserts x`.
+        tsParseType();
+      }
+      return true;
+    } else {
+      // Regular type, so bail out and start type parsing from scratch.
+      _base.state.restoreFromSnapshot(snapshot);
+      return false;
+    }
+  } else if (tsIsIdentifier() || _index.match.call(void 0, _types.TokenType._this)) {
+    // This is a regular identifier, which may or may not have "is" after it.
+    _index.next.call(void 0, );
+    if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._is) && !_util.hasPrecedingLineBreak.call(void 0, )) {
+      _index.next.call(void 0, );
+      tsParseType();
+      return true;
+    } else {
+      // Regular type, so bail out and start type parsing from scratch.
+      _base.state.restoreFromSnapshot(snapshot);
+      return false;
+    }
+  }
+  return false;
+}
+
+ function tsParseTypeAnnotation() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  _util.expect.call(void 0, _types.TokenType.colon);
+  tsParseType();
+  _index.popTypeContext.call(void 0, oldIsType);
+} exports.tsParseTypeAnnotation = tsParseTypeAnnotation;
+
+ function tsParseType() {
+  tsParseNonConditionalType();
+  if (_base.state.inDisallowConditionalTypesContext || _util.hasPrecedingLineBreak.call(void 0, ) || !_index.eat.call(void 0, _types.TokenType._extends)) {
+    return;
+  }
+  // extends type
+  const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
+  _base.state.inDisallowConditionalTypesContext = true;
+  tsParseNonConditionalType();
+  _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+
+  _util.expect.call(void 0, _types.TokenType.question);
+  // true type
+  tsParseType();
+  _util.expect.call(void 0, _types.TokenType.colon);
+  // false type
+  tsParseType();
+} exports.tsParseType = tsParseType;
+
+function isAbstractConstructorSignature() {
+  return _util.isContextual.call(void 0, _keywords.ContextualKeyword._abstract) && _index.lookaheadType.call(void 0, ) === _types.TokenType._new;
+}
+
+ function tsParseNonConditionalType() {
+  if (tsIsStartOfFunctionType()) {
+    tsParseFunctionOrConstructorType(FunctionType.TSFunctionType);
+    return;
+  }
+  if (_index.match.call(void 0, _types.TokenType._new)) {
+    // As in `new () => Date`
+    tsParseFunctionOrConstructorType(FunctionType.TSConstructorType);
+    return;
+  } else if (isAbstractConstructorSignature()) {
+    // As in `abstract new () => Date`
+    tsParseFunctionOrConstructorType(FunctionType.TSAbstractConstructorType);
+    return;
+  }
+  tsParseUnionTypeOrHigher();
+} exports.tsParseNonConditionalType = tsParseNonConditionalType;
+
+ function tsParseTypeAssertion() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 1);
+  tsParseType();
+  _util.expect.call(void 0, _types.TokenType.greaterThan);
+  _index.popTypeContext.call(void 0, oldIsType);
+  _expression.parseMaybeUnary.call(void 0, );
+} exports.tsParseTypeAssertion = tsParseTypeAssertion;
+
+ function tsTryParseJSXTypeArgument() {
+  if (_index.eat.call(void 0, _types.TokenType.jsxTagStart)) {
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.typeParameterStart;
+    const oldIsType = _index.pushTypeContext.call(void 0, 1);
+    while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
+      tsParseType();
+      _index.eat.call(void 0, _types.TokenType.comma);
+    }
+    // Process >, but the one after needs to be parsed JSX-style.
+    _jsx.nextJSXTagToken.call(void 0, );
+    _index.popTypeContext.call(void 0, oldIsType);
+  }
+} exports.tsTryParseJSXTypeArgument = tsTryParseJSXTypeArgument;
+
+function tsParseHeritageClause() {
+  while (!_index.match.call(void 0, _types.TokenType.braceL) && !_base.state.error) {
+    tsParseExpressionWithTypeArguments();
+    _index.eat.call(void 0, _types.TokenType.comma);
+  }
+}
+
+function tsParseExpressionWithTypeArguments() {
+  // Note: TS uses parseLeftHandSideExpressionOrHigher,
+  // then has grammar errors later if it's not an EntityName.
+  tsParseEntityName();
+  if (_index.match.call(void 0, _types.TokenType.lessThan)) {
+    tsParseTypeArguments();
+  }
+}
+
+function tsParseInterfaceDeclaration() {
+  _lval.parseBindingIdentifier.call(void 0, false);
+  tsTryParseTypeParameters();
+  if (_index.eat.call(void 0, _types.TokenType._extends)) {
+    tsParseHeritageClause();
+  }
+  tsParseObjectTypeMembers();
+}
+
+function tsParseTypeAliasDeclaration() {
+  _lval.parseBindingIdentifier.call(void 0, false);
+  tsTryParseTypeParameters();
+  _util.expect.call(void 0, _types.TokenType.eq);
+  tsParseType();
+  _util.semicolon.call(void 0, );
+}
+
+function tsParseEnumMember() {
+  // Computed property names are grammar errors in an enum, so accept just string literal or identifier.
+  if (_index.match.call(void 0, _types.TokenType.string)) {
+    _expression.parseLiteral.call(void 0, );
+  } else {
+    _expression.parseIdentifier.call(void 0, );
+  }
+  if (_index.eat.call(void 0, _types.TokenType.eq)) {
+    const eqIndex = _base.state.tokens.length - 1;
+    _expression.parseMaybeAssign.call(void 0, );
+    _base.state.tokens[eqIndex].rhsEndIndex = _base.state.tokens.length;
+  }
+}
+
+function tsParseEnumDeclaration() {
+  _lval.parseBindingIdentifier.call(void 0, false);
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  while (!_index.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    tsParseEnumMember();
+    _index.eat.call(void 0, _types.TokenType.comma);
+  }
+}
+
+function tsParseModuleBlock() {
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  _statement.parseBlockBody.call(void 0, /* end */ _types.TokenType.braceR);
+}
+
+function tsParseModuleOrNamespaceDeclaration() {
+  _lval.parseBindingIdentifier.call(void 0, false);
+  if (_index.eat.call(void 0, _types.TokenType.dot)) {
+    tsParseModuleOrNamespaceDeclaration();
+  } else {
+    tsParseModuleBlock();
+  }
+}
+
+function tsParseAmbientExternalModuleDeclaration() {
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._global)) {
+    _expression.parseIdentifier.call(void 0, );
+  } else if (_index.match.call(void 0, _types.TokenType.string)) {
+    _expression.parseExprAtom.call(void 0, );
+  } else {
+    _util.unexpected.call(void 0, );
+  }
+
+  if (_index.match.call(void 0, _types.TokenType.braceL)) {
+    tsParseModuleBlock();
+  } else {
+    _util.semicolon.call(void 0, );
+  }
+}
+
+ function tsParseImportEqualsDeclaration() {
+  _lval.parseImportedIdentifier.call(void 0, );
+  _util.expect.call(void 0, _types.TokenType.eq);
+  tsParseModuleReference();
+  _util.semicolon.call(void 0, );
+} exports.tsParseImportEqualsDeclaration = tsParseImportEqualsDeclaration;
+
+function tsIsExternalModuleReference() {
+  return _util.isContextual.call(void 0, _keywords.ContextualKeyword._require) && _index.lookaheadType.call(void 0, ) === _types.TokenType.parenL;
+}
+
+function tsParseModuleReference() {
+  if (tsIsExternalModuleReference()) {
+    tsParseExternalModuleReference();
+  } else {
+    tsParseEntityName();
+  }
+}
+
+function tsParseExternalModuleReference() {
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._require);
+  _util.expect.call(void 0, _types.TokenType.parenL);
+  if (!_index.match.call(void 0, _types.TokenType.string)) {
+    _util.unexpected.call(void 0, );
+  }
+  _expression.parseLiteral.call(void 0, );
+  _util.expect.call(void 0, _types.TokenType.parenR);
+}
+
+// Utilities
+
+// Returns true if a statement matched.
+function tsTryParseDeclare() {
+  if (_util.isLineTerminator.call(void 0, )) {
+    return false;
+  }
+  switch (_base.state.type) {
+    case _types.TokenType._function: {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      _index.next.call(void 0, );
+      // We don't need to precisely get the function start here, since it's only used to mark
+      // the function as a type if it's bodiless, and it's already a type here.
+      const functionStart = _base.state.start;
+      _statement.parseFunction.call(void 0, functionStart, /* isStatement */ true);
+      _index.popTypeContext.call(void 0, oldIsType);
+      return true;
+    }
+    case _types.TokenType._class: {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      _statement.parseClass.call(void 0, /* isStatement */ true, /* optionalId */ false);
+      _index.popTypeContext.call(void 0, oldIsType);
+      return true;
+    }
+    case _types.TokenType._const: {
+      if (_index.match.call(void 0, _types.TokenType._const) && _util.isLookaheadContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
+        const oldIsType = _index.pushTypeContext.call(void 0, 1);
+        // `const enum = 0;` not allowed because "enum" is a strict mode reserved word.
+        _util.expect.call(void 0, _types.TokenType._const);
+        _util.expectContextual.call(void 0, _keywords.ContextualKeyword._enum);
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
+        tsParseEnumDeclaration();
+        _index.popTypeContext.call(void 0, oldIsType);
+        return true;
+      }
+    }
+    // falls through
+    case _types.TokenType._var:
+    case _types.TokenType._let: {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      _statement.parseVarStatement.call(void 0, _base.state.type !== _types.TokenType._var);
+      _index.popTypeContext.call(void 0, oldIsType);
+      return true;
+    }
+    case _types.TokenType.name: {
+      const oldIsType = _index.pushTypeContext.call(void 0, 1);
+      const contextualKeyword = _base.state.contextualKeyword;
+      let matched = false;
+      if (contextualKeyword === _keywords.ContextualKeyword._global) {
+        tsParseAmbientExternalModuleDeclaration();
+        matched = true;
+      } else {
+        matched = tsParseDeclaration(contextualKeyword, /* isBeforeToken */ true);
+      }
+      _index.popTypeContext.call(void 0, oldIsType);
+      return matched;
+    }
+    default:
+      return false;
+  }
+}
+
+// Note: this won't be called unless the keyword is allowed in `shouldParseExportDeclaration`.
+// Returns true if it matched a declaration.
+function tsTryParseExportDeclaration() {
+  return tsParseDeclaration(_base.state.contextualKeyword, /* isBeforeToken */ true);
+}
+
+// Returns true if it matched a statement.
+function tsParseExpressionStatement(contextualKeyword) {
+  switch (contextualKeyword) {
+    case _keywords.ContextualKeyword._declare: {
+      const declareTokenIndex = _base.state.tokens.length - 1;
+      const matched = tsTryParseDeclare();
+      if (matched) {
+        _base.state.tokens[declareTokenIndex].type = _types.TokenType._declare;
+        return true;
+      }
+      break;
+    }
+    case _keywords.ContextualKeyword._global:
+      // `global { }` (with no `declare`) may appear inside an ambient module declaration.
+      // Would like to use tsParseAmbientExternalModuleDeclaration here, but already ran past "global".
+      if (_index.match.call(void 0, _types.TokenType.braceL)) {
+        tsParseModuleBlock();
+        return true;
+      }
+      break;
+
+    default:
+      return tsParseDeclaration(contextualKeyword, /* isBeforeToken */ false);
+  }
+  return false;
+}
+
+/**
+ * Common code for parsing a declaration.
+ *
+ * isBeforeToken indicates that the current parser state is at the contextual
+ * keyword (and that it is not yet emitted) rather than reading the token after
+ * it. When isBeforeToken is true, we may be preceded by an `export` token and
+ * should include that token in a type context we create, e.g. to handle
+ * `export interface` or `export type`. (This is a bit of a hack and should be
+ * cleaned up at some point.)
+ *
+ * Returns true if it matched a declaration.
+ */
+function tsParseDeclaration(contextualKeyword, isBeforeToken) {
+  switch (contextualKeyword) {
+    case _keywords.ContextualKeyword._abstract:
+      if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType._class)) {
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._abstract;
+        _statement.parseClass.call(void 0, /* isStatement */ true, /* optionalId */ false);
+        return true;
+      }
+      break;
+
+    case _keywords.ContextualKeyword._enum:
+      if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
+        tsParseEnumDeclaration();
+        return true;
+      }
+      break;
+
+    case _keywords.ContextualKeyword._interface:
+      if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
+        // `next` is true in "export" and "declare" contexts, so we want to remove that token
+        // as well.
+        const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
+        tsParseInterfaceDeclaration();
+        _index.popTypeContext.call(void 0, oldIsType);
+        return true;
+      }
+      break;
+
+    case _keywords.ContextualKeyword._module:
+      if (tsCheckLineTerminator(isBeforeToken)) {
+        if (_index.match.call(void 0, _types.TokenType.string)) {
+          const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
+          tsParseAmbientExternalModuleDeclaration();
+          _index.popTypeContext.call(void 0, oldIsType);
+          return true;
+        } else if (_index.match.call(void 0, _types.TokenType.name)) {
+          const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
+          tsParseModuleOrNamespaceDeclaration();
+          _index.popTypeContext.call(void 0, oldIsType);
+          return true;
+        }
+      }
+      break;
+
+    case _keywords.ContextualKeyword._namespace:
+      if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
+        const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
+        tsParseModuleOrNamespaceDeclaration();
+        _index.popTypeContext.call(void 0, oldIsType);
+        return true;
+      }
+      break;
+
+    case _keywords.ContextualKeyword._type:
+      if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
+        const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
+        tsParseTypeAliasDeclaration();
+        _index.popTypeContext.call(void 0, oldIsType);
+        return true;
+      }
+      break;
+
+    default:
+      break;
+  }
+  return false;
+}
+
+function tsCheckLineTerminator(isBeforeToken) {
+  if (isBeforeToken) {
+    // Babel checks hasFollowingLineBreak here and returns false, but this
+    // doesn't actually come up, e.g. `export interface` can never be on its own
+    // line in valid code.
+    _index.next.call(void 0, );
+    return true;
+  } else {
+    return !_util.isLineTerminator.call(void 0, );
+  }
+}
+
+// Returns true if there was a generic async arrow function.
+function tsTryParseGenericAsyncArrowFunction() {
+  const snapshot = _base.state.snapshot();
+
+  tsParseTypeParameters();
+  _statement.parseFunctionParams.call(void 0, );
+  tsTryParseTypeOrTypePredicateAnnotation();
+  _util.expect.call(void 0, _types.TokenType.arrow);
+
+  if (_base.state.error) {
+    _base.state.restoreFromSnapshot(snapshot);
+    return false;
+  }
+
+  _expression.parseFunctionBody.call(void 0, true);
+  return true;
+}
+
+/**
+ * If necessary, hack the tokenizer state so that this bitshift was actually a
+ * less-than token, then keep parsing. This should only be used in situations
+ * where we restore from snapshot on error (which reverts this change) or
+ * where bitshift would be illegal anyway (e.g. in a class "extends" clause).
+ *
+ * This hack is useful to handle situations like foo<<T>() => void>() where
+ * there can legitimately be two open-angle-brackets in a row in TS.
+ */
+function tsParseTypeArgumentsWithPossibleBitshift() {
+  if (_base.state.type === _types.TokenType.bitShiftL) {
+    _base.state.pos -= 1;
+    _index.finishToken.call(void 0, _types.TokenType.lessThan);
+  }
+  tsParseTypeArguments();
+}
+
+function tsParseTypeArguments() {
+  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) {
+    tsParseType();
+    _index.eat.call(void 0, _types.TokenType.comma);
+  }
+  if (!oldIsType) {
+    // If the type arguments are present in an expression context, e.g.
+    // f<number>(), then the > sign should be tokenized as a non-type token.
+    // In particular, f(a < b, c >= d) should parse the >= as a single token,
+    // resulting in a syntax error and fallback to the non-type-args
+    // interpretation. In the success case, even though the > is tokenized as a
+    // non-type token, it still must be marked as a type token so that it is
+    // erased.
+    _index.popTypeContext.call(void 0, oldIsType);
+    _index.rescan_gt.call(void 0, );
+    _util.expect.call(void 0, _types.TokenType.greaterThan);
+    _base.state.tokens[_base.state.tokens.length - 1].isType = true;
+  } else {
+    _util.expect.call(void 0, _types.TokenType.greaterThan);
+    _index.popTypeContext.call(void 0, oldIsType);
+  }
+}
+
+ function tsIsDeclarationStart() {
+  if (_index.match.call(void 0, _types.TokenType.name)) {
+    switch (_base.state.contextualKeyword) {
+      case _keywords.ContextualKeyword._abstract:
+      case _keywords.ContextualKeyword._declare:
+      case _keywords.ContextualKeyword._enum:
+      case _keywords.ContextualKeyword._interface:
+      case _keywords.ContextualKeyword._module:
+      case _keywords.ContextualKeyword._namespace:
+      case _keywords.ContextualKeyword._type:
+        return true;
+      default:
+        break;
+    }
+  }
+
+  return false;
+} exports.tsIsDeclarationStart = tsIsDeclarationStart;
+
+// ======================================================
+// OVERRIDES
+// ======================================================
+
+ function tsParseFunctionBodyAndFinish(functionStart, funcContextId) {
+  // For arrow functions, `parseArrow` handles the return type itself.
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    tsParseTypeOrTypePredicateAnnotation(_types.TokenType.colon);
+  }
+
+  // The original code checked the node type to make sure this function type allows a missing
+  // body, but we skip that to avoid sending around the node type. We instead just use the
+  // allowExpressionBody boolean to make sure it's not an arrow function.
+  if (!_index.match.call(void 0, _types.TokenType.braceL) && _util.isLineTerminator.call(void 0, )) {
+    // Retroactively mark the function declaration as a type.
+    let i = _base.state.tokens.length - 1;
+    while (
+      i >= 0 &&
+      (_base.state.tokens[i].start >= functionStart ||
+        _base.state.tokens[i].type === _types.TokenType._default ||
+        _base.state.tokens[i].type === _types.TokenType._export)
+    ) {
+      _base.state.tokens[i].isType = true;
+      i--;
+    }
+    return;
+  }
+
+  _expression.parseFunctionBody.call(void 0, false, funcContextId);
+} exports.tsParseFunctionBodyAndFinish = tsParseFunctionBodyAndFinish;
+
+ function tsParseSubscript(
+  startTokenIndex,
+  noCalls,
+  stopState,
+) {
+  if (!_util.hasPrecedingLineBreak.call(void 0, ) && _index.eat.call(void 0, _types.TokenType.bang)) {
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.nonNullAssertion;
+    return;
+  }
+
+  if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.bitShiftL)) {
+    // There are number of things we are going to "maybe" parse, like type arguments on
+    // tagged template expressions. If any of them fail, walk it back and continue.
+    const snapshot = _base.state.snapshot();
+
+    if (!noCalls && _expression.atPossibleAsync.call(void 0, )) {
+      // Almost certainly this is a generic async function `async <T>() => ...
+      // But it might be a call with a type argument `async<T>();`
+      const asyncArrowFn = tsTryParseGenericAsyncArrowFunction();
+      if (asyncArrowFn) {
+        return;
+      }
+    }
+    tsParseTypeArgumentsWithPossibleBitshift();
+    if (!noCalls && _index.eat.call(void 0, _types.TokenType.parenL)) {
+      // With f<T>(), the subscriptStartIndex marker is on the ( token.
+      _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
+      _expression.parseCallExpressionArguments.call(void 0, );
+    } else if (_index.match.call(void 0, _types.TokenType.backQuote)) {
+      // Tagged template with a type argument.
+      _expression.parseTemplate.call(void 0, );
+    } else if (
+      // The remaining possible case is an instantiation expression, e.g.
+      // Array<number> . Check for a few cases that would disqualify it and
+      // cause us to bail out.
+      // a<b>>c is not (a<b>)>c, but a<(b>>c)
+      _base.state.type === _types.TokenType.greaterThan ||
+      // a<b>c is (a<b)>c
+      (_base.state.type !== _types.TokenType.parenL &&
+        Boolean(_base.state.type & _types.TokenType.IS_EXPRESSION_START) &&
+        !_util.hasPrecedingLineBreak.call(void 0, ))
+    ) {
+      // Bail out. We have something like a<b>c, which is not an expression with
+      // type arguments but an (a < b) > c comparison.
+      _util.unexpected.call(void 0, );
+    }
+
+    if (_base.state.error) {
+      _base.state.restoreFromSnapshot(snapshot);
+    } else {
+      return;
+    }
+  } else if (!noCalls && _index.match.call(void 0, _types.TokenType.questionDot) && _index.lookaheadType.call(void 0, ) === _types.TokenType.lessThan) {
+    // If we see f?.<, then this must be an optional call with a type argument.
+    _index.next.call(void 0, );
+    _base.state.tokens[startTokenIndex].isOptionalChainStart = true;
+    // With f?.<T>(), the subscriptStartIndex marker is on the ?. token.
+    _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
+
+    tsParseTypeArguments();
+    _util.expect.call(void 0, _types.TokenType.parenL);
+    _expression.parseCallExpressionArguments.call(void 0, );
+  }
+  _expression.baseParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
+} exports.tsParseSubscript = tsParseSubscript;
+
+ function tsTryParseExport() {
+  if (_index.eat.call(void 0, _types.TokenType._import)) {
+    // One of these cases:
+    // export import A = B;
+    // export import type A = require("A");
+    if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type) && _index.lookaheadType.call(void 0, ) !== _types.TokenType.eq) {
+      // Eat a `type` token, unless it's actually an identifier name.
+      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
+    }
+    tsParseImportEqualsDeclaration();
+    return true;
+  } else if (_index.eat.call(void 0, _types.TokenType.eq)) {
+    // `export = x;`
+    _expression.parseExpression.call(void 0, );
+    _util.semicolon.call(void 0, );
+    return true;
+  } else if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
+    // `export as namespace A;`
+    // See `parseNamespaceExportDeclaration` in TypeScript's own parser
+    _util.expectContextual.call(void 0, _keywords.ContextualKeyword._namespace);
+    _expression.parseIdentifier.call(void 0, );
+    _util.semicolon.call(void 0, );
+    return true;
+  } else {
+    if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
+      const nextType = _index.lookaheadType.call(void 0, );
+      // export type {foo} from 'a';
+      // export type * from 'a';'
+      // export type * as ns from 'a';'
+      if (nextType === _types.TokenType.braceL || nextType === _types.TokenType.star) {
+        _index.next.call(void 0, );
+      }
+    }
+    return false;
+  }
+} exports.tsTryParseExport = tsTryParseExport;
+
+/**
+ * Parse a TS import specifier, which may be prefixed with "type" and may be of
+ * the form `foo as bar`.
+ *
+ * The number of identifier-like tokens we see happens to be enough to uniquely
+ * identify the form, so simply count the number of identifiers rather than
+ * matching the words `type` or `as`. This is particularly important because
+ * `type` and `as` could each actually be plain identifiers rather than
+ * keywords.
+ */
+ function tsParseImportSpecifier() {
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
+    // import {foo}
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
+    return;
+  }
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
+    // import {type foo}
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
+    _base.state.tokens[_base.state.tokens.length - 2].isType = true;
+    _base.state.tokens[_base.state.tokens.length - 1].isType = true;
+    return;
+  }
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
+    // import {foo as bar}
+    _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ImportAccess;
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
+    return;
+  }
+  _expression.parseIdentifier.call(void 0, );
+  // import {type foo as bar}
+  _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ImportAccess;
+  _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
+  _base.state.tokens[_base.state.tokens.length - 4].isType = true;
+  _base.state.tokens[_base.state.tokens.length - 3].isType = true;
+  _base.state.tokens[_base.state.tokens.length - 2].isType = true;
+  _base.state.tokens[_base.state.tokens.length - 1].isType = true;
+} exports.tsParseImportSpecifier = tsParseImportSpecifier;
+
+/**
+ * Just like named import specifiers, export specifiers can have from 1 to 4
+ * tokens, inclusive, and the number of tokens determines the role of each token.
+ */
+ function tsParseExportSpecifier() {
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
+    // export {foo}
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ExportAccess;
+    return;
+  }
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
+    // export {type foo}
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ExportAccess;
+    _base.state.tokens[_base.state.tokens.length - 2].isType = true;
+    _base.state.tokens[_base.state.tokens.length - 1].isType = true;
+    return;
+  }
+  _expression.parseIdentifier.call(void 0, );
+  if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
+    // export {foo as bar}
+    _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ExportAccess;
+    return;
+  }
+  _expression.parseIdentifier.call(void 0, );
+  // export {type foo as bar}
+  _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ExportAccess;
+  _base.state.tokens[_base.state.tokens.length - 4].isType = true;
+  _base.state.tokens[_base.state.tokens.length - 3].isType = true;
+  _base.state.tokens[_base.state.tokens.length - 2].isType = true;
+  _base.state.tokens[_base.state.tokens.length - 1].isType = true;
+} exports.tsParseExportSpecifier = tsParseExportSpecifier;
+
+ function tsTryParseExportDefaultExpression() {
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._abstract) && _index.lookaheadType.call(void 0, ) === _types.TokenType._class) {
+    _base.state.type = _types.TokenType._abstract;
+    _index.next.call(void 0, ); // Skip "abstract"
+    _statement.parseClass.call(void 0, true, true);
+    return true;
+  }
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
+    // Make sure "export default" are considered type tokens so the whole thing is removed.
+    const oldIsType = _index.pushTypeContext.call(void 0, 2);
+    tsParseDeclaration(_keywords.ContextualKeyword._interface, true);
+    _index.popTypeContext.call(void 0, oldIsType);
+    return true;
+  }
+  return false;
+} exports.tsTryParseExportDefaultExpression = tsTryParseExportDefaultExpression;
+
+ function tsTryParseStatementContent() {
+  if (_base.state.type === _types.TokenType._const) {
+    const ahead = _index.lookaheadTypeAndKeyword.call(void 0, );
+    if (ahead.type === _types.TokenType.name && ahead.contextualKeyword === _keywords.ContextualKeyword._enum) {
+      _util.expect.call(void 0, _types.TokenType._const);
+      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._enum);
+      _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
+      tsParseEnumDeclaration();
+      return true;
+    }
+  }
+  return false;
+} exports.tsTryParseStatementContent = tsTryParseStatementContent;
+
+ function tsTryParseClassMemberWithIsStatic(isStatic) {
+  const memberStartIndexAfterStatic = _base.state.tokens.length;
+  tsParseModifiers([
+    _keywords.ContextualKeyword._abstract,
+    _keywords.ContextualKeyword._readonly,
+    _keywords.ContextualKeyword._declare,
+    _keywords.ContextualKeyword._static,
+    _keywords.ContextualKeyword._override,
+  ]);
+
+  const modifiersEndIndex = _base.state.tokens.length;
+  const found = tsTryParseIndexSignature();
+  if (found) {
+    // Index signatures are type declarations, so set the modifier tokens as
+    // type tokens. Most tokens could be assumed to be type tokens, but `static`
+    // is ambiguous unless we set it explicitly here.
+    const memberStartIndex = isStatic
+      ? memberStartIndexAfterStatic - 1
+      : memberStartIndexAfterStatic;
+    for (let i = memberStartIndex; i < modifiersEndIndex; i++) {
+      _base.state.tokens[i].isType = true;
+    }
+    return true;
+  }
+  return false;
+} exports.tsTryParseClassMemberWithIsStatic = tsTryParseClassMemberWithIsStatic;
+
+// Note: The reason we do this in `parseIdentifierStatement` and not `parseStatement`
+// is that e.g. `type()` is valid JS, so we must try parsing that first.
+// If it's really a type, we will parse `type` as the statement, and can correct it here
+// by parsing the rest.
+ function tsParseIdentifierStatement(contextualKeyword) {
+  const matched = tsParseExpressionStatement(contextualKeyword);
+  if (!matched) {
+    _util.semicolon.call(void 0, );
+  }
+} exports.tsParseIdentifierStatement = tsParseIdentifierStatement;
+
+ function tsParseExportDeclaration() {
+  // "export declare" is equivalent to just "export".
+  const isDeclare = _util.eatContextual.call(void 0, _keywords.ContextualKeyword._declare);
+  if (isDeclare) {
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._declare;
+  }
+
+  let matchedDeclaration = false;
+  if (_index.match.call(void 0, _types.TokenType.name)) {
+    if (isDeclare) {
+      const oldIsType = _index.pushTypeContext.call(void 0, 2);
+      matchedDeclaration = tsTryParseExportDeclaration();
+      _index.popTypeContext.call(void 0, oldIsType);
+    } else {
+      matchedDeclaration = tsTryParseExportDeclaration();
+    }
+  }
+  if (!matchedDeclaration) {
+    if (isDeclare) {
+      const oldIsType = _index.pushTypeContext.call(void 0, 2);
+      _statement.parseStatement.call(void 0, true);
+      _index.popTypeContext.call(void 0, oldIsType);
+    } else {
+      _statement.parseStatement.call(void 0, true);
+    }
+  }
+} exports.tsParseExportDeclaration = tsParseExportDeclaration;
+
+ function tsAfterParseClassSuper(hasSuper) {
+  if (hasSuper && (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.bitShiftL))) {
+    tsParseTypeArgumentsWithPossibleBitshift();
+  }
+  if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._implements;
+    const oldIsType = _index.pushTypeContext.call(void 0, 1);
+    tsParseHeritageClause();
+    _index.popTypeContext.call(void 0, oldIsType);
+  }
+} exports.tsAfterParseClassSuper = tsAfterParseClassSuper;
+
+ function tsStartParseObjPropValue() {
+  tsTryParseTypeParameters();
+} exports.tsStartParseObjPropValue = tsStartParseObjPropValue;
+
+ function tsStartParseFunctionParams() {
+  tsTryParseTypeParameters();
+} exports.tsStartParseFunctionParams = tsStartParseFunctionParams;
+
+// `let x: number;`
+ function tsAfterParseVarHead() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  if (!_util.hasPrecedingLineBreak.call(void 0, )) {
+    _index.eat.call(void 0, _types.TokenType.bang);
+  }
+  tsTryParseTypeAnnotation();
+  _index.popTypeContext.call(void 0, oldIsType);
+} exports.tsAfterParseVarHead = tsAfterParseVarHead;
+
+// parse the return type of an async arrow function - let foo = (async (): number => {});
+ function tsStartParseAsyncArrowFromCallExpression() {
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    tsParseTypeAnnotation();
+  }
+} exports.tsStartParseAsyncArrowFromCallExpression = tsStartParseAsyncArrowFromCallExpression;
+
+// Returns true if the expression was an arrow function.
+ function tsParseMaybeAssign(noIn, isWithinParens) {
+  // Note: When the JSX plugin is on, type assertions (`<T> x`) aren't valid syntax.
+  if (_base.isJSXEnabled) {
+    return tsParseMaybeAssignWithJSX(noIn, isWithinParens);
+  } else {
+    return tsParseMaybeAssignWithoutJSX(noIn, isWithinParens);
+  }
+} exports.tsParseMaybeAssign = tsParseMaybeAssign;
+
+ function tsParseMaybeAssignWithJSX(noIn, isWithinParens) {
+  if (!_index.match.call(void 0, _types.TokenType.lessThan)) {
+    return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+  }
+
+  // Prefer to parse JSX if possible. But may be an arrow fn.
+  const snapshot = _base.state.snapshot();
+  let wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+  if (_base.state.error) {
+    _base.state.restoreFromSnapshot(snapshot);
+  } else {
+    return wasArrow;
+  }
+
+  // Otherwise, try as type-parameterized arrow function.
+  _base.state.type = _types.TokenType.typeParameterStart;
+  // This is similar to TypeScript's `tryParseParenthesizedArrowFunctionExpression`.
+  tsParseTypeParameters();
+  wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+  if (!wasArrow) {
+    _util.unexpected.call(void 0, );
+  }
+
+  return wasArrow;
+} exports.tsParseMaybeAssignWithJSX = tsParseMaybeAssignWithJSX;
+
+ function tsParseMaybeAssignWithoutJSX(noIn, isWithinParens) {
+  if (!_index.match.call(void 0, _types.TokenType.lessThan)) {
+    return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+  }
+
+  const snapshot = _base.state.snapshot();
+  // This is similar to TypeScript's `tryParseParenthesizedArrowFunctionExpression`.
+  tsParseTypeParameters();
+  const wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+  if (!wasArrow) {
+    _util.unexpected.call(void 0, );
+  }
+  if (_base.state.error) {
+    _base.state.restoreFromSnapshot(snapshot);
+  } else {
+    return wasArrow;
+  }
+
+  // Try parsing a type cast instead of an arrow function.
+  // This will start with a type assertion (via parseMaybeUnary).
+  // But don't directly call `tsParseTypeAssertion` because we want to handle any binary after it.
+  return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
+} exports.tsParseMaybeAssignWithoutJSX = tsParseMaybeAssignWithoutJSX;
+
+ function tsParseArrow() {
+  if (_index.match.call(void 0, _types.TokenType.colon)) {
+    // This is different from how the TS parser does it.
+    // TS uses lookahead. Babylon parses it as a parenthesized expression and converts.
+    const snapshot = _base.state.snapshot();
+
+    tsParseTypeOrTypePredicateAnnotation(_types.TokenType.colon);
+    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);
+    }
+  }
+  return _index.eat.call(void 0, _types.TokenType.arrow);
+} exports.tsParseArrow = tsParseArrow;
+
+// Allow type annotations inside of a parameter list.
+ function tsParseAssignableListItemTypes() {
+  const oldIsType = _index.pushTypeContext.call(void 0, 0);
+  _index.eat.call(void 0, _types.TokenType.question);
+  tsTryParseTypeAnnotation();
+  _index.popTypeContext.call(void 0, oldIsType);
+} exports.tsParseAssignableListItemTypes = tsParseAssignableListItemTypes;
+
+ function tsParseMaybeDecoratorArguments() {
+  if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.bitShiftL)) {
+    tsParseTypeArgumentsWithPossibleBitshift();
+  }
+  _statement.baseParseMaybeDecoratorArguments.call(void 0, );
+} exports.tsParseMaybeDecoratorArguments = tsParseMaybeDecoratorArguments;
diff --git a/node_modules/sucrase/dist/parser/tokenizer/index.js b/node_modules/sucrase/dist/parser/tokenizer/index.js
new file mode 100644
index 0000000..84f5e14
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/tokenizer/index.js
@@ -0,0 +1,1004 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }/* eslint max-len: 0 */
+
+var _base = require('../traverser/base');
+var _util = require('../traverser/util');
+var _charcodes = require('../util/charcodes');
+var _identifier = require('../util/identifier');
+var _whitespace = require('../util/whitespace');
+var _keywords = require('./keywords');
+var _readWord = require('./readWord'); var _readWord2 = _interopRequireDefault(_readWord);
+var _types = require('./types');
+
+var IdentifierRole; (function (IdentifierRole) {
+  const Access = 0; IdentifierRole[IdentifierRole["Access"] = Access] = "Access";
+  const ExportAccess = Access + 1; IdentifierRole[IdentifierRole["ExportAccess"] = ExportAccess] = "ExportAccess";
+  const TopLevelDeclaration = ExportAccess + 1; IdentifierRole[IdentifierRole["TopLevelDeclaration"] = TopLevelDeclaration] = "TopLevelDeclaration";
+  const FunctionScopedDeclaration = TopLevelDeclaration + 1; IdentifierRole[IdentifierRole["FunctionScopedDeclaration"] = FunctionScopedDeclaration] = "FunctionScopedDeclaration";
+  const BlockScopedDeclaration = FunctionScopedDeclaration + 1; IdentifierRole[IdentifierRole["BlockScopedDeclaration"] = BlockScopedDeclaration] = "BlockScopedDeclaration";
+  const ObjectShorthandTopLevelDeclaration = BlockScopedDeclaration + 1; IdentifierRole[IdentifierRole["ObjectShorthandTopLevelDeclaration"] = ObjectShorthandTopLevelDeclaration] = "ObjectShorthandTopLevelDeclaration";
+  const ObjectShorthandFunctionScopedDeclaration = ObjectShorthandTopLevelDeclaration + 1; IdentifierRole[IdentifierRole["ObjectShorthandFunctionScopedDeclaration"] = ObjectShorthandFunctionScopedDeclaration] = "ObjectShorthandFunctionScopedDeclaration";
+  const ObjectShorthandBlockScopedDeclaration = ObjectShorthandFunctionScopedDeclaration + 1; IdentifierRole[IdentifierRole["ObjectShorthandBlockScopedDeclaration"] = ObjectShorthandBlockScopedDeclaration] = "ObjectShorthandBlockScopedDeclaration";
+  const ObjectShorthand = ObjectShorthandBlockScopedDeclaration + 1; IdentifierRole[IdentifierRole["ObjectShorthand"] = ObjectShorthand] = "ObjectShorthand";
+  // Any identifier bound in an import statement, e.g. both A and b from
+  // `import A, * as b from 'A';`
+  const ImportDeclaration = ObjectShorthand + 1; IdentifierRole[IdentifierRole["ImportDeclaration"] = ImportDeclaration] = "ImportDeclaration";
+  const ObjectKey = ImportDeclaration + 1; IdentifierRole[IdentifierRole["ObjectKey"] = ObjectKey] = "ObjectKey";
+  // The `foo` in `import {foo as bar} from "./abc";`.
+  const ImportAccess = ObjectKey + 1; IdentifierRole[IdentifierRole["ImportAccess"] = ImportAccess] = "ImportAccess";
+})(IdentifierRole || (exports.IdentifierRole = IdentifierRole = {}));
+
+/**
+ * Extra information on jsxTagStart tokens, used to determine which of the three
+ * jsx functions are called in the automatic transform.
+ */
+var JSXRole; (function (JSXRole) {
+  // The element is self-closing or has a body that resolves to empty. We
+  // shouldn't emit children at all in this case.
+  const NoChildren = 0; JSXRole[JSXRole["NoChildren"] = NoChildren] = "NoChildren";
+  // The element has a single explicit child, which might still be an arbitrary
+  // expression like an array. We should emit that expression as the children.
+  const OneChild = NoChildren + 1; JSXRole[JSXRole["OneChild"] = OneChild] = "OneChild";
+  // The element has at least two explicitly-specified children or has spread
+  // children, so child positions are assumed to be "static". We should wrap
+  // these children in an array.
+  const StaticChildren = OneChild + 1; JSXRole[JSXRole["StaticChildren"] = StaticChildren] = "StaticChildren";
+  // The element has a prop named "key" after a prop spread, so we should fall
+  // back to the createElement function.
+  const KeyAfterPropSpread = StaticChildren + 1; JSXRole[JSXRole["KeyAfterPropSpread"] = KeyAfterPropSpread] = "KeyAfterPropSpread";
+})(JSXRole || (exports.JSXRole = JSXRole = {}));
+
+ function isDeclaration(token) {
+  const role = token.identifierRole;
+  return (
+    role === IdentifierRole.TopLevelDeclaration ||
+    role === IdentifierRole.FunctionScopedDeclaration ||
+    role === IdentifierRole.BlockScopedDeclaration ||
+    role === IdentifierRole.ObjectShorthandTopLevelDeclaration ||
+    role === IdentifierRole.ObjectShorthandFunctionScopedDeclaration ||
+    role === IdentifierRole.ObjectShorthandBlockScopedDeclaration
+  );
+} exports.isDeclaration = isDeclaration;
+
+ function isNonTopLevelDeclaration(token) {
+  const role = token.identifierRole;
+  return (
+    role === IdentifierRole.FunctionScopedDeclaration ||
+    role === IdentifierRole.BlockScopedDeclaration ||
+    role === IdentifierRole.ObjectShorthandFunctionScopedDeclaration ||
+    role === IdentifierRole.ObjectShorthandBlockScopedDeclaration
+  );
+} exports.isNonTopLevelDeclaration = isNonTopLevelDeclaration;
+
+ function isTopLevelDeclaration(token) {
+  const role = token.identifierRole;
+  return (
+    role === IdentifierRole.TopLevelDeclaration ||
+    role === IdentifierRole.ObjectShorthandTopLevelDeclaration ||
+    role === IdentifierRole.ImportDeclaration
+  );
+} exports.isTopLevelDeclaration = isTopLevelDeclaration;
+
+ function isBlockScopedDeclaration(token) {
+  const role = token.identifierRole;
+  // Treat top-level declarations as block scope since the distinction doesn't matter here.
+  return (
+    role === IdentifierRole.TopLevelDeclaration ||
+    role === IdentifierRole.BlockScopedDeclaration ||
+    role === IdentifierRole.ObjectShorthandTopLevelDeclaration ||
+    role === IdentifierRole.ObjectShorthandBlockScopedDeclaration
+  );
+} exports.isBlockScopedDeclaration = isBlockScopedDeclaration;
+
+ function isFunctionScopedDeclaration(token) {
+  const role = token.identifierRole;
+  return (
+    role === IdentifierRole.FunctionScopedDeclaration ||
+    role === IdentifierRole.ObjectShorthandFunctionScopedDeclaration
+  );
+} exports.isFunctionScopedDeclaration = isFunctionScopedDeclaration;
+
+ function isObjectShorthandDeclaration(token) {
+  return (
+    token.identifierRole === IdentifierRole.ObjectShorthandTopLevelDeclaration ||
+    token.identifierRole === IdentifierRole.ObjectShorthandBlockScopedDeclaration ||
+    token.identifierRole === IdentifierRole.ObjectShorthandFunctionScopedDeclaration
+  );
+} exports.isObjectShorthandDeclaration = isObjectShorthandDeclaration;
+
+// Object type used to represent tokens. Note that normally, tokens
+// simply exist as properties on the parser object. This is only
+// used for the onToken callback and the external tokenizer.
+ class Token {
+  constructor() {
+    this.type = _base.state.type;
+    this.contextualKeyword = _base.state.contextualKeyword;
+    this.start = _base.state.start;
+    this.end = _base.state.end;
+    this.scopeDepth = _base.state.scopeDepth;
+    this.isType = _base.state.isType;
+    this.identifierRole = null;
+    this.jsxRole = null;
+    this.shadowsGlobal = false;
+    this.isAsyncOperation = false;
+    this.contextId = null;
+    this.rhsEndIndex = null;
+    this.isExpression = false;
+    this.numNullishCoalesceStarts = 0;
+    this.numNullishCoalesceEnds = 0;
+    this.isOptionalChainStart = false;
+    this.isOptionalChainEnd = false;
+    this.subscriptStartIndex = null;
+    this.nullishStartIndex = null;
+  }
+
+  
+  
+  
+  
+  
+  
+  
+  
+  // Initially false for all tokens, then may be computed in a follow-up step that does scope
+  // analysis.
+  
+  // Initially false for all tokens, but may be set during transform to mark it as containing an
+  // await operation.
+  
+  
+  // For assignments, the index of the RHS. For export tokens, the end of the export.
+  
+  // For class tokens, records if the class is a class expression or a class statement.
+  
+  // Number of times to insert a `nullishCoalesce(` snippet before this token.
+  
+  // Number of times to insert a `)` snippet after this token.
+  
+  // If true, insert an `optionalChain([` snippet before this token.
+  
+  // If true, insert a `])` snippet after this token.
+  
+  // Tag for `.`, `?.`, `[`, `?.[`, `(`, and `?.(` to denote the "root" token for this
+  // subscript chain. This can be used to determine if this chain is an optional chain.
+  
+  // Tag for `??` operators to denote the root token for this nullish coalescing call.
+  
+} exports.Token = Token;
+
+// ## Tokenizer
+
+// Move to the next token
+ function next() {
+  _base.state.tokens.push(new Token());
+  nextToken();
+} exports.next = next;
+
+// Call instead of next when inside a template, since that needs to be handled differently.
+ function nextTemplateToken() {
+  _base.state.tokens.push(new Token());
+  _base.state.start = _base.state.pos;
+  readTmplToken();
+} exports.nextTemplateToken = nextTemplateToken;
+
+// The tokenizer never parses regexes by default. Instead, the parser is responsible for
+// instructing it to parse a regex when we see a slash at the start of an expression.
+ function retokenizeSlashAsRegex() {
+  if (_base.state.type === _types.TokenType.assign) {
+    --_base.state.pos;
+  }
+  readRegexp();
+} exports.retokenizeSlashAsRegex = retokenizeSlashAsRegex;
+
+ function pushTypeContext(existingTokensInType) {
+  for (let i = _base.state.tokens.length - existingTokensInType; i < _base.state.tokens.length; i++) {
+    _base.state.tokens[i].isType = true;
+  }
+  const oldIsType = _base.state.isType;
+  _base.state.isType = true;
+  return oldIsType;
+} exports.pushTypeContext = pushTypeContext;
+
+ function popTypeContext(oldIsType) {
+  _base.state.isType = oldIsType;
+} exports.popTypeContext = popTypeContext;
+
+ function eat(type) {
+  if (match(type)) {
+    next();
+    return true;
+  } else {
+    return false;
+  }
+} exports.eat = eat;
+
+ function eatTypeToken(tokenType) {
+  const oldIsType = _base.state.isType;
+  _base.state.isType = true;
+  eat(tokenType);
+  _base.state.isType = oldIsType;
+} exports.eatTypeToken = eatTypeToken;
+
+ function match(type) {
+  return _base.state.type === type;
+} exports.match = match;
+
+ function lookaheadType() {
+  const snapshot = _base.state.snapshot();
+  next();
+  const type = _base.state.type;
+  _base.state.restoreFromSnapshot(snapshot);
+  return type;
+} exports.lookaheadType = lookaheadType;
+
+ class TypeAndKeyword {
+  
+  
+  constructor(type, contextualKeyword) {
+    this.type = type;
+    this.contextualKeyword = contextualKeyword;
+  }
+} exports.TypeAndKeyword = TypeAndKeyword;
+
+ function lookaheadTypeAndKeyword() {
+  const snapshot = _base.state.snapshot();
+  next();
+  const type = _base.state.type;
+  const contextualKeyword = _base.state.contextualKeyword;
+  _base.state.restoreFromSnapshot(snapshot);
+  return new TypeAndKeyword(type, contextualKeyword);
+} exports.lookaheadTypeAndKeyword = lookaheadTypeAndKeyword;
+
+ function nextTokenStart() {
+  return nextTokenStartSince(_base.state.pos);
+} exports.nextTokenStart = nextTokenStart;
+
+ function nextTokenStartSince(pos) {
+  _whitespace.skipWhiteSpace.lastIndex = pos;
+  const skip = _whitespace.skipWhiteSpace.exec(_base.input);
+  return pos + skip[0].length;
+} exports.nextTokenStartSince = nextTokenStartSince;
+
+ function lookaheadCharCode() {
+  return _base.input.charCodeAt(nextTokenStart());
+} exports.lookaheadCharCode = lookaheadCharCode;
+
+// Read a single token, updating the parser object's token-related
+// properties.
+ function nextToken() {
+  skipSpace();
+  _base.state.start = _base.state.pos;
+  if (_base.state.pos >= _base.input.length) {
+    const tokens = _base.state.tokens;
+    // We normally run past the end a bit, but if we're way past the end, avoid an infinite loop.
+    // Also check the token positions rather than the types since sometimes we rewrite the token
+    // type to something else.
+    if (
+      tokens.length >= 2 &&
+      tokens[tokens.length - 1].start >= _base.input.length &&
+      tokens[tokens.length - 2].start >= _base.input.length
+    ) {
+      _util.unexpected.call(void 0, "Unexpectedly reached the end of input.");
+    }
+    finishToken(_types.TokenType.eof);
+    return;
+  }
+  readToken(_base.input.charCodeAt(_base.state.pos));
+} exports.nextToken = nextToken;
+
+function readToken(code) {
+  // Identifier or keyword. '\uXXXX' sequences are allowed in
+  // identifiers, so '\' also dispatches to that.
+  if (
+    _identifier.IS_IDENTIFIER_START[code] ||
+    code === _charcodes.charCodes.backslash ||
+    (code === _charcodes.charCodes.atSign && _base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.atSign)
+  ) {
+    _readWord2.default.call(void 0, );
+  } else {
+    getTokenFromCode(code);
+  }
+}
+
+function skipBlockComment() {
+  while (
+    _base.input.charCodeAt(_base.state.pos) !== _charcodes.charCodes.asterisk ||
+    _base.input.charCodeAt(_base.state.pos + 1) !== _charcodes.charCodes.slash
+  ) {
+    _base.state.pos++;
+    if (_base.state.pos > _base.input.length) {
+      _util.unexpected.call(void 0, "Unterminated comment", _base.state.pos - 2);
+      return;
+    }
+  }
+  _base.state.pos += 2;
+}
+
+ function skipLineComment(startSkip) {
+  let ch = _base.input.charCodeAt((_base.state.pos += startSkip));
+  if (_base.state.pos < _base.input.length) {
+    while (
+      ch !== _charcodes.charCodes.lineFeed &&
+      ch !== _charcodes.charCodes.carriageReturn &&
+      ch !== _charcodes.charCodes.lineSeparator &&
+      ch !== _charcodes.charCodes.paragraphSeparator &&
+      ++_base.state.pos < _base.input.length
+    ) {
+      ch = _base.input.charCodeAt(_base.state.pos);
+    }
+  }
+} exports.skipLineComment = skipLineComment;
+
+// Called at the start of the parse and after every token. Skips
+// whitespace and comments.
+ function skipSpace() {
+  while (_base.state.pos < _base.input.length) {
+    const ch = _base.input.charCodeAt(_base.state.pos);
+    switch (ch) {
+      case _charcodes.charCodes.carriageReturn:
+        if (_base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.lineFeed) {
+          ++_base.state.pos;
+        }
+
+      case _charcodes.charCodes.lineFeed:
+      case _charcodes.charCodes.lineSeparator:
+      case _charcodes.charCodes.paragraphSeparator:
+        ++_base.state.pos;
+        break;
+
+      case _charcodes.charCodes.slash:
+        switch (_base.input.charCodeAt(_base.state.pos + 1)) {
+          case _charcodes.charCodes.asterisk:
+            _base.state.pos += 2;
+            skipBlockComment();
+            break;
+
+          case _charcodes.charCodes.slash:
+            skipLineComment(2);
+            break;
+
+          default:
+            return;
+        }
+        break;
+
+      default:
+        if (_whitespace.IS_WHITESPACE[ch]) {
+          ++_base.state.pos;
+        } else {
+          return;
+        }
+    }
+  }
+} exports.skipSpace = skipSpace;
+
+// Called at the end of every token. Sets various fields, and skips the space after the token, so
+// that the next one's `start` will point at the right position.
+ function finishToken(
+  type,
+  contextualKeyword = _keywords.ContextualKeyword.NONE,
+) {
+  _base.state.end = _base.state.pos;
+  _base.state.type = type;
+  _base.state.contextualKeyword = contextualKeyword;
+} exports.finishToken = finishToken;
+
+// ### Token reading
+
+// This is the function that is called to fetch the next token. It
+// is somewhat obscure, because it works in character codes rather
+// than characters, and because operator parsing has been inlined
+// into it.
+//
+// All in the name of speed.
+function readToken_dot() {
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+  if (nextChar >= _charcodes.charCodes.digit0 && nextChar <= _charcodes.charCodes.digit9) {
+    readNumber(true);
+    return;
+  }
+
+  if (nextChar === _charcodes.charCodes.dot && _base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.dot) {
+    _base.state.pos += 3;
+    finishToken(_types.TokenType.ellipsis);
+  } else {
+    ++_base.state.pos;
+    finishToken(_types.TokenType.dot);
+  }
+}
+
+function readToken_slash() {
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+  if (nextChar === _charcodes.charCodes.equalsTo) {
+    finishOp(_types.TokenType.assign, 2);
+  } else {
+    finishOp(_types.TokenType.slash, 1);
+  }
+}
+
+function readToken_mult_modulo(code) {
+  // '%*'
+  let tokenType = code === _charcodes.charCodes.asterisk ? _types.TokenType.star : _types.TokenType.modulo;
+  let width = 1;
+  let nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+
+  // Exponentiation operator **
+  if (code === _charcodes.charCodes.asterisk && nextChar === _charcodes.charCodes.asterisk) {
+    width++;
+    nextChar = _base.input.charCodeAt(_base.state.pos + 2);
+    tokenType = _types.TokenType.exponent;
+  }
+
+  // Match *= or %=, disallowing *=> which can be valid in flow.
+  if (
+    nextChar === _charcodes.charCodes.equalsTo &&
+    _base.input.charCodeAt(_base.state.pos + 2) !== _charcodes.charCodes.greaterThan
+  ) {
+    width++;
+    tokenType = _types.TokenType.assign;
+  }
+
+  finishOp(tokenType, width);
+}
+
+function readToken_pipe_amp(code) {
+  // '|&'
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+
+  if (nextChar === code) {
+    if (_base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.equalsTo) {
+      // ||= or &&=
+      finishOp(_types.TokenType.assign, 3);
+    } else {
+      // || or &&
+      finishOp(code === _charcodes.charCodes.verticalBar ? _types.TokenType.logicalOR : _types.TokenType.logicalAND, 2);
+    }
+    return;
+  }
+
+  if (code === _charcodes.charCodes.verticalBar) {
+    // '|>'
+    if (nextChar === _charcodes.charCodes.greaterThan) {
+      finishOp(_types.TokenType.pipeline, 2);
+      return;
+    } else if (nextChar === _charcodes.charCodes.rightCurlyBrace && _base.isFlowEnabled) {
+      // '|}'
+      finishOp(_types.TokenType.braceBarR, 2);
+      return;
+    }
+  }
+
+  if (nextChar === _charcodes.charCodes.equalsTo) {
+    finishOp(_types.TokenType.assign, 2);
+    return;
+  }
+
+  finishOp(code === _charcodes.charCodes.verticalBar ? _types.TokenType.bitwiseOR : _types.TokenType.bitwiseAND, 1);
+}
+
+function readToken_caret() {
+  // '^'
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+  if (nextChar === _charcodes.charCodes.equalsTo) {
+    finishOp(_types.TokenType.assign, 2);
+  } else {
+    finishOp(_types.TokenType.bitwiseXOR, 1);
+  }
+}
+
+function readToken_plus_min(code) {
+  // '+-'
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+
+  if (nextChar === code) {
+    // Tentatively call this a prefix operator, but it might be changed to postfix later.
+    finishOp(_types.TokenType.preIncDec, 2);
+    return;
+  }
+
+  if (nextChar === _charcodes.charCodes.equalsTo) {
+    finishOp(_types.TokenType.assign, 2);
+  } else if (code === _charcodes.charCodes.plusSign) {
+    finishOp(_types.TokenType.plus, 1);
+  } else {
+    finishOp(_types.TokenType.minus, 1);
+  }
+}
+
+function readToken_lt() {
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+
+  if (nextChar === _charcodes.charCodes.lessThan) {
+    if (_base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.equalsTo) {
+      finishOp(_types.TokenType.assign, 3);
+      return;
+    }
+    // We see <<, but need to be really careful about whether to treat it as a
+    // true left-shift or as two < tokens.
+    if (_base.state.isType) {
+      // Within a type, << might come up in a snippet like `Array<<T>() => void>`,
+      // so treat it as two < tokens. Importantly, this should only override <<
+      // rather than other tokens like <= . If we treated <= as < in a type
+      // context, then the snippet `a as T <= 1` would incorrectly start parsing
+      // a type argument on T. We don't need to worry about `a as T << 1`
+      // because TypeScript disallows that syntax.
+      finishOp(_types.TokenType.lessThan, 1);
+    } else {
+      // Outside a type, this might be a true left-shift operator, or it might
+      // still be two open-type-arg tokens, such as in `f<<T>() => void>()`. We
+      // look at the token while considering the `f`, so we don't yet know that
+      // we're in a type context. In this case, we initially tokenize as a
+      // left-shift and correct after-the-fact as necessary in
+      // tsParseTypeArgumentsWithPossibleBitshift .
+      finishOp(_types.TokenType.bitShiftL, 2);
+    }
+    return;
+  }
+
+  if (nextChar === _charcodes.charCodes.equalsTo) {
+    // <=
+    finishOp(_types.TokenType.relationalOrEqual, 2);
+  } else {
+    finishOp(_types.TokenType.lessThan, 1);
+  }
+}
+
+function readToken_gt() {
+  if (_base.state.isType) {
+    // Avoid right-shift for things like `Array<Array<string>>` and
+    // greater-than-or-equal for things like `const a: Array<number>=[];`.
+    finishOp(_types.TokenType.greaterThan, 1);
+    return;
+  }
+
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+
+  if (nextChar === _charcodes.charCodes.greaterThan) {
+    const size = _base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.greaterThan ? 3 : 2;
+    if (_base.input.charCodeAt(_base.state.pos + size) === _charcodes.charCodes.equalsTo) {
+      finishOp(_types.TokenType.assign, size + 1);
+      return;
+    }
+    finishOp(_types.TokenType.bitShiftR, size);
+    return;
+  }
+
+  if (nextChar === _charcodes.charCodes.equalsTo) {
+    // >=
+    finishOp(_types.TokenType.relationalOrEqual, 2);
+  } else {
+    finishOp(_types.TokenType.greaterThan, 1);
+  }
+}
+
+/**
+ * Reinterpret a possible > token when transitioning from a type to a non-type
+ * context.
+ *
+ * This comes up in two situations where >= needs to be treated as one token:
+ * - After an `as` expression, like in the code `a as T >= 1`.
+ * - In a type argument in an expression context, e.g. `f(a < b, c >= d)`, we
+ *   need to see the token as >= so that we get an error and backtrack to
+ *   normal expression parsing.
+ *
+ * Other situations require >= to be seen as two tokens, e.g.
+ * `const x: Array<T>=[];`, so it's important to treat > as its own token in
+ * typical type parsing situations.
+ */
+ function rescan_gt() {
+  if (_base.state.type === _types.TokenType.greaterThan) {
+    _base.state.pos -= 1;
+    readToken_gt();
+  }
+} exports.rescan_gt = rescan_gt;
+
+function readToken_eq_excl(code) {
+  // '=!'
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+  if (nextChar === _charcodes.charCodes.equalsTo) {
+    finishOp(_types.TokenType.equality, _base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.equalsTo ? 3 : 2);
+    return;
+  }
+  if (code === _charcodes.charCodes.equalsTo && nextChar === _charcodes.charCodes.greaterThan) {
+    // '=>'
+    _base.state.pos += 2;
+    finishToken(_types.TokenType.arrow);
+    return;
+  }
+  finishOp(code === _charcodes.charCodes.equalsTo ? _types.TokenType.eq : _types.TokenType.bang, 1);
+}
+
+function readToken_question() {
+  // '?'
+  const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+  const nextChar2 = _base.input.charCodeAt(_base.state.pos + 2);
+  if (
+    nextChar === _charcodes.charCodes.questionMark &&
+    // In Flow (but not TypeScript), ??string is a valid type that should be
+    // tokenized as two individual ? tokens.
+    !(_base.isFlowEnabled && _base.state.isType)
+  ) {
+    if (nextChar2 === _charcodes.charCodes.equalsTo) {
+      // '??='
+      finishOp(_types.TokenType.assign, 3);
+    } else {
+      // '??'
+      finishOp(_types.TokenType.nullishCoalescing, 2);
+    }
+  } else if (
+    nextChar === _charcodes.charCodes.dot &&
+    !(nextChar2 >= _charcodes.charCodes.digit0 && nextChar2 <= _charcodes.charCodes.digit9)
+  ) {
+    // '.' not followed by a number
+    _base.state.pos += 2;
+    finishToken(_types.TokenType.questionDot);
+  } else {
+    ++_base.state.pos;
+    finishToken(_types.TokenType.question);
+  }
+}
+
+ function getTokenFromCode(code) {
+  switch (code) {
+    case _charcodes.charCodes.numberSign:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.hash);
+      return;
+
+    // The interpretation of a dot depends on whether it is followed
+    // by a digit or another two dots.
+
+    case _charcodes.charCodes.dot:
+      readToken_dot();
+      return;
+
+    // Punctuation tokens.
+    case _charcodes.charCodes.leftParenthesis:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.parenL);
+      return;
+    case _charcodes.charCodes.rightParenthesis:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.parenR);
+      return;
+    case _charcodes.charCodes.semicolon:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.semi);
+      return;
+    case _charcodes.charCodes.comma:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.comma);
+      return;
+    case _charcodes.charCodes.leftSquareBracket:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.bracketL);
+      return;
+    case _charcodes.charCodes.rightSquareBracket:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.bracketR);
+      return;
+
+    case _charcodes.charCodes.leftCurlyBrace:
+      if (_base.isFlowEnabled && _base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.verticalBar) {
+        finishOp(_types.TokenType.braceBarL, 2);
+      } else {
+        ++_base.state.pos;
+        finishToken(_types.TokenType.braceL);
+      }
+      return;
+
+    case _charcodes.charCodes.rightCurlyBrace:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.braceR);
+      return;
+
+    case _charcodes.charCodes.colon:
+      if (_base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.colon) {
+        finishOp(_types.TokenType.doubleColon, 2);
+      } else {
+        ++_base.state.pos;
+        finishToken(_types.TokenType.colon);
+      }
+      return;
+
+    case _charcodes.charCodes.questionMark:
+      readToken_question();
+      return;
+    case _charcodes.charCodes.atSign:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.at);
+      return;
+
+    case _charcodes.charCodes.graveAccent:
+      ++_base.state.pos;
+      finishToken(_types.TokenType.backQuote);
+      return;
+
+    case _charcodes.charCodes.digit0: {
+      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
+      // '0x', '0X', '0o', '0O', '0b', '0B'
+      if (
+        nextChar === _charcodes.charCodes.lowercaseX ||
+        nextChar === _charcodes.charCodes.uppercaseX ||
+        nextChar === _charcodes.charCodes.lowercaseO ||
+        nextChar === _charcodes.charCodes.uppercaseO ||
+        nextChar === _charcodes.charCodes.lowercaseB ||
+        nextChar === _charcodes.charCodes.uppercaseB
+      ) {
+        readRadixNumber();
+        return;
+      }
+    }
+    // Anything else beginning with a digit is an integer, octal
+    // number, or float.
+    case _charcodes.charCodes.digit1:
+    case _charcodes.charCodes.digit2:
+    case _charcodes.charCodes.digit3:
+    case _charcodes.charCodes.digit4:
+    case _charcodes.charCodes.digit5:
+    case _charcodes.charCodes.digit6:
+    case _charcodes.charCodes.digit7:
+    case _charcodes.charCodes.digit8:
+    case _charcodes.charCodes.digit9:
+      readNumber(false);
+      return;
+
+    // Quotes produce strings.
+    case _charcodes.charCodes.quotationMark:
+    case _charcodes.charCodes.apostrophe:
+      readString(code);
+      return;
+
+    // Operators are parsed inline in tiny state machines. '=' (charCodes.equalsTo) is
+    // often referred to. `finishOp` simply skips the amount of
+    // characters it is given as second argument, and returns a token
+    // of the type given by its first argument.
+
+    case _charcodes.charCodes.slash:
+      readToken_slash();
+      return;
+
+    case _charcodes.charCodes.percentSign:
+    case _charcodes.charCodes.asterisk:
+      readToken_mult_modulo(code);
+      return;
+
+    case _charcodes.charCodes.verticalBar:
+    case _charcodes.charCodes.ampersand:
+      readToken_pipe_amp(code);
+      return;
+
+    case _charcodes.charCodes.caret:
+      readToken_caret();
+      return;
+
+    case _charcodes.charCodes.plusSign:
+    case _charcodes.charCodes.dash:
+      readToken_plus_min(code);
+      return;
+
+    case _charcodes.charCodes.lessThan:
+      readToken_lt();
+      return;
+
+    case _charcodes.charCodes.greaterThan:
+      readToken_gt();
+      return;
+
+    case _charcodes.charCodes.equalsTo:
+    case _charcodes.charCodes.exclamationMark:
+      readToken_eq_excl(code);
+      return;
+
+    case _charcodes.charCodes.tilde:
+      finishOp(_types.TokenType.tilde, 1);
+      return;
+
+    default:
+      break;
+  }
+
+  _util.unexpected.call(void 0, `Unexpected character '${String.fromCharCode(code)}'`, _base.state.pos);
+} exports.getTokenFromCode = getTokenFromCode;
+
+function finishOp(type, size) {
+  _base.state.pos += size;
+  finishToken(type);
+}
+
+function readRegexp() {
+  const start = _base.state.pos;
+  let escaped = false;
+  let inClass = false;
+  for (;;) {
+    if (_base.state.pos >= _base.input.length) {
+      _util.unexpected.call(void 0, "Unterminated regular expression", start);
+      return;
+    }
+    const code = _base.input.charCodeAt(_base.state.pos);
+    if (escaped) {
+      escaped = false;
+    } else {
+      if (code === _charcodes.charCodes.leftSquareBracket) {
+        inClass = true;
+      } else if (code === _charcodes.charCodes.rightSquareBracket && inClass) {
+        inClass = false;
+      } else if (code === _charcodes.charCodes.slash && !inClass) {
+        break;
+      }
+      escaped = code === _charcodes.charCodes.backslash;
+    }
+    ++_base.state.pos;
+  }
+  ++_base.state.pos;
+  // Need to use `skipWord` because '\uXXXX' sequences are allowed here (don't ask).
+  skipWord();
+
+  finishToken(_types.TokenType.regexp);
+}
+
+/**
+ * Read a decimal integer. Note that this can't be unified with the similar code
+ * in readRadixNumber (which also handles hex digits) because "e" needs to be
+ * the end of the integer so that we can properly handle scientific notation.
+ */
+function readInt() {
+  while (true) {
+    const code = _base.input.charCodeAt(_base.state.pos);
+    if ((code >= _charcodes.charCodes.digit0 && code <= _charcodes.charCodes.digit9) || code === _charcodes.charCodes.underscore) {
+      _base.state.pos++;
+    } else {
+      break;
+    }
+  }
+}
+
+function readRadixNumber() {
+  _base.state.pos += 2; // 0x
+
+  // Walk to the end of the number, allowing hex digits.
+  while (true) {
+    const code = _base.input.charCodeAt(_base.state.pos);
+    if (
+      (code >= _charcodes.charCodes.digit0 && code <= _charcodes.charCodes.digit9) ||
+      (code >= _charcodes.charCodes.lowercaseA && code <= _charcodes.charCodes.lowercaseF) ||
+      (code >= _charcodes.charCodes.uppercaseA && code <= _charcodes.charCodes.uppercaseF) ||
+      code === _charcodes.charCodes.underscore
+    ) {
+      _base.state.pos++;
+    } else {
+      break;
+    }
+  }
+
+  const nextChar = _base.input.charCodeAt(_base.state.pos);
+  if (nextChar === _charcodes.charCodes.lowercaseN) {
+    ++_base.state.pos;
+    finishToken(_types.TokenType.bigint);
+  } else {
+    finishToken(_types.TokenType.num);
+  }
+}
+
+// Read an integer, octal integer, or floating-point number.
+function readNumber(startsWithDot) {
+  let isBigInt = false;
+  let isDecimal = false;
+
+  if (!startsWithDot) {
+    readInt();
+  }
+
+  let nextChar = _base.input.charCodeAt(_base.state.pos);
+  if (nextChar === _charcodes.charCodes.dot) {
+    ++_base.state.pos;
+    readInt();
+    nextChar = _base.input.charCodeAt(_base.state.pos);
+  }
+
+  if (nextChar === _charcodes.charCodes.uppercaseE || nextChar === _charcodes.charCodes.lowercaseE) {
+    nextChar = _base.input.charCodeAt(++_base.state.pos);
+    if (nextChar === _charcodes.charCodes.plusSign || nextChar === _charcodes.charCodes.dash) {
+      ++_base.state.pos;
+    }
+    readInt();
+    nextChar = _base.input.charCodeAt(_base.state.pos);
+  }
+
+  if (nextChar === _charcodes.charCodes.lowercaseN) {
+    ++_base.state.pos;
+    isBigInt = true;
+  } else if (nextChar === _charcodes.charCodes.lowercaseM) {
+    ++_base.state.pos;
+    isDecimal = true;
+  }
+
+  if (isBigInt) {
+    finishToken(_types.TokenType.bigint);
+    return;
+  }
+
+  if (isDecimal) {
+    finishToken(_types.TokenType.decimal);
+    return;
+  }
+
+  finishToken(_types.TokenType.num);
+}
+
+function readString(quote) {
+  _base.state.pos++;
+  for (;;) {
+    if (_base.state.pos >= _base.input.length) {
+      _util.unexpected.call(void 0, "Unterminated string constant");
+      return;
+    }
+    const ch = _base.input.charCodeAt(_base.state.pos);
+    if (ch === _charcodes.charCodes.backslash) {
+      _base.state.pos++;
+    } else if (ch === quote) {
+      break;
+    }
+    _base.state.pos++;
+  }
+  _base.state.pos++;
+  finishToken(_types.TokenType.string);
+}
+
+// Reads template string tokens.
+function readTmplToken() {
+  for (;;) {
+    if (_base.state.pos >= _base.input.length) {
+      _util.unexpected.call(void 0, "Unterminated template");
+      return;
+    }
+    const ch = _base.input.charCodeAt(_base.state.pos);
+    if (
+      ch === _charcodes.charCodes.graveAccent ||
+      (ch === _charcodes.charCodes.dollarSign && _base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.leftCurlyBrace)
+    ) {
+      if (_base.state.pos === _base.state.start && match(_types.TokenType.template)) {
+        if (ch === _charcodes.charCodes.dollarSign) {
+          _base.state.pos += 2;
+          finishToken(_types.TokenType.dollarBraceL);
+          return;
+        } else {
+          ++_base.state.pos;
+          finishToken(_types.TokenType.backQuote);
+          return;
+        }
+      }
+      finishToken(_types.TokenType.template);
+      return;
+    }
+    if (ch === _charcodes.charCodes.backslash) {
+      _base.state.pos++;
+    }
+    _base.state.pos++;
+  }
+}
+
+// Skip to the end of the current word. Note that this is the same as the snippet at the end of
+// readWord, but calling skipWord from readWord seems to slightly hurt performance from some rough
+// measurements.
+ function skipWord() {
+  while (_base.state.pos < _base.input.length) {
+    const ch = _base.input.charCodeAt(_base.state.pos);
+    if (_identifier.IS_IDENTIFIER_CHAR[ch]) {
+      _base.state.pos++;
+    } else if (ch === _charcodes.charCodes.backslash) {
+      // \u
+      _base.state.pos += 2;
+      if (_base.input.charCodeAt(_base.state.pos) === _charcodes.charCodes.leftCurlyBrace) {
+        while (
+          _base.state.pos < _base.input.length &&
+          _base.input.charCodeAt(_base.state.pos) !== _charcodes.charCodes.rightCurlyBrace
+        ) {
+          _base.state.pos++;
+        }
+        _base.state.pos++;
+      }
+    } else {
+      break;
+    }
+  }
+} exports.skipWord = skipWord;
diff --git a/node_modules/sucrase/dist/parser/tokenizer/keywords.js b/node_modules/sucrase/dist/parser/tokenizer/keywords.js
new file mode 100644
index 0000000..e741926
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/tokenizer/keywords.js
@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var ContextualKeyword; (function (ContextualKeyword) {
+  const NONE = 0; ContextualKeyword[ContextualKeyword["NONE"] = NONE] = "NONE";
+  const _abstract = NONE + 1; ContextualKeyword[ContextualKeyword["_abstract"] = _abstract] = "_abstract";
+  const _accessor = _abstract + 1; ContextualKeyword[ContextualKeyword["_accessor"] = _accessor] = "_accessor";
+  const _as = _accessor + 1; ContextualKeyword[ContextualKeyword["_as"] = _as] = "_as";
+  const _assert = _as + 1; ContextualKeyword[ContextualKeyword["_assert"] = _assert] = "_assert";
+  const _asserts = _assert + 1; ContextualKeyword[ContextualKeyword["_asserts"] = _asserts] = "_asserts";
+  const _async = _asserts + 1; ContextualKeyword[ContextualKeyword["_async"] = _async] = "_async";
+  const _await = _async + 1; ContextualKeyword[ContextualKeyword["_await"] = _await] = "_await";
+  const _checks = _await + 1; ContextualKeyword[ContextualKeyword["_checks"] = _checks] = "_checks";
+  const _constructor = _checks + 1; ContextualKeyword[ContextualKeyword["_constructor"] = _constructor] = "_constructor";
+  const _declare = _constructor + 1; ContextualKeyword[ContextualKeyword["_declare"] = _declare] = "_declare";
+  const _enum = _declare + 1; ContextualKeyword[ContextualKeyword["_enum"] = _enum] = "_enum";
+  const _exports = _enum + 1; ContextualKeyword[ContextualKeyword["_exports"] = _exports] = "_exports";
+  const _from = _exports + 1; ContextualKeyword[ContextualKeyword["_from"] = _from] = "_from";
+  const _get = _from + 1; ContextualKeyword[ContextualKeyword["_get"] = _get] = "_get";
+  const _global = _get + 1; ContextualKeyword[ContextualKeyword["_global"] = _global] = "_global";
+  const _implements = _global + 1; ContextualKeyword[ContextualKeyword["_implements"] = _implements] = "_implements";
+  const _infer = _implements + 1; ContextualKeyword[ContextualKeyword["_infer"] = _infer] = "_infer";
+  const _interface = _infer + 1; ContextualKeyword[ContextualKeyword["_interface"] = _interface] = "_interface";
+  const _is = _interface + 1; ContextualKeyword[ContextualKeyword["_is"] = _is] = "_is";
+  const _keyof = _is + 1; ContextualKeyword[ContextualKeyword["_keyof"] = _keyof] = "_keyof";
+  const _mixins = _keyof + 1; ContextualKeyword[ContextualKeyword["_mixins"] = _mixins] = "_mixins";
+  const _module = _mixins + 1; ContextualKeyword[ContextualKeyword["_module"] = _module] = "_module";
+  const _namespace = _module + 1; ContextualKeyword[ContextualKeyword["_namespace"] = _namespace] = "_namespace";
+  const _of = _namespace + 1; ContextualKeyword[ContextualKeyword["_of"] = _of] = "_of";
+  const _opaque = _of + 1; ContextualKeyword[ContextualKeyword["_opaque"] = _opaque] = "_opaque";
+  const _out = _opaque + 1; ContextualKeyword[ContextualKeyword["_out"] = _out] = "_out";
+  const _override = _out + 1; ContextualKeyword[ContextualKeyword["_override"] = _override] = "_override";
+  const _private = _override + 1; ContextualKeyword[ContextualKeyword["_private"] = _private] = "_private";
+  const _protected = _private + 1; ContextualKeyword[ContextualKeyword["_protected"] = _protected] = "_protected";
+  const _proto = _protected + 1; ContextualKeyword[ContextualKeyword["_proto"] = _proto] = "_proto";
+  const _public = _proto + 1; ContextualKeyword[ContextualKeyword["_public"] = _public] = "_public";
+  const _readonly = _public + 1; ContextualKeyword[ContextualKeyword["_readonly"] = _readonly] = "_readonly";
+  const _require = _readonly + 1; ContextualKeyword[ContextualKeyword["_require"] = _require] = "_require";
+  const _satisfies = _require + 1; ContextualKeyword[ContextualKeyword["_satisfies"] = _satisfies] = "_satisfies";
+  const _set = _satisfies + 1; ContextualKeyword[ContextualKeyword["_set"] = _set] = "_set";
+  const _static = _set + 1; ContextualKeyword[ContextualKeyword["_static"] = _static] = "_static";
+  const _symbol = _static + 1; ContextualKeyword[ContextualKeyword["_symbol"] = _symbol] = "_symbol";
+  const _type = _symbol + 1; ContextualKeyword[ContextualKeyword["_type"] = _type] = "_type";
+  const _unique = _type + 1; ContextualKeyword[ContextualKeyword["_unique"] = _unique] = "_unique";
+  const _using = _unique + 1; ContextualKeyword[ContextualKeyword["_using"] = _using] = "_using";
+})(ContextualKeyword || (exports.ContextualKeyword = ContextualKeyword = {}));
diff --git a/node_modules/sucrase/dist/parser/tokenizer/readWord.js b/node_modules/sucrase/dist/parser/tokenizer/readWord.js
new file mode 100644
index 0000000..69ed5c9
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/tokenizer/readWord.js
@@ -0,0 +1,64 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _base = require('../traverser/base');
+var _charcodes = require('../util/charcodes');
+var _identifier = require('../util/identifier');
+var _index = require('./index');
+var _readWordTree = require('./readWordTree');
+var _types = require('./types');
+
+/**
+ * Read an identifier, producing either a name token or matching on one of the existing keywords.
+ * For performance, we pre-generate big decision tree that we traverse. Each node represents a
+ * prefix and has 27 values, where the first value is the token or contextual token, if any (-1 if
+ * not), and the other 26 values are the transitions to other nodes, or -1 to stop.
+ */
+ function readWord() {
+  let treePos = 0;
+  let code = 0;
+  let pos = _base.state.pos;
+  while (pos < _base.input.length) {
+    code = _base.input.charCodeAt(pos);
+    if (code < _charcodes.charCodes.lowercaseA || code > _charcodes.charCodes.lowercaseZ) {
+      break;
+    }
+    const next = _readWordTree.READ_WORD_TREE[treePos + (code - _charcodes.charCodes.lowercaseA) + 1];
+    if (next === -1) {
+      break;
+    } else {
+      treePos = next;
+      pos++;
+    }
+  }
+
+  const keywordValue = _readWordTree.READ_WORD_TREE[treePos];
+  if (keywordValue > -1 && !_identifier.IS_IDENTIFIER_CHAR[code]) {
+    _base.state.pos = pos;
+    if (keywordValue & 1) {
+      _index.finishToken.call(void 0, keywordValue >>> 1);
+    } else {
+      _index.finishToken.call(void 0, _types.TokenType.name, keywordValue >>> 1);
+    }
+    return;
+  }
+
+  while (pos < _base.input.length) {
+    const ch = _base.input.charCodeAt(pos);
+    if (_identifier.IS_IDENTIFIER_CHAR[ch]) {
+      pos++;
+    } else if (ch === _charcodes.charCodes.backslash) {
+      // \u
+      pos += 2;
+      if (_base.input.charCodeAt(pos) === _charcodes.charCodes.leftCurlyBrace) {
+        while (pos < _base.input.length && _base.input.charCodeAt(pos) !== _charcodes.charCodes.rightCurlyBrace) {
+          pos++;
+        }
+        pos++;
+      }
+    } else if (ch === _charcodes.charCodes.atSign && _base.input.charCodeAt(pos + 1) === _charcodes.charCodes.atSign) {
+      pos += 2;
+    } else {
+      break;
+    }
+  }
+  _base.state.pos = pos;
+  _index.finishToken.call(void 0, _types.TokenType.name);
+} exports.default = readWord;
diff --git a/node_modules/sucrase/dist/parser/tokenizer/readWordTree.js b/node_modules/sucrase/dist/parser/tokenizer/readWordTree.js
new file mode 100644
index 0000000..fcc7733
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/tokenizer/readWordTree.js
@@ -0,0 +1,671 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// Generated file, do not edit! Run "yarn generate" to re-generate this file.
+var _keywords = require('./keywords');
+var _types = require('./types');
+
+// prettier-ignore
+ const READ_WORD_TREE = new Int32Array([
+  // ""
+  -1, 27, 783, 918, 1755, 2376, 2862, 3483, -1, 3699, -1, 4617, 4752, 4833, 5130, 5508, 5940, -1, 6480, 6939, 7749, 8181, 8451, 8613, -1, 8829, -1,
+  // "a"
+  -1, -1, 54, 243, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 432, -1, -1, -1, 675, -1, -1, -1,
+  // "ab"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, -1, -1,
+  // "abs"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 108, -1, -1, -1, -1, -1, -1,
+  // "abst"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 135, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "abstr"
+  -1, 162, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "abstra"
+  -1, -1, -1, 189, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "abstrac"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 216, -1, -1, -1, -1, -1, -1,
+  // "abstract"
+  _keywords.ContextualKeyword._abstract << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ac"
+  -1, -1, -1, 270, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "acc"
+  -1, -1, -1, -1, -1, 297, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "acce"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 324, -1, -1, -1, -1, -1, -1, -1,
+  // "acces"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 351, -1, -1, -1, -1, -1, -1, -1,
+  // "access"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 378, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "accesso"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 405, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "accessor"
+  _keywords.ContextualKeyword._accessor << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "as"
+  _keywords.ContextualKeyword._as << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 459, -1, -1, -1, -1, -1, 594, -1,
+  // "ass"
+  -1, -1, -1, -1, -1, 486, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "asse"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 513, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "asser"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 540, -1, -1, -1, -1, -1, -1,
+  // "assert"
+  _keywords.ContextualKeyword._assert << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 567, -1, -1, -1, -1, -1, -1, -1,
+  // "asserts"
+  _keywords.ContextualKeyword._asserts << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "asy"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 621, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "asyn"
+  -1, -1, -1, 648, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "async"
+  _keywords.ContextualKeyword._async << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "aw"
+  -1, 702, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "awa"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 729, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "awai"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 756, -1, -1, -1, -1, -1, -1,
+  // "await"
+  _keywords.ContextualKeyword._await << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "b"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 810, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "br"
+  -1, -1, -1, -1, -1, 837, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "bre"
+  -1, 864, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "brea"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 891, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "break"
+  (_types.TokenType._break << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "c"
+  -1, 945, -1, -1, -1, -1, -1, -1, 1107, -1, -1, -1, 1242, -1, -1, 1350, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ca"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 972, 1026, -1, -1, -1, -1, -1, -1,
+  // "cas"
+  -1, -1, -1, -1, -1, 999, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "case"
+  (_types.TokenType._case << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "cat"
+  -1, -1, -1, 1053, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "catc"
+  -1, -1, -1, -1, -1, -1, -1, -1, 1080, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "catch"
+  (_types.TokenType._catch << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ch"
+  -1, -1, -1, -1, -1, 1134, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "che"
+  -1, -1, -1, 1161, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "chec"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1188, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "check"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1215, -1, -1, -1, -1, -1, -1, -1,
+  // "checks"
+  _keywords.ContextualKeyword._checks << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "cl"
+  -1, 1269, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "cla"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1296, -1, -1, -1, -1, -1, -1, -1,
+  // "clas"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1323, -1, -1, -1, -1, -1, -1, -1,
+  // "class"
+  (_types.TokenType._class << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "co"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1377, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "con"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1404, 1620, -1, -1, -1, -1, -1, -1,
+  // "cons"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1431, -1, -1, -1, -1, -1, -1,
+  // "const"
+  (_types.TokenType._const << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1458, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "constr"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1485, -1, -1, -1, -1, -1,
+  // "constru"
+  -1, -1, -1, 1512, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "construc"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1539, -1, -1, -1, -1, -1, -1,
+  // "construct"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1566, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "constructo"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1593, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "constructor"
+  _keywords.ContextualKeyword._constructor << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "cont"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 1647, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "conti"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1674, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "contin"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1701, -1, -1, -1, -1, -1,
+  // "continu"
+  -1, -1, -1, -1, -1, 1728, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "continue"
+  (_types.TokenType._continue << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "d"
+  -1, -1, -1, -1, -1, 1782, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "de"
+  -1, -1, 1809, 1971, -1, -1, 2106, -1, -1, -1, -1, -1, 2241, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "deb"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1836, -1, -1, -1, -1, -1,
+  // "debu"
+  -1, -1, -1, -1, -1, -1, -1, 1863, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "debug"
+  -1, -1, -1, -1, -1, -1, -1, 1890, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "debugg"
+  -1, -1, -1, -1, -1, 1917, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "debugge"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1944, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "debugger"
+  (_types.TokenType._debugger << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "dec"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1998, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "decl"
+  -1, 2025, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "decla"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2052, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "declar"
+  -1, -1, -1, -1, -1, 2079, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "declare"
+  _keywords.ContextualKeyword._declare << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "def"
+  -1, 2133, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "defa"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2160, -1, -1, -1, -1, -1,
+  // "defau"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2187, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "defaul"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2214, -1, -1, -1, -1, -1, -1,
+  // "default"
+  (_types.TokenType._default << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "del"
+  -1, -1, -1, -1, -1, 2268, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "dele"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2295, -1, -1, -1, -1, -1, -1,
+  // "delet"
+  -1, -1, -1, -1, -1, 2322, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "delete"
+  (_types.TokenType._delete << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "do"
+  (_types.TokenType._do << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "e"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2403, -1, 2484, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2565, -1, -1,
+  // "el"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2430, -1, -1, -1, -1, -1, -1, -1,
+  // "els"
+  -1, -1, -1, -1, -1, 2457, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "else"
+  (_types.TokenType._else << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "en"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2511, -1, -1, -1, -1, -1,
+  // "enu"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2538, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "enum"
+  _keywords.ContextualKeyword._enum << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ex"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2592, -1, -1, -1, 2727, -1, -1, -1, -1, -1, -1,
+  // "exp"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2619, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "expo"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2646, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "expor"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2673, -1, -1, -1, -1, -1, -1,
+  // "export"
+  (_types.TokenType._export << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2700, -1, -1, -1, -1, -1, -1, -1,
+  // "exports"
+  _keywords.ContextualKeyword._exports << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ext"
+  -1, -1, -1, -1, -1, 2754, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "exte"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2781, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "exten"
+  -1, -1, -1, -1, 2808, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "extend"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2835, -1, -1, -1, -1, -1, -1, -1,
+  // "extends"
+  (_types.TokenType._extends << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "f"
+  -1, 2889, -1, -1, -1, -1, -1, -1, -1, 2997, -1, -1, -1, -1, -1, 3159, -1, -1, 3213, -1, -1, 3294, -1, -1, -1, -1, -1,
+  // "fa"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2916, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fal"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2943, -1, -1, -1, -1, -1, -1, -1,
+  // "fals"
+  -1, -1, -1, -1, -1, 2970, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "false"
+  (_types.TokenType._false << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3024, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fin"
+  -1, 3051, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fina"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3078, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "final"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3105, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "finall"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3132, -1,
+  // "finally"
+  (_types.TokenType._finally << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fo"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3186, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "for"
+  (_types.TokenType._for << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fr"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fro"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3267, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "from"
+  _keywords.ContextualKeyword._from << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fu"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3321, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "fun"
+  -1, -1, -1, 3348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "func"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3375, -1, -1, -1, -1, -1, -1,
+  // "funct"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3402, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "functi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3429, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "functio"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3456, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "function"
+  (_types.TokenType._function << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "g"
+  -1, -1, -1, -1, -1, 3510, -1, -1, -1, -1, -1, -1, 3564, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ge"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3537, -1, -1, -1, -1, -1, -1,
+  // "get"
+  _keywords.ContextualKeyword._get << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "gl"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3591, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "glo"
+  -1, -1, 3618, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "glob"
+  -1, 3645, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "globa"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3672, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "global"
+  _keywords.ContextualKeyword._global << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "i"
+  -1, -1, -1, -1, -1, -1, 3726, -1, -1, -1, -1, -1, -1, 3753, 4077, -1, -1, -1, -1, 4590, -1, -1, -1, -1, -1, -1, -1,
+  // "if"
+  (_types.TokenType._if << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "im"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3780, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "imp"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3807, -1, -1, 3996, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "impl"
+  -1, -1, -1, -1, -1, 3834, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "imple"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3861, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "implem"
+  -1, -1, -1, -1, -1, 3888, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "impleme"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3915, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "implemen"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3942, -1, -1, -1, -1, -1, -1,
+  // "implement"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3969, -1, -1, -1, -1, -1, -1, -1,
+  // "implements"
+  _keywords.ContextualKeyword._implements << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "impo"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4023, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "impor"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4050, -1, -1, -1, -1, -1, -1,
+  // "import"
+  (_types.TokenType._import << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "in"
+  (_types.TokenType._in << 1) + 1, -1, -1, -1, -1, -1, 4104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4185, 4401, -1, -1, -1, -1, -1, -1,
+  // "inf"
+  -1, -1, -1, -1, -1, 4131, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "infe"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4158, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "infer"
+  _keywords.ContextualKeyword._infer << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ins"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4212, -1, -1, -1, -1, -1, -1,
+  // "inst"
+  -1, 4239, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "insta"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4266, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "instan"
+  -1, -1, -1, 4293, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "instanc"
+  -1, -1, -1, -1, -1, 4320, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "instance"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4347, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "instanceo"
+  -1, -1, -1, -1, -1, -1, 4374, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "instanceof"
+  (_types.TokenType._instanceof << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "int"
+  -1, -1, -1, -1, -1, 4428, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "inte"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4455, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "inter"
+  -1, -1, -1, -1, -1, -1, 4482, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "interf"
+  -1, 4509, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "interfa"
+  -1, -1, -1, 4536, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "interfac"
+  -1, -1, -1, -1, -1, 4563, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "interface"
+  _keywords.ContextualKeyword._interface << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "is"
+  _keywords.ContextualKeyword._is << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "k"
+  -1, -1, -1, -1, -1, 4644, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ke"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4671, -1,
+  // "key"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4698, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "keyo"
+  -1, -1, -1, -1, -1, -1, 4725, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "keyof"
+  _keywords.ContextualKeyword._keyof << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "l"
+  -1, -1, -1, -1, -1, 4779, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "le"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4806, -1, -1, -1, -1, -1, -1,
+  // "let"
+  (_types.TokenType._let << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "m"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 4860, -1, -1, -1, -1, -1, 4995, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "mi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4887, -1, -1,
+  // "mix"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 4914, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "mixi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4941, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "mixin"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4968, -1, -1, -1, -1, -1, -1, -1,
+  // "mixins"
+  _keywords.ContextualKeyword._mixins << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "mo"
+  -1, -1, -1, -1, 5022, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "mod"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5049, -1, -1, -1, -1, -1,
+  // "modu"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5076, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "modul"
+  -1, -1, -1, -1, -1, 5103, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "module"
+  _keywords.ContextualKeyword._module << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "n"
+  -1, 5157, -1, -1, -1, 5373, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5427, -1, -1, -1, -1, -1,
+  // "na"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5184, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "nam"
+  -1, -1, -1, -1, -1, 5211, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "name"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5238, -1, -1, -1, -1, -1, -1, -1,
+  // "names"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5265, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "namesp"
+  -1, 5292, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "namespa"
+  -1, -1, -1, 5319, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "namespac"
+  -1, -1, -1, -1, -1, 5346, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "namespace"
+  _keywords.ContextualKeyword._namespace << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ne"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5400, -1, -1, -1,
+  // "new"
+  (_types.TokenType._new << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "nu"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5454, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "nul"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5481, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "null"
+  (_types.TokenType._null << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "o"
+  -1, -1, -1, -1, -1, -1, 5535, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5562, -1, -1, -1, -1, 5697, 5751, -1, -1, -1, -1,
+  // "of"
+  _keywords.ContextualKeyword._of << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "op"
+  -1, 5589, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "opa"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5616, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "opaq"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5643, -1, -1, -1, -1, -1,
+  // "opaqu"
+  -1, -1, -1, -1, -1, 5670, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "opaque"
+  _keywords.ContextualKeyword._opaque << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ou"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5724, -1, -1, -1, -1, -1, -1,
+  // "out"
+  _keywords.ContextualKeyword._out << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ov"
+  -1, -1, -1, -1, -1, 5778, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ove"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5805, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "over"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5832, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "overr"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 5859, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "overri"
+  -1, -1, -1, -1, 5886, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "overrid"
+  -1, -1, -1, -1, -1, 5913, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "override"
+  _keywords.ContextualKeyword._override << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "p"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5967, -1, -1, 6345, -1, -1, -1, -1, -1,
+  // "pr"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 5994, -1, -1, -1, -1, -1, 6129, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "pri"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6021, -1, -1, -1, -1,
+  // "priv"
+  -1, 6048, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "priva"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6075, -1, -1, -1, -1, -1, -1,
+  // "privat"
+  -1, -1, -1, -1, -1, 6102, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "private"
+  _keywords.ContextualKeyword._private << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "pro"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6156, -1, -1, -1, -1, -1, -1,
+  // "prot"
+  -1, -1, -1, -1, -1, 6183, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6318, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "prote"
+  -1, -1, -1, 6210, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "protec"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6237, -1, -1, -1, -1, -1, -1,
+  // "protect"
+  -1, -1, -1, -1, -1, 6264, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "protecte"
+  -1, -1, -1, -1, 6291, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "protected"
+  _keywords.ContextualKeyword._protected << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "proto"
+  _keywords.ContextualKeyword._proto << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "pu"
+  -1, -1, 6372, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "pub"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6399, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "publ"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 6426, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "publi"
+  -1, -1, -1, 6453, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "public"
+  _keywords.ContextualKeyword._public << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "r"
+  -1, -1, -1, -1, -1, 6507, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "re"
+  -1, 6534, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6696, -1, -1, 6831, -1, -1, -1, -1, -1, -1,
+  // "rea"
+  -1, -1, -1, -1, 6561, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "read"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6588, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "reado"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6615, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "readon"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6642, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "readonl"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6669, -1,
+  // "readonly"
+  _keywords.ContextualKeyword._readonly << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "req"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6723, -1, -1, -1, -1, -1,
+  // "requ"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 6750, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "requi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6777, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "requir"
+  -1, -1, -1, -1, -1, 6804, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "require"
+  _keywords.ContextualKeyword._require << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ret"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6858, -1, -1, -1, -1, -1,
+  // "retu"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6885, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "retur"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6912, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "return"
+  (_types.TokenType._return << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "s"
+  -1, 6966, -1, -1, -1, 7182, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7236, 7371, -1, 7479, -1, 7614, -1,
+  // "sa"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6993, -1, -1, -1, -1, -1, -1,
+  // "sat"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 7020, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "sati"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7047, -1, -1, -1, -1, -1, -1, -1,
+  // "satis"
+  -1, -1, -1, -1, -1, -1, 7074, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "satisf"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 7101, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "satisfi"
+  -1, -1, -1, -1, -1, 7128, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "satisfie"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7155, -1, -1, -1, -1, -1, -1, -1,
+  // "satisfies"
+  _keywords.ContextualKeyword._satisfies << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "se"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7209, -1, -1, -1, -1, -1, -1,
+  // "set"
+  _keywords.ContextualKeyword._set << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "st"
+  -1, 7263, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "sta"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7290, -1, -1, -1, -1, -1, -1,
+  // "stat"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 7317, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "stati"
+  -1, -1, -1, 7344, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "static"
+  _keywords.ContextualKeyword._static << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "su"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7398, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "sup"
+  -1, -1, -1, -1, -1, 7425, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "supe"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7452, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "super"
+  (_types.TokenType._super << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "sw"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 7506, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "swi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7533, -1, -1, -1, -1, -1, -1,
+  // "swit"
+  -1, -1, -1, 7560, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "switc"
+  -1, -1, -1, -1, -1, -1, -1, -1, 7587, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "switch"
+  (_types.TokenType._switch << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "sy"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7641, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "sym"
+  -1, -1, 7668, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "symb"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7695, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "symbo"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7722, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "symbol"
+  _keywords.ContextualKeyword._symbol << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "t"
+  -1, -1, -1, -1, -1, -1, -1, -1, 7776, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7938, -1, -1, -1, -1, -1, -1, 8046, -1,
+  // "th"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 7803, -1, -1, -1, -1, -1, -1, -1, -1, 7857, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "thi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7830, -1, -1, -1, -1, -1, -1, -1,
+  // "this"
+  (_types.TokenType._this << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "thr"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7884, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "thro"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7911, -1, -1, -1,
+  // "throw"
+  (_types.TokenType._throw << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "tr"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7965, -1, -1, -1, 8019, -1,
+  // "tru"
+  -1, -1, -1, -1, -1, 7992, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "true"
+  (_types.TokenType._true << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "try"
+  (_types.TokenType._try << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "ty"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8073, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "typ"
+  -1, -1, -1, -1, -1, 8100, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "type"
+  _keywords.ContextualKeyword._type << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8127, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "typeo"
+  -1, -1, -1, -1, -1, -1, 8154, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "typeof"
+  (_types.TokenType._typeof << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "u"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8208, -1, -1, -1, -1, 8343, -1, -1, -1, -1, -1, -1, -1,
+  // "un"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 8235, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "uni"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8262, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "uniq"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8289, -1, -1, -1, -1, -1,
+  // "uniqu"
+  -1, -1, -1, -1, -1, 8316, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "unique"
+  _keywords.ContextualKeyword._unique << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "us"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 8370, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "usi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8397, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "usin"
+  -1, -1, -1, -1, -1, -1, -1, 8424, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "using"
+  _keywords.ContextualKeyword._using << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "v"
+  -1, 8478, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8532, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "va"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8505, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "var"
+  (_types.TokenType._var << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "vo"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 8559, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "voi"
+  -1, -1, -1, -1, 8586, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "void"
+  (_types.TokenType._void << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "w"
+  -1, -1, -1, -1, -1, -1, -1, -1, 8640, 8748, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "wh"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 8667, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "whi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8694, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "whil"
+  -1, -1, -1, -1, -1, 8721, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "while"
+  (_types.TokenType._while << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "wi"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8775, -1, -1, -1, -1, -1, -1,
+  // "wit"
+  -1, -1, -1, -1, -1, -1, -1, -1, 8802, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "with"
+  (_types.TokenType._with << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "y"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 8856, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "yi"
+  -1, -1, -1, -1, -1, 8883, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "yie"
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 8910, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "yiel"
+  -1, -1, -1, -1, 8937, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  // "yield"
+  (_types.TokenType._yield << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+]); exports.READ_WORD_TREE = READ_WORD_TREE;
diff --git a/node_modules/sucrase/dist/parser/tokenizer/state.js b/node_modules/sucrase/dist/parser/tokenizer/state.js
new file mode 100644
index 0000000..359e1b4
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/tokenizer/state.js
@@ -0,0 +1,106 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+var _keywords = require('./keywords');
+var _types = require('./types');
+
+ class Scope {
+  
+  
+  
+
+  constructor(startTokenIndex, endTokenIndex, isFunctionScope) {
+    this.startTokenIndex = startTokenIndex;
+    this.endTokenIndex = endTokenIndex;
+    this.isFunctionScope = isFunctionScope;
+  }
+} exports.Scope = Scope;
+
+ class StateSnapshot {
+  constructor(
+     potentialArrowAt,
+     noAnonFunctionType,
+     inDisallowConditionalTypesContext,
+     tokensLength,
+     scopesLength,
+     pos,
+     type,
+     contextualKeyword,
+     start,
+     end,
+     isType,
+     scopeDepth,
+     error,
+  ) {;this.potentialArrowAt = potentialArrowAt;this.noAnonFunctionType = noAnonFunctionType;this.inDisallowConditionalTypesContext = inDisallowConditionalTypesContext;this.tokensLength = tokensLength;this.scopesLength = scopesLength;this.pos = pos;this.type = type;this.contextualKeyword = contextualKeyword;this.start = start;this.end = end;this.isType = isType;this.scopeDepth = scopeDepth;this.error = error;}
+} exports.StateSnapshot = StateSnapshot;
+
+ class State {constructor() { State.prototype.__init.call(this);State.prototype.__init2.call(this);State.prototype.__init3.call(this);State.prototype.__init4.call(this);State.prototype.__init5.call(this);State.prototype.__init6.call(this);State.prototype.__init7.call(this);State.prototype.__init8.call(this);State.prototype.__init9.call(this);State.prototype.__init10.call(this);State.prototype.__init11.call(this);State.prototype.__init12.call(this);State.prototype.__init13.call(this); }
+  // Used to signify the start of a potential arrow function
+  __init() {this.potentialArrowAt = -1}
+
+  // Used by Flow to handle an edge case involving function type parsing.
+  __init2() {this.noAnonFunctionType = false}
+
+  // Used by TypeScript to handle ambiguities when parsing conditional types.
+  __init3() {this.inDisallowConditionalTypesContext = false}
+
+  // Token store.
+  __init4() {this.tokens = []}
+
+  // Array of all observed scopes, ordered by their ending position.
+  __init5() {this.scopes = []}
+
+  // The current position of the tokenizer in the input.
+  __init6() {this.pos = 0}
+
+  // Information about the current token.
+  __init7() {this.type = _types.TokenType.eof}
+  __init8() {this.contextualKeyword = _keywords.ContextualKeyword.NONE}
+  __init9() {this.start = 0}
+  __init10() {this.end = 0}
+
+  __init11() {this.isType = false}
+  __init12() {this.scopeDepth = 0}
+
+  /**
+   * If the parser is in an error state, then the token is always tt.eof and all functions can
+   * keep executing but should be written so they don't get into an infinite loop in this situation.
+   *
+   * This approach, combined with the ability to snapshot and restore state, allows us to implement
+   * backtracking without exceptions and without needing to explicitly propagate error states
+   * everywhere.
+   */
+  __init13() {this.error = null}
+
+  snapshot() {
+    return new StateSnapshot(
+      this.potentialArrowAt,
+      this.noAnonFunctionType,
+      this.inDisallowConditionalTypesContext,
+      this.tokens.length,
+      this.scopes.length,
+      this.pos,
+      this.type,
+      this.contextualKeyword,
+      this.start,
+      this.end,
+      this.isType,
+      this.scopeDepth,
+      this.error,
+    );
+  }
+
+  restoreFromSnapshot(snapshot) {
+    this.potentialArrowAt = snapshot.potentialArrowAt;
+    this.noAnonFunctionType = snapshot.noAnonFunctionType;
+    this.inDisallowConditionalTypesContext = snapshot.inDisallowConditionalTypesContext;
+    this.tokens.length = snapshot.tokensLength;
+    this.scopes.length = snapshot.scopesLength;
+    this.pos = snapshot.pos;
+    this.type = snapshot.type;
+    this.contextualKeyword = snapshot.contextualKeyword;
+    this.start = snapshot.start;
+    this.end = snapshot.end;
+    this.isType = snapshot.isType;
+    this.scopeDepth = snapshot.scopeDepth;
+    this.error = snapshot.error;
+  }
+} exports.default = State;
diff --git a/node_modules/sucrase/dist/parser/tokenizer/types.js b/node_modules/sucrase/dist/parser/tokenizer/types.js
new file mode 100644
index 0000000..c1f2a81
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/tokenizer/types.js
@@ -0,0 +1,361 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// Generated file, do not edit! Run "yarn generate" to re-generate this file.
+/* istanbul ignore file */
+/**
+ * Enum of all token types, with bit fields to signify meaningful properties.
+ */
+var TokenType; (function (TokenType) {
+  // Precedence 0 means not an operator; otherwise it is a positive number up to 12.
+  const PRECEDENCE_MASK = 0xf; TokenType[TokenType["PRECEDENCE_MASK"] = PRECEDENCE_MASK] = "PRECEDENCE_MASK";
+  const IS_KEYWORD = 1 << 4; TokenType[TokenType["IS_KEYWORD"] = IS_KEYWORD] = "IS_KEYWORD";
+  const IS_ASSIGN = 1 << 5; TokenType[TokenType["IS_ASSIGN"] = IS_ASSIGN] = "IS_ASSIGN";
+  const IS_RIGHT_ASSOCIATIVE = 1 << 6; TokenType[TokenType["IS_RIGHT_ASSOCIATIVE"] = IS_RIGHT_ASSOCIATIVE] = "IS_RIGHT_ASSOCIATIVE";
+  const IS_PREFIX = 1 << 7; TokenType[TokenType["IS_PREFIX"] = IS_PREFIX] = "IS_PREFIX";
+  const IS_POSTFIX = 1 << 8; TokenType[TokenType["IS_POSTFIX"] = IS_POSTFIX] = "IS_POSTFIX";
+  const IS_EXPRESSION_START = 1 << 9; TokenType[TokenType["IS_EXPRESSION_START"] = IS_EXPRESSION_START] = "IS_EXPRESSION_START";
+
+  const num = 512; TokenType[TokenType["num"] = num] = "num"; // num startsExpr
+  const bigint = 1536; TokenType[TokenType["bigint"] = bigint] = "bigint"; // bigint startsExpr
+  const decimal = 2560; TokenType[TokenType["decimal"] = decimal] = "decimal"; // decimal startsExpr
+  const regexp = 3584; TokenType[TokenType["regexp"] = regexp] = "regexp"; // regexp startsExpr
+  const string = 4608; TokenType[TokenType["string"] = string] = "string"; // string startsExpr
+  const name = 5632; TokenType[TokenType["name"] = name] = "name"; // name startsExpr
+  const eof = 6144; TokenType[TokenType["eof"] = eof] = "eof"; // eof
+  const bracketL = 7680; TokenType[TokenType["bracketL"] = bracketL] = "bracketL"; // [ startsExpr
+  const bracketR = 8192; TokenType[TokenType["bracketR"] = bracketR] = "bracketR"; // ]
+  const braceL = 9728; TokenType[TokenType["braceL"] = braceL] = "braceL"; // { startsExpr
+  const braceBarL = 10752; TokenType[TokenType["braceBarL"] = braceBarL] = "braceBarL"; // {| startsExpr
+  const braceR = 11264; TokenType[TokenType["braceR"] = braceR] = "braceR"; // }
+  const braceBarR = 12288; TokenType[TokenType["braceBarR"] = braceBarR] = "braceBarR"; // |}
+  const parenL = 13824; TokenType[TokenType["parenL"] = parenL] = "parenL"; // ( startsExpr
+  const parenR = 14336; TokenType[TokenType["parenR"] = parenR] = "parenR"; // )
+  const comma = 15360; TokenType[TokenType["comma"] = comma] = "comma"; // ,
+  const semi = 16384; TokenType[TokenType["semi"] = semi] = "semi"; // ;
+  const colon = 17408; TokenType[TokenType["colon"] = colon] = "colon"; // :
+  const doubleColon = 18432; TokenType[TokenType["doubleColon"] = doubleColon] = "doubleColon"; // ::
+  const dot = 19456; TokenType[TokenType["dot"] = dot] = "dot"; // .
+  const question = 20480; TokenType[TokenType["question"] = question] = "question"; // ?
+  const questionDot = 21504; TokenType[TokenType["questionDot"] = questionDot] = "questionDot"; // ?.
+  const arrow = 22528; TokenType[TokenType["arrow"] = arrow] = "arrow"; // =>
+  const template = 23552; TokenType[TokenType["template"] = template] = "template"; // template
+  const ellipsis = 24576; TokenType[TokenType["ellipsis"] = ellipsis] = "ellipsis"; // ...
+  const backQuote = 25600; TokenType[TokenType["backQuote"] = backQuote] = "backQuote"; // `
+  const dollarBraceL = 27136; TokenType[TokenType["dollarBraceL"] = dollarBraceL] = "dollarBraceL"; // ${ startsExpr
+  const at = 27648; TokenType[TokenType["at"] = at] = "at"; // @
+  const hash = 29184; TokenType[TokenType["hash"] = hash] = "hash"; // # startsExpr
+  const eq = 29728; TokenType[TokenType["eq"] = eq] = "eq"; // = isAssign
+  const assign = 30752; TokenType[TokenType["assign"] = assign] = "assign"; // _= isAssign
+  const preIncDec = 32640; TokenType[TokenType["preIncDec"] = preIncDec] = "preIncDec"; // ++/-- prefix postfix startsExpr
+  const postIncDec = 33664; TokenType[TokenType["postIncDec"] = postIncDec] = "postIncDec"; // ++/-- prefix postfix startsExpr
+  const bang = 34432; TokenType[TokenType["bang"] = bang] = "bang"; // ! prefix startsExpr
+  const tilde = 35456; TokenType[TokenType["tilde"] = tilde] = "tilde"; // ~ prefix startsExpr
+  const pipeline = 35841; TokenType[TokenType["pipeline"] = pipeline] = "pipeline"; // |> prec:1
+  const nullishCoalescing = 36866; TokenType[TokenType["nullishCoalescing"] = nullishCoalescing] = "nullishCoalescing"; // ?? prec:2
+  const logicalOR = 37890; TokenType[TokenType["logicalOR"] = logicalOR] = "logicalOR"; // || prec:2
+  const logicalAND = 38915; TokenType[TokenType["logicalAND"] = logicalAND] = "logicalAND"; // && prec:3
+  const bitwiseOR = 39940; TokenType[TokenType["bitwiseOR"] = bitwiseOR] = "bitwiseOR"; // | prec:4
+  const bitwiseXOR = 40965; TokenType[TokenType["bitwiseXOR"] = bitwiseXOR] = "bitwiseXOR"; // ^ prec:5
+  const bitwiseAND = 41990; TokenType[TokenType["bitwiseAND"] = bitwiseAND] = "bitwiseAND"; // & prec:6
+  const equality = 43015; TokenType[TokenType["equality"] = equality] = "equality"; // ==/!= prec:7
+  const lessThan = 44040; TokenType[TokenType["lessThan"] = lessThan] = "lessThan"; // < prec:8
+  const greaterThan = 45064; TokenType[TokenType["greaterThan"] = greaterThan] = "greaterThan"; // > prec:8
+  const relationalOrEqual = 46088; TokenType[TokenType["relationalOrEqual"] = relationalOrEqual] = "relationalOrEqual"; // <=/>= prec:8
+  const bitShiftL = 47113; TokenType[TokenType["bitShiftL"] = bitShiftL] = "bitShiftL"; // << prec:9
+  const bitShiftR = 48137; TokenType[TokenType["bitShiftR"] = bitShiftR] = "bitShiftR"; // >>/>>> prec:9
+  const plus = 49802; TokenType[TokenType["plus"] = plus] = "plus"; // + prec:10 prefix startsExpr
+  const minus = 50826; TokenType[TokenType["minus"] = minus] = "minus"; // - prec:10 prefix startsExpr
+  const modulo = 51723; TokenType[TokenType["modulo"] = modulo] = "modulo"; // % prec:11 startsExpr
+  const star = 52235; TokenType[TokenType["star"] = star] = "star"; // * prec:11
+  const slash = 53259; TokenType[TokenType["slash"] = slash] = "slash"; // / prec:11
+  const exponent = 54348; TokenType[TokenType["exponent"] = exponent] = "exponent"; // ** prec:12 rightAssociative
+  const jsxName = 55296; TokenType[TokenType["jsxName"] = jsxName] = "jsxName"; // jsxName
+  const jsxText = 56320; TokenType[TokenType["jsxText"] = jsxText] = "jsxText"; // jsxText
+  const jsxEmptyText = 57344; TokenType[TokenType["jsxEmptyText"] = jsxEmptyText] = "jsxEmptyText"; // jsxEmptyText
+  const jsxTagStart = 58880; TokenType[TokenType["jsxTagStart"] = jsxTagStart] = "jsxTagStart"; // jsxTagStart startsExpr
+  const jsxTagEnd = 59392; TokenType[TokenType["jsxTagEnd"] = jsxTagEnd] = "jsxTagEnd"; // jsxTagEnd
+  const typeParameterStart = 60928; TokenType[TokenType["typeParameterStart"] = typeParameterStart] = "typeParameterStart"; // typeParameterStart startsExpr
+  const nonNullAssertion = 61440; TokenType[TokenType["nonNullAssertion"] = nonNullAssertion] = "nonNullAssertion"; // nonNullAssertion
+  const _break = 62480; TokenType[TokenType["_break"] = _break] = "_break"; // break keyword
+  const _case = 63504; TokenType[TokenType["_case"] = _case] = "_case"; // case keyword
+  const _catch = 64528; TokenType[TokenType["_catch"] = _catch] = "_catch"; // catch keyword
+  const _continue = 65552; TokenType[TokenType["_continue"] = _continue] = "_continue"; // continue keyword
+  const _debugger = 66576; TokenType[TokenType["_debugger"] = _debugger] = "_debugger"; // debugger keyword
+  const _default = 67600; TokenType[TokenType["_default"] = _default] = "_default"; // default keyword
+  const _do = 68624; TokenType[TokenType["_do"] = _do] = "_do"; // do keyword
+  const _else = 69648; TokenType[TokenType["_else"] = _else] = "_else"; // else keyword
+  const _finally = 70672; TokenType[TokenType["_finally"] = _finally] = "_finally"; // finally keyword
+  const _for = 71696; TokenType[TokenType["_for"] = _for] = "_for"; // for keyword
+  const _function = 73232; TokenType[TokenType["_function"] = _function] = "_function"; // function keyword startsExpr
+  const _if = 73744; TokenType[TokenType["_if"] = _if] = "_if"; // if keyword
+  const _return = 74768; TokenType[TokenType["_return"] = _return] = "_return"; // return keyword
+  const _switch = 75792; TokenType[TokenType["_switch"] = _switch] = "_switch"; // switch keyword
+  const _throw = 77456; TokenType[TokenType["_throw"] = _throw] = "_throw"; // throw keyword prefix startsExpr
+  const _try = 77840; TokenType[TokenType["_try"] = _try] = "_try"; // try keyword
+  const _var = 78864; TokenType[TokenType["_var"] = _var] = "_var"; // var keyword
+  const _let = 79888; TokenType[TokenType["_let"] = _let] = "_let"; // let keyword
+  const _const = 80912; TokenType[TokenType["_const"] = _const] = "_const"; // const keyword
+  const _while = 81936; TokenType[TokenType["_while"] = _while] = "_while"; // while keyword
+  const _with = 82960; TokenType[TokenType["_with"] = _with] = "_with"; // with keyword
+  const _new = 84496; TokenType[TokenType["_new"] = _new] = "_new"; // new keyword startsExpr
+  const _this = 85520; TokenType[TokenType["_this"] = _this] = "_this"; // this keyword startsExpr
+  const _super = 86544; TokenType[TokenType["_super"] = _super] = "_super"; // super keyword startsExpr
+  const _class = 87568; TokenType[TokenType["_class"] = _class] = "_class"; // class keyword startsExpr
+  const _extends = 88080; TokenType[TokenType["_extends"] = _extends] = "_extends"; // extends keyword
+  const _export = 89104; TokenType[TokenType["_export"] = _export] = "_export"; // export keyword
+  const _import = 90640; TokenType[TokenType["_import"] = _import] = "_import"; // import keyword startsExpr
+  const _yield = 91664; TokenType[TokenType["_yield"] = _yield] = "_yield"; // yield keyword startsExpr
+  const _null = 92688; TokenType[TokenType["_null"] = _null] = "_null"; // null keyword startsExpr
+  const _true = 93712; TokenType[TokenType["_true"] = _true] = "_true"; // true keyword startsExpr
+  const _false = 94736; TokenType[TokenType["_false"] = _false] = "_false"; // false keyword startsExpr
+  const _in = 95256; TokenType[TokenType["_in"] = _in] = "_in"; // in prec:8 keyword
+  const _instanceof = 96280; TokenType[TokenType["_instanceof"] = _instanceof] = "_instanceof"; // instanceof prec:8 keyword
+  const _typeof = 97936; TokenType[TokenType["_typeof"] = _typeof] = "_typeof"; // typeof keyword prefix startsExpr
+  const _void = 98960; TokenType[TokenType["_void"] = _void] = "_void"; // void keyword prefix startsExpr
+  const _delete = 99984; TokenType[TokenType["_delete"] = _delete] = "_delete"; // delete keyword prefix startsExpr
+  const _async = 100880; TokenType[TokenType["_async"] = _async] = "_async"; // async keyword startsExpr
+  const _get = 101904; TokenType[TokenType["_get"] = _get] = "_get"; // get keyword startsExpr
+  const _set = 102928; TokenType[TokenType["_set"] = _set] = "_set"; // set keyword startsExpr
+  const _declare = 103952; TokenType[TokenType["_declare"] = _declare] = "_declare"; // declare keyword startsExpr
+  const _readonly = 104976; TokenType[TokenType["_readonly"] = _readonly] = "_readonly"; // readonly keyword startsExpr
+  const _abstract = 106000; TokenType[TokenType["_abstract"] = _abstract] = "_abstract"; // abstract keyword startsExpr
+  const _static = 107024; TokenType[TokenType["_static"] = _static] = "_static"; // static keyword startsExpr
+  const _public = 107536; TokenType[TokenType["_public"] = _public] = "_public"; // public keyword
+  const _private = 108560; TokenType[TokenType["_private"] = _private] = "_private"; // private keyword
+  const _protected = 109584; TokenType[TokenType["_protected"] = _protected] = "_protected"; // protected keyword
+  const _override = 110608; TokenType[TokenType["_override"] = _override] = "_override"; // override keyword
+  const _as = 112144; TokenType[TokenType["_as"] = _as] = "_as"; // as keyword startsExpr
+  const _enum = 113168; TokenType[TokenType["_enum"] = _enum] = "_enum"; // enum keyword startsExpr
+  const _type = 114192; TokenType[TokenType["_type"] = _type] = "_type"; // type keyword startsExpr
+  const _implements = 115216; TokenType[TokenType["_implements"] = _implements] = "_implements"; // implements keyword startsExpr
+})(TokenType || (exports.TokenType = TokenType = {}));
+ function formatTokenType(tokenType) {
+  switch (tokenType) {
+    case TokenType.num:
+      return "num";
+    case TokenType.bigint:
+      return "bigint";
+    case TokenType.decimal:
+      return "decimal";
+    case TokenType.regexp:
+      return "regexp";
+    case TokenType.string:
+      return "string";
+    case TokenType.name:
+      return "name";
+    case TokenType.eof:
+      return "eof";
+    case TokenType.bracketL:
+      return "[";
+    case TokenType.bracketR:
+      return "]";
+    case TokenType.braceL:
+      return "{";
+    case TokenType.braceBarL:
+      return "{|";
+    case TokenType.braceR:
+      return "}";
+    case TokenType.braceBarR:
+      return "|}";
+    case TokenType.parenL:
+      return "(";
+    case TokenType.parenR:
+      return ")";
+    case TokenType.comma:
+      return ",";
+    case TokenType.semi:
+      return ";";
+    case TokenType.colon:
+      return ":";
+    case TokenType.doubleColon:
+      return "::";
+    case TokenType.dot:
+      return ".";
+    case TokenType.question:
+      return "?";
+    case TokenType.questionDot:
+      return "?.";
+    case TokenType.arrow:
+      return "=>";
+    case TokenType.template:
+      return "template";
+    case TokenType.ellipsis:
+      return "...";
+    case TokenType.backQuote:
+      return "`";
+    case TokenType.dollarBraceL:
+      return "${";
+    case TokenType.at:
+      return "@";
+    case TokenType.hash:
+      return "#";
+    case TokenType.eq:
+      return "=";
+    case TokenType.assign:
+      return "_=";
+    case TokenType.preIncDec:
+      return "++/--";
+    case TokenType.postIncDec:
+      return "++/--";
+    case TokenType.bang:
+      return "!";
+    case TokenType.tilde:
+      return "~";
+    case TokenType.pipeline:
+      return "|>";
+    case TokenType.nullishCoalescing:
+      return "??";
+    case TokenType.logicalOR:
+      return "||";
+    case TokenType.logicalAND:
+      return "&&";
+    case TokenType.bitwiseOR:
+      return "|";
+    case TokenType.bitwiseXOR:
+      return "^";
+    case TokenType.bitwiseAND:
+      return "&";
+    case TokenType.equality:
+      return "==/!=";
+    case TokenType.lessThan:
+      return "<";
+    case TokenType.greaterThan:
+      return ">";
+    case TokenType.relationalOrEqual:
+      return "<=/>=";
+    case TokenType.bitShiftL:
+      return "<<";
+    case TokenType.bitShiftR:
+      return ">>/>>>";
+    case TokenType.plus:
+      return "+";
+    case TokenType.minus:
+      return "-";
+    case TokenType.modulo:
+      return "%";
+    case TokenType.star:
+      return "*";
+    case TokenType.slash:
+      return "/";
+    case TokenType.exponent:
+      return "**";
+    case TokenType.jsxName:
+      return "jsxName";
+    case TokenType.jsxText:
+      return "jsxText";
+    case TokenType.jsxEmptyText:
+      return "jsxEmptyText";
+    case TokenType.jsxTagStart:
+      return "jsxTagStart";
+    case TokenType.jsxTagEnd:
+      return "jsxTagEnd";
+    case TokenType.typeParameterStart:
+      return "typeParameterStart";
+    case TokenType.nonNullAssertion:
+      return "nonNullAssertion";
+    case TokenType._break:
+      return "break";
+    case TokenType._case:
+      return "case";
+    case TokenType._catch:
+      return "catch";
+    case TokenType._continue:
+      return "continue";
+    case TokenType._debugger:
+      return "debugger";
+    case TokenType._default:
+      return "default";
+    case TokenType._do:
+      return "do";
+    case TokenType._else:
+      return "else";
+    case TokenType._finally:
+      return "finally";
+    case TokenType._for:
+      return "for";
+    case TokenType._function:
+      return "function";
+    case TokenType._if:
+      return "if";
+    case TokenType._return:
+      return "return";
+    case TokenType._switch:
+      return "switch";
+    case TokenType._throw:
+      return "throw";
+    case TokenType._try:
+      return "try";
+    case TokenType._var:
+      return "var";
+    case TokenType._let:
+      return "let";
+    case TokenType._const:
+      return "const";
+    case TokenType._while:
+      return "while";
+    case TokenType._with:
+      return "with";
+    case TokenType._new:
+      return "new";
+    case TokenType._this:
+      return "this";
+    case TokenType._super:
+      return "super";
+    case TokenType._class:
+      return "class";
+    case TokenType._extends:
+      return "extends";
+    case TokenType._export:
+      return "export";
+    case TokenType._import:
+      return "import";
+    case TokenType._yield:
+      return "yield";
+    case TokenType._null:
+      return "null";
+    case TokenType._true:
+      return "true";
+    case TokenType._false:
+      return "false";
+    case TokenType._in:
+      return "in";
+    case TokenType._instanceof:
+      return "instanceof";
+    case TokenType._typeof:
+      return "typeof";
+    case TokenType._void:
+      return "void";
+    case TokenType._delete:
+      return "delete";
+    case TokenType._async:
+      return "async";
+    case TokenType._get:
+      return "get";
+    case TokenType._set:
+      return "set";
+    case TokenType._declare:
+      return "declare";
+    case TokenType._readonly:
+      return "readonly";
+    case TokenType._abstract:
+      return "abstract";
+    case TokenType._static:
+      return "static";
+    case TokenType._public:
+      return "public";
+    case TokenType._private:
+      return "private";
+    case TokenType._protected:
+      return "protected";
+    case TokenType._override:
+      return "override";
+    case TokenType._as:
+      return "as";
+    case TokenType._enum:
+      return "enum";
+    case TokenType._type:
+      return "type";
+    case TokenType._implements:
+      return "implements";
+    default:
+      return "";
+  }
+} exports.formatTokenType = formatTokenType;
diff --git a/node_modules/sucrase/dist/parser/traverser/base.js b/node_modules/sucrase/dist/parser/traverser/base.js
new file mode 100644
index 0000000..85c9c17
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/traverser/base.js
@@ -0,0 +1,60 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _state = require('../tokenizer/state'); var _state2 = _interopRequireDefault(_state);
+var _charcodes = require('../util/charcodes');
+
+ exports.isJSXEnabled;
+ exports.isTypeScriptEnabled;
+ exports.isFlowEnabled;
+ exports.state;
+ exports.input;
+ exports.nextContextId;
+
+ function getNextContextId() {
+  return exports.nextContextId++;
+} exports.getNextContextId = getNextContextId;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ function augmentError(error) {
+  if ("pos" in error) {
+    const loc = locationForIndex(error.pos);
+    error.message += ` (${loc.line}:${loc.column})`;
+    error.loc = loc;
+  }
+  return error;
+} exports.augmentError = augmentError;
+
+ class Loc {
+  
+  
+  constructor(line, column) {
+    this.line = line;
+    this.column = column;
+  }
+} exports.Loc = Loc;
+
+ function locationForIndex(pos) {
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < pos; i++) {
+    if (exports.input.charCodeAt(i) === _charcodes.charCodes.lineFeed) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return new Loc(line, column);
+} exports.locationForIndex = locationForIndex;
+
+ function initParser(
+  inputCode,
+  isJSXEnabledArg,
+  isTypeScriptEnabledArg,
+  isFlowEnabledArg,
+) {
+  exports.input = inputCode;
+  exports.state = new (0, _state2.default)();
+  exports.nextContextId = 1;
+  exports.isJSXEnabled = isJSXEnabledArg;
+  exports.isTypeScriptEnabled = isTypeScriptEnabledArg;
+  exports.isFlowEnabled = isFlowEnabledArg;
+} exports.initParser = initParser;
diff --git a/node_modules/sucrase/dist/parser/traverser/expression.js b/node_modules/sucrase/dist/parser/traverser/expression.js
new file mode 100644
index 0000000..d0011e3
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/traverser/expression.js
@@ -0,0 +1,1022 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});/* eslint max-len: 0 */
+
+// A recursive descent parser operates by defining functions for all
+// syntactic elements, and recursively calling those, each function
+// advancing the input stream and returning an AST node. Precedence
+// of constructs (for example, the fact that `!x[1]` means `!(x[1])`
+// instead of `(!x)[1]` is handled by the fact that the parser
+// function that parses unary prefix operators is called first, and
+// in turn calls the function that parses `[]` subscripts — that
+// way, it'll receive the node for `x[1]` already parsed, and wraps
+// *that* in the unary operator node.
+//
+// Acorn uses an [operator precedence parser][opp] to handle binary
+// operator precedence, because it is much more compact than using
+// the technique outlined above, which uses different, nesting
+// functions to specify precedence, for all of the ten binary
+// precedence levels that JavaScript defines.
+//
+// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
+
+
+
+
+
+
+
+
+
+
+
+var _flow = require('../plugins/flow');
+var _index = require('../plugins/jsx/index');
+var _types = require('../plugins/types');
+
+
+
+
+
+
+
+
+
+var _typescript = require('../plugins/typescript');
+
+
+
+
+
+
+
+
+
+
+
+
+var _index3 = require('../tokenizer/index');
+var _keywords = require('../tokenizer/keywords');
+var _state = require('../tokenizer/state');
+var _types3 = require('../tokenizer/types');
+var _charcodes = require('../util/charcodes');
+var _identifier = require('../util/identifier');
+var _base = require('./base');
+
+
+
+
+
+
+var _lval = require('./lval');
+
+
+
+
+
+
+
+var _statement = require('./statement');
+
+
+
+
+
+
+
+
+
+var _util = require('./util');
+
+ class StopState {
+  
+  constructor(stop) {
+    this.stop = stop;
+  }
+} exports.StopState = StopState;
+
+// ### Expression parsing
+
+// These nest, from the most general expression type at the top to
+// 'atomic', nondivisible expression types at the bottom. Most of
+// the functions will simply let the function (s) below them parse,
+// and, *if* the syntactic construct they handle is present, wrap
+// the AST node that the inner parser gave them in another node.
+ function parseExpression(noIn = false) {
+  parseMaybeAssign(noIn);
+  if (_index3.match.call(void 0, _types3.TokenType.comma)) {
+    while (_index3.eat.call(void 0, _types3.TokenType.comma)) {
+      parseMaybeAssign(noIn);
+    }
+  }
+} exports.parseExpression = parseExpression;
+
+/**
+ * noIn is used when parsing a for loop so that we don't interpret a following "in" as the binary
+ * operatior.
+ * isWithinParens is used to indicate that we're parsing something that might be a comma expression
+ * or might be an arrow function or might be a Flow type assertion (which requires explicit parens).
+ * In these cases, we should allow : and ?: after the initial "left" part.
+ */
+ function parseMaybeAssign(noIn = false, isWithinParens = false) {
+  if (_base.isTypeScriptEnabled) {
+    return _typescript.tsParseMaybeAssign.call(void 0, noIn, isWithinParens);
+  } else if (_base.isFlowEnabled) {
+    return _flow.flowParseMaybeAssign.call(void 0, noIn, isWithinParens);
+  } else {
+    return baseParseMaybeAssign(noIn, isWithinParens);
+  }
+} exports.parseMaybeAssign = parseMaybeAssign;
+
+// Parse an assignment expression. This includes applications of
+// operators like `+=`.
+// Returns true if the expression was an arrow function.
+ function baseParseMaybeAssign(noIn, isWithinParens) {
+  if (_index3.match.call(void 0, _types3.TokenType._yield)) {
+    parseYield();
+    return false;
+  }
+
+  if (_index3.match.call(void 0, _types3.TokenType.parenL) || _index3.match.call(void 0, _types3.TokenType.name) || _index3.match.call(void 0, _types3.TokenType._yield)) {
+    _base.state.potentialArrowAt = _base.state.start;
+  }
+
+  const wasArrow = parseMaybeConditional(noIn);
+  if (isWithinParens) {
+    parseParenItem();
+  }
+  if (_base.state.type & _types3.TokenType.IS_ASSIGN) {
+    _index3.next.call(void 0, );
+    parseMaybeAssign(noIn);
+    return false;
+  }
+  return wasArrow;
+} exports.baseParseMaybeAssign = baseParseMaybeAssign;
+
+// Parse a ternary conditional (`?:`) operator.
+// Returns true if the expression was an arrow function.
+function parseMaybeConditional(noIn) {
+  const wasArrow = parseExprOps(noIn);
+  if (wasArrow) {
+    return true;
+  }
+  parseConditional(noIn);
+  return false;
+}
+
+function parseConditional(noIn) {
+  if (_base.isTypeScriptEnabled || _base.isFlowEnabled) {
+    _types.typedParseConditional.call(void 0, noIn);
+  } else {
+    baseParseConditional(noIn);
+  }
+}
+
+ function baseParseConditional(noIn) {
+  if (_index3.eat.call(void 0, _types3.TokenType.question)) {
+    parseMaybeAssign();
+    _util.expect.call(void 0, _types3.TokenType.colon);
+    parseMaybeAssign(noIn);
+  }
+} exports.baseParseConditional = baseParseConditional;
+
+// Start the precedence parser.
+// Returns true if this was an arrow function
+function parseExprOps(noIn) {
+  const startTokenIndex = _base.state.tokens.length;
+  const wasArrow = parseMaybeUnary();
+  if (wasArrow) {
+    return true;
+  }
+  parseExprOp(startTokenIndex, -1, noIn);
+  return false;
+}
+
+// Parse binary operators with the operator precedence parsing
+// algorithm. `left` is the left-hand side of the operator.
+// `minPrec` provides context that allows the function to stop and
+// defer further parser to one of its callers when it encounters an
+// operator that has a lower precedence than the set it is parsing.
+function parseExprOp(startTokenIndex, minPrec, noIn) {
+  if (
+    _base.isTypeScriptEnabled &&
+    (_types3.TokenType._in & _types3.TokenType.PRECEDENCE_MASK) > minPrec &&
+    !_util.hasPrecedingLineBreak.call(void 0, ) &&
+    (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as) || _util.eatContextual.call(void 0, _keywords.ContextualKeyword._satisfies))
+  ) {
+    const oldIsType = _index3.pushTypeContext.call(void 0, 1);
+    _typescript.tsParseType.call(void 0, );
+    _index3.popTypeContext.call(void 0, oldIsType);
+    _index3.rescan_gt.call(void 0, );
+    parseExprOp(startTokenIndex, minPrec, noIn);
+    return;
+  }
+
+  const prec = _base.state.type & _types3.TokenType.PRECEDENCE_MASK;
+  if (prec > 0 && (!noIn || !_index3.match.call(void 0, _types3.TokenType._in))) {
+    if (prec > minPrec) {
+      const op = _base.state.type;
+      _index3.next.call(void 0, );
+      if (op === _types3.TokenType.nullishCoalescing) {
+        _base.state.tokens[_base.state.tokens.length - 1].nullishStartIndex = startTokenIndex;
+      }
+
+      const rhsStartTokenIndex = _base.state.tokens.length;
+      parseMaybeUnary();
+      // Extend the right operand of this operator if possible.
+      parseExprOp(rhsStartTokenIndex, op & _types3.TokenType.IS_RIGHT_ASSOCIATIVE ? prec - 1 : prec, noIn);
+      if (op === _types3.TokenType.nullishCoalescing) {
+        _base.state.tokens[startTokenIndex].numNullishCoalesceStarts++;
+        _base.state.tokens[_base.state.tokens.length - 1].numNullishCoalesceEnds++;
+      }
+      // Continue with any future operator holding this expression as the left operand.
+      parseExprOp(startTokenIndex, minPrec, noIn);
+    }
+  }
+}
+
+// Parse unary operators, both prefix and postfix.
+// Returns true if this was an arrow function.
+ function parseMaybeUnary() {
+  if (_base.isTypeScriptEnabled && !_base.isJSXEnabled && _index3.eat.call(void 0, _types3.TokenType.lessThan)) {
+    _typescript.tsParseTypeAssertion.call(void 0, );
+    return false;
+  }
+  if (
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._module) &&
+    _index3.lookaheadCharCode.call(void 0, ) === _charcodes.charCodes.leftCurlyBrace &&
+    !_util.hasFollowingLineBreak.call(void 0, )
+  ) {
+    parseModuleExpression();
+    return false;
+  }
+  if (_base.state.type & _types3.TokenType.IS_PREFIX) {
+    _index3.next.call(void 0, );
+    parseMaybeUnary();
+    return false;
+  }
+
+  const wasArrow = parseExprSubscripts();
+  if (wasArrow) {
+    return true;
+  }
+  while (_base.state.type & _types3.TokenType.IS_POSTFIX && !_util.canInsertSemicolon.call(void 0, )) {
+    // The tokenizer calls everything a preincrement, so make it a postincrement when
+    // we see it in that context.
+    if (_base.state.type === _types3.TokenType.preIncDec) {
+      _base.state.type = _types3.TokenType.postIncDec;
+    }
+    _index3.next.call(void 0, );
+  }
+  return false;
+} exports.parseMaybeUnary = parseMaybeUnary;
+
+// Parse call, dot, and `[]`-subscript expressions.
+// Returns true if this was an arrow function.
+ function parseExprSubscripts() {
+  const startTokenIndex = _base.state.tokens.length;
+  const wasArrow = parseExprAtom();
+  if (wasArrow) {
+    return true;
+  }
+  parseSubscripts(startTokenIndex);
+  // If there was any optional chain operation, the start token would be marked
+  // as such, so also mark the end now.
+  if (_base.state.tokens.length > startTokenIndex && _base.state.tokens[startTokenIndex].isOptionalChainStart) {
+    _base.state.tokens[_base.state.tokens.length - 1].isOptionalChainEnd = true;
+  }
+  return false;
+} exports.parseExprSubscripts = parseExprSubscripts;
+
+function parseSubscripts(startTokenIndex, noCalls = false) {
+  if (_base.isFlowEnabled) {
+    _flow.flowParseSubscripts.call(void 0, startTokenIndex, noCalls);
+  } else {
+    baseParseSubscripts(startTokenIndex, noCalls);
+  }
+}
+
+ function baseParseSubscripts(startTokenIndex, noCalls = false) {
+  const stopState = new StopState(false);
+  do {
+    parseSubscript(startTokenIndex, noCalls, stopState);
+  } while (!stopState.stop && !_base.state.error);
+} exports.baseParseSubscripts = baseParseSubscripts;
+
+function parseSubscript(startTokenIndex, noCalls, stopState) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
+  } else if (_base.isFlowEnabled) {
+    _flow.flowParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
+  } else {
+    baseParseSubscript(startTokenIndex, noCalls, stopState);
+  }
+}
+
+/** Set 'state.stop = true' to indicate that we should stop parsing subscripts. */
+ function baseParseSubscript(
+  startTokenIndex,
+  noCalls,
+  stopState,
+) {
+  if (!noCalls && _index3.eat.call(void 0, _types3.TokenType.doubleColon)) {
+    parseNoCallExpr();
+    stopState.stop = true;
+    // Propagate startTokenIndex so that `a::b?.()` will keep `a` as the first token. We may want
+    // to revisit this in the future when fully supporting bind syntax.
+    parseSubscripts(startTokenIndex, noCalls);
+  } else if (_index3.match.call(void 0, _types3.TokenType.questionDot)) {
+    _base.state.tokens[startTokenIndex].isOptionalChainStart = true;
+    if (noCalls && _index3.lookaheadType.call(void 0, ) === _types3.TokenType.parenL) {
+      stopState.stop = true;
+      return;
+    }
+    _index3.next.call(void 0, );
+    _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
+
+    if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
+      parseExpression();
+      _util.expect.call(void 0, _types3.TokenType.bracketR);
+    } else if (_index3.eat.call(void 0, _types3.TokenType.parenL)) {
+      parseCallExpressionArguments();
+    } else {
+      parseMaybePrivateName();
+    }
+  } else if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
+    _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
+    parseMaybePrivateName();
+  } else if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
+    _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
+    parseExpression();
+    _util.expect.call(void 0, _types3.TokenType.bracketR);
+  } else if (!noCalls && _index3.match.call(void 0, _types3.TokenType.parenL)) {
+    if (atPossibleAsync()) {
+      // We see "async", but it's possible it's a usage of the name "async". Parse as if it's a
+      // function call, and if we see an arrow later, backtrack and re-parse as a parameter list.
+      const snapshot = _base.state.snapshot();
+      const asyncStartTokenIndex = _base.state.tokens.length;
+      _index3.next.call(void 0, );
+      _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
+
+      const callContextId = _base.getNextContextId.call(void 0, );
+
+      _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
+      parseCallExpressionArguments();
+      _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
+
+      if (shouldParseAsyncArrow()) {
+        // We hit an arrow, so backtrack and start again parsing function parameters.
+        _base.state.restoreFromSnapshot(snapshot);
+        stopState.stop = true;
+        _base.state.scopeDepth++;
+
+        _statement.parseFunctionParams.call(void 0, );
+        parseAsyncArrowFromCallExpression(asyncStartTokenIndex);
+      }
+    } else {
+      _index3.next.call(void 0, );
+      _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
+      const callContextId = _base.getNextContextId.call(void 0, );
+      _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
+      parseCallExpressionArguments();
+      _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
+    }
+  } else if (_index3.match.call(void 0, _types3.TokenType.backQuote)) {
+    // Tagged template expression.
+    parseTemplate();
+  } else {
+    stopState.stop = true;
+  }
+} exports.baseParseSubscript = baseParseSubscript;
+
+ function atPossibleAsync() {
+  // This was made less strict than the original version to avoid passing around nodes, but it
+  // should be safe to have rare false positives here.
+  return (
+    _base.state.tokens[_base.state.tokens.length - 1].contextualKeyword === _keywords.ContextualKeyword._async &&
+    !_util.canInsertSemicolon.call(void 0, )
+  );
+} exports.atPossibleAsync = atPossibleAsync;
+
+ function parseCallExpressionArguments() {
+  let first = true;
+  while (!_index3.eat.call(void 0, _types3.TokenType.parenR) && !_base.state.error) {
+    if (first) {
+      first = false;
+    } else {
+      _util.expect.call(void 0, _types3.TokenType.comma);
+      if (_index3.eat.call(void 0, _types3.TokenType.parenR)) {
+        break;
+      }
+    }
+
+    parseExprListItem(false);
+  }
+} exports.parseCallExpressionArguments = parseCallExpressionArguments;
+
+function shouldParseAsyncArrow() {
+  return _index3.match.call(void 0, _types3.TokenType.colon) || _index3.match.call(void 0, _types3.TokenType.arrow);
+}
+
+function parseAsyncArrowFromCallExpression(startTokenIndex) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsStartParseAsyncArrowFromCallExpression.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    _flow.flowStartParseAsyncArrowFromCallExpression.call(void 0, );
+  }
+  _util.expect.call(void 0, _types3.TokenType.arrow);
+  parseArrowExpression(startTokenIndex);
+}
+
+// Parse a no-call expression (like argument of `new` or `::` operators).
+
+function parseNoCallExpr() {
+  const startTokenIndex = _base.state.tokens.length;
+  parseExprAtom();
+  parseSubscripts(startTokenIndex, true);
+}
+
+// Parse an atomic expression — either a single token that is an
+// expression, an expression started by a keyword like `function` or
+// `new`, or an expression wrapped in punctuation like `()`, `[]`,
+// or `{}`.
+// Returns true if the parsed expression was an arrow function.
+ function parseExprAtom() {
+  if (_index3.eat.call(void 0, _types3.TokenType.modulo)) {
+    // V8 intrinsic expression. Just parse the identifier, and the function invocation is parsed
+    // naturally.
+    parseIdentifier();
+    return false;
+  }
+
+  if (_index3.match.call(void 0, _types3.TokenType.jsxText) || _index3.match.call(void 0, _types3.TokenType.jsxEmptyText)) {
+    parseLiteral();
+    return false;
+  } else if (_index3.match.call(void 0, _types3.TokenType.lessThan) && _base.isJSXEnabled) {
+    _base.state.type = _types3.TokenType.jsxTagStart;
+    _index.jsxParseElement.call(void 0, );
+    _index3.next.call(void 0, );
+    return false;
+  }
+
+  const canBeArrow = _base.state.potentialArrowAt === _base.state.start;
+  switch (_base.state.type) {
+    case _types3.TokenType.slash:
+    case _types3.TokenType.assign:
+      _index3.retokenizeSlashAsRegex.call(void 0, );
+    // Fall through.
+
+    case _types3.TokenType._super:
+    case _types3.TokenType._this:
+    case _types3.TokenType.regexp:
+    case _types3.TokenType.num:
+    case _types3.TokenType.bigint:
+    case _types3.TokenType.decimal:
+    case _types3.TokenType.string:
+    case _types3.TokenType._null:
+    case _types3.TokenType._true:
+    case _types3.TokenType._false:
+      _index3.next.call(void 0, );
+      return false;
+
+    case _types3.TokenType._import:
+      _index3.next.call(void 0, );
+      if (_index3.match.call(void 0, _types3.TokenType.dot)) {
+        // import.meta
+        _base.state.tokens[_base.state.tokens.length - 1].type = _types3.TokenType.name;
+        _index3.next.call(void 0, );
+        parseIdentifier();
+      }
+      return false;
+
+    case _types3.TokenType.name: {
+      const startTokenIndex = _base.state.tokens.length;
+      const functionStart = _base.state.start;
+      const contextualKeyword = _base.state.contextualKeyword;
+      parseIdentifier();
+      if (contextualKeyword === _keywords.ContextualKeyword._await) {
+        parseAwait();
+        return false;
+      } else if (
+        contextualKeyword === _keywords.ContextualKeyword._async &&
+        _index3.match.call(void 0, _types3.TokenType._function) &&
+        !_util.canInsertSemicolon.call(void 0, )
+      ) {
+        _index3.next.call(void 0, );
+        _statement.parseFunction.call(void 0, functionStart, false);
+        return false;
+      } else if (
+        canBeArrow &&
+        contextualKeyword === _keywords.ContextualKeyword._async &&
+        !_util.canInsertSemicolon.call(void 0, ) &&
+        _index3.match.call(void 0, _types3.TokenType.name)
+      ) {
+        _base.state.scopeDepth++;
+        _lval.parseBindingIdentifier.call(void 0, false);
+        _util.expect.call(void 0, _types3.TokenType.arrow);
+        // let foo = async bar => {};
+        parseArrowExpression(startTokenIndex);
+        return true;
+      } else if (_index3.match.call(void 0, _types3.TokenType._do) && !_util.canInsertSemicolon.call(void 0, )) {
+        _index3.next.call(void 0, );
+        _statement.parseBlock.call(void 0, );
+        return false;
+      }
+
+      if (canBeArrow && !_util.canInsertSemicolon.call(void 0, ) && _index3.match.call(void 0, _types3.TokenType.arrow)) {
+        _base.state.scopeDepth++;
+        _lval.markPriorBindingIdentifier.call(void 0, false);
+        _util.expect.call(void 0, _types3.TokenType.arrow);
+        parseArrowExpression(startTokenIndex);
+        return true;
+      }
+
+      _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index3.IdentifierRole.Access;
+      return false;
+    }
+
+    case _types3.TokenType._do: {
+      _index3.next.call(void 0, );
+      _statement.parseBlock.call(void 0, );
+      return false;
+    }
+
+    case _types3.TokenType.parenL: {
+      const wasArrow = parseParenAndDistinguishExpression(canBeArrow);
+      return wasArrow;
+    }
+
+    case _types3.TokenType.bracketL:
+      _index3.next.call(void 0, );
+      parseExprList(_types3.TokenType.bracketR, true);
+      return false;
+
+    case _types3.TokenType.braceL:
+      parseObj(false, false);
+      return false;
+
+    case _types3.TokenType._function:
+      parseFunctionExpression();
+      return false;
+
+    case _types3.TokenType.at:
+      _statement.parseDecorators.call(void 0, );
+    // Fall through.
+
+    case _types3.TokenType._class:
+      _statement.parseClass.call(void 0, false);
+      return false;
+
+    case _types3.TokenType._new:
+      parseNew();
+      return false;
+
+    case _types3.TokenType.backQuote:
+      parseTemplate();
+      return false;
+
+    case _types3.TokenType.doubleColon: {
+      _index3.next.call(void 0, );
+      parseNoCallExpr();
+      return false;
+    }
+
+    case _types3.TokenType.hash: {
+      const code = _index3.lookaheadCharCode.call(void 0, );
+      if (_identifier.IS_IDENTIFIER_START[code] || code === _charcodes.charCodes.backslash) {
+        parseMaybePrivateName();
+      } else {
+        _index3.next.call(void 0, );
+      }
+      // Smart pipeline topic reference.
+      return false;
+    }
+
+    default:
+      _util.unexpected.call(void 0, );
+      return false;
+  }
+} exports.parseExprAtom = parseExprAtom;
+
+function parseMaybePrivateName() {
+  _index3.eat.call(void 0, _types3.TokenType.hash);
+  parseIdentifier();
+}
+
+function parseFunctionExpression() {
+  const functionStart = _base.state.start;
+  parseIdentifier();
+  if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
+    // function.sent
+    parseIdentifier();
+  }
+  _statement.parseFunction.call(void 0, functionStart, false);
+}
+
+ function parseLiteral() {
+  _index3.next.call(void 0, );
+} exports.parseLiteral = parseLiteral;
+
+ function parseParenExpression() {
+  _util.expect.call(void 0, _types3.TokenType.parenL);
+  parseExpression();
+  _util.expect.call(void 0, _types3.TokenType.parenR);
+} exports.parseParenExpression = parseParenExpression;
+
+// Returns true if this was an arrow expression.
+function parseParenAndDistinguishExpression(canBeArrow) {
+  // Assume this is a normal parenthesized expression, but if we see an arrow, we'll bail and
+  // start over as a parameter list.
+  const snapshot = _base.state.snapshot();
+
+  const startTokenIndex = _base.state.tokens.length;
+  _util.expect.call(void 0, _types3.TokenType.parenL);
+
+  let first = true;
+
+  while (!_index3.match.call(void 0, _types3.TokenType.parenR) && !_base.state.error) {
+    if (first) {
+      first = false;
+    } else {
+      _util.expect.call(void 0, _types3.TokenType.comma);
+      if (_index3.match.call(void 0, _types3.TokenType.parenR)) {
+        break;
+      }
+    }
+
+    if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
+      _lval.parseRest.call(void 0, false /* isBlockScope */);
+      parseParenItem();
+      break;
+    } else {
+      parseMaybeAssign(false, true);
+    }
+  }
+
+  _util.expect.call(void 0, _types3.TokenType.parenR);
+
+  if (canBeArrow && shouldParseArrow()) {
+    const wasArrow = parseArrow();
+    if (wasArrow) {
+      // It was an arrow function this whole time, so start over and parse it as params so that we
+      // get proper token annotations.
+      _base.state.restoreFromSnapshot(snapshot);
+      _base.state.scopeDepth++;
+      // Don't specify a context ID because arrow functions don't need a context ID.
+      _statement.parseFunctionParams.call(void 0, );
+      parseArrow();
+      parseArrowExpression(startTokenIndex);
+      if (_base.state.error) {
+        // Nevermind! This must have been something that looks very much like an
+        // arrow function but where its "parameter list" isn't actually a valid
+        // parameter list. Force non-arrow parsing.
+        // See https://github.com/alangpierce/sucrase/issues/666 for an example.
+        _base.state.restoreFromSnapshot(snapshot);
+        parseParenAndDistinguishExpression(false);
+        return false;
+      }
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function shouldParseArrow() {
+  return _index3.match.call(void 0, _types3.TokenType.colon) || !_util.canInsertSemicolon.call(void 0, );
+}
+
+// Returns whether there was an arrow token.
+ function parseArrow() {
+  if (_base.isTypeScriptEnabled) {
+    return _typescript.tsParseArrow.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    return _flow.flowParseArrow.call(void 0, );
+  } else {
+    return _index3.eat.call(void 0, _types3.TokenType.arrow);
+  }
+} exports.parseArrow = parseArrow;
+
+function parseParenItem() {
+  if (_base.isTypeScriptEnabled || _base.isFlowEnabled) {
+    _types.typedParseParenItem.call(void 0, );
+  }
+}
+
+// New's precedence is slightly tricky. It must allow its argument to
+// be a `[]` or dot subscript expression, but not a call — at least,
+// not without wrapping it in parentheses. Thus, it uses the noCalls
+// argument to parseSubscripts to prevent it from consuming the
+// argument list.
+function parseNew() {
+  _util.expect.call(void 0, _types3.TokenType._new);
+  if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
+    // new.target
+    parseIdentifier();
+    return;
+  }
+  parseNewCallee();
+  if (_base.isFlowEnabled) {
+    _flow.flowStartParseNewArguments.call(void 0, );
+  }
+  if (_index3.eat.call(void 0, _types3.TokenType.parenL)) {
+    parseExprList(_types3.TokenType.parenR);
+  }
+}
+
+function parseNewCallee() {
+  parseNoCallExpr();
+  _index3.eat.call(void 0, _types3.TokenType.questionDot);
+}
+
+ function parseTemplate() {
+  // Finish `, read quasi
+  _index3.nextTemplateToken.call(void 0, );
+  // Finish quasi, read ${
+  _index3.nextTemplateToken.call(void 0, );
+  while (!_index3.match.call(void 0, _types3.TokenType.backQuote) && !_base.state.error) {
+    _util.expect.call(void 0, _types3.TokenType.dollarBraceL);
+    parseExpression();
+    // Finish }, read quasi
+    _index3.nextTemplateToken.call(void 0, );
+    // Finish quasi, read either ${ or `
+    _index3.nextTemplateToken.call(void 0, );
+  }
+  _index3.next.call(void 0, );
+} exports.parseTemplate = parseTemplate;
+
+// Parse an object literal or binding pattern.
+ function parseObj(isPattern, isBlockScope) {
+  // Attach a context ID to the object open and close brace and each object key.
+  const contextId = _base.getNextContextId.call(void 0, );
+  let first = true;
+
+  _index3.next.call(void 0, );
+  _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
+
+  while (!_index3.eat.call(void 0, _types3.TokenType.braceR) && !_base.state.error) {
+    if (first) {
+      first = false;
+    } else {
+      _util.expect.call(void 0, _types3.TokenType.comma);
+      if (_index3.eat.call(void 0, _types3.TokenType.braceR)) {
+        break;
+      }
+    }
+
+    let isGenerator = false;
+    if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
+      const previousIndex = _base.state.tokens.length;
+      _lval.parseSpread.call(void 0, );
+      if (isPattern) {
+        // Mark role when the only thing being spread over is an identifier.
+        if (_base.state.tokens.length === previousIndex + 2) {
+          _lval.markPriorBindingIdentifier.call(void 0, isBlockScope);
+        }
+        if (_index3.eat.call(void 0, _types3.TokenType.braceR)) {
+          break;
+        }
+      }
+      continue;
+    }
+
+    if (!isPattern) {
+      isGenerator = _index3.eat.call(void 0, _types3.TokenType.star);
+    }
+
+    if (!isPattern && _util.isContextual.call(void 0, _keywords.ContextualKeyword._async)) {
+      if (isGenerator) _util.unexpected.call(void 0, );
+
+      parseIdentifier();
+      if (
+        _index3.match.call(void 0, _types3.TokenType.colon) ||
+        _index3.match.call(void 0, _types3.TokenType.parenL) ||
+        _index3.match.call(void 0, _types3.TokenType.braceR) ||
+        _index3.match.call(void 0, _types3.TokenType.eq) ||
+        _index3.match.call(void 0, _types3.TokenType.comma)
+      ) {
+        // This is a key called "async" rather than an async function.
+      } else {
+        if (_index3.match.call(void 0, _types3.TokenType.star)) {
+          _index3.next.call(void 0, );
+          isGenerator = true;
+        }
+        parsePropertyName(contextId);
+      }
+    } else {
+      parsePropertyName(contextId);
+    }
+
+    parseObjPropValue(isPattern, isBlockScope, contextId);
+  }
+
+  _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
+} exports.parseObj = parseObj;
+
+function isGetterOrSetterMethod(isPattern) {
+  // We go off of the next and don't bother checking if the node key is actually "get" or "set".
+  // This lets us avoid generating a node, and should only make the validation worse.
+  return (
+    !isPattern &&
+    (_index3.match.call(void 0, _types3.TokenType.string) || // get "string"() {}
+      _index3.match.call(void 0, _types3.TokenType.num) || // get 1() {}
+      _index3.match.call(void 0, _types3.TokenType.bracketL) || // get ["string"]() {}
+      _index3.match.call(void 0, _types3.TokenType.name) || // get foo() {}
+      !!(_base.state.type & _types3.TokenType.IS_KEYWORD)) // get debugger() {}
+  );
+}
+
+// Returns true if this was a method.
+function parseObjectMethod(isPattern, objectContextId) {
+  // We don't need to worry about modifiers because object methods can't have optional bodies, so
+  // the start will never be used.
+  const functionStart = _base.state.start;
+  if (_index3.match.call(void 0, _types3.TokenType.parenL)) {
+    if (isPattern) _util.unexpected.call(void 0, );
+    parseMethod(functionStart, /* isConstructor */ false);
+    return true;
+  }
+
+  if (isGetterOrSetterMethod(isPattern)) {
+    parsePropertyName(objectContextId);
+    parseMethod(functionStart, /* isConstructor */ false);
+    return true;
+  }
+  return false;
+}
+
+function parseObjectProperty(isPattern, isBlockScope) {
+  if (_index3.eat.call(void 0, _types3.TokenType.colon)) {
+    if (isPattern) {
+      _lval.parseMaybeDefault.call(void 0, isBlockScope);
+    } else {
+      parseMaybeAssign(false);
+    }
+    return;
+  }
+
+  // Since there's no colon, we assume this is an object shorthand.
+
+  // If we're in a destructuring, we've now discovered that the key was actually an assignee, so
+  // we need to tag it as a declaration with the appropriate scope. Otherwise, we might need to
+  // transform it on access, so mark it as a normal object shorthand.
+  let identifierRole;
+  if (isPattern) {
+    if (_base.state.scopeDepth === 0) {
+      identifierRole = _index3.IdentifierRole.ObjectShorthandTopLevelDeclaration;
+    } else if (isBlockScope) {
+      identifierRole = _index3.IdentifierRole.ObjectShorthandBlockScopedDeclaration;
+    } else {
+      identifierRole = _index3.IdentifierRole.ObjectShorthandFunctionScopedDeclaration;
+    }
+  } else {
+    identifierRole = _index3.IdentifierRole.ObjectShorthand;
+  }
+  _base.state.tokens[_base.state.tokens.length - 1].identifierRole = identifierRole;
+
+  // Regardless of whether we know this to be a pattern or if we're in an ambiguous context, allow
+  // parsing as if there's a default value.
+  _lval.parseMaybeDefault.call(void 0, isBlockScope, true);
+}
+
+function parseObjPropValue(
+  isPattern,
+  isBlockScope,
+  objectContextId,
+) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsStartParseObjPropValue.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    _flow.flowStartParseObjPropValue.call(void 0, );
+  }
+  const wasMethod = parseObjectMethod(isPattern, objectContextId);
+  if (!wasMethod) {
+    parseObjectProperty(isPattern, isBlockScope);
+  }
+}
+
+ function parsePropertyName(objectContextId) {
+  if (_base.isFlowEnabled) {
+    _flow.flowParseVariance.call(void 0, );
+  }
+  if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
+    _base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
+    parseMaybeAssign();
+    _util.expect.call(void 0, _types3.TokenType.bracketR);
+    _base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
+  } else {
+    if (_index3.match.call(void 0, _types3.TokenType.num) || _index3.match.call(void 0, _types3.TokenType.string) || _index3.match.call(void 0, _types3.TokenType.bigint) || _index3.match.call(void 0, _types3.TokenType.decimal)) {
+      parseExprAtom();
+    } else {
+      parseMaybePrivateName();
+    }
+
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index3.IdentifierRole.ObjectKey;
+    _base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
+  }
+} exports.parsePropertyName = parsePropertyName;
+
+// Parse object or class method.
+ function parseMethod(functionStart, isConstructor) {
+  const funcContextId = _base.getNextContextId.call(void 0, );
+
+  _base.state.scopeDepth++;
+  const startTokenIndex = _base.state.tokens.length;
+  const allowModifiers = isConstructor; // For TypeScript parameter properties
+  _statement.parseFunctionParams.call(void 0, allowModifiers, funcContextId);
+  parseFunctionBodyAndFinish(functionStart, funcContextId);
+  const endTokenIndex = _base.state.tokens.length;
+  _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
+  _base.state.scopeDepth--;
+} exports.parseMethod = parseMethod;
+
+// Parse arrow function expression.
+// If the parameters are provided, they will be converted to an
+// assignable list.
+ function parseArrowExpression(startTokenIndex) {
+  parseFunctionBody(true);
+  const endTokenIndex = _base.state.tokens.length;
+  _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
+  _base.state.scopeDepth--;
+} exports.parseArrowExpression = parseArrowExpression;
+
+ function parseFunctionBodyAndFinish(functionStart, funcContextId = 0) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseFunctionBodyAndFinish.call(void 0, functionStart, funcContextId);
+  } else if (_base.isFlowEnabled) {
+    _flow.flowParseFunctionBodyAndFinish.call(void 0, funcContextId);
+  } else {
+    parseFunctionBody(false, funcContextId);
+  }
+} exports.parseFunctionBodyAndFinish = parseFunctionBodyAndFinish;
+
+ function parseFunctionBody(allowExpression, funcContextId = 0) {
+  const isExpression = allowExpression && !_index3.match.call(void 0, _types3.TokenType.braceL);
+
+  if (isExpression) {
+    parseMaybeAssign();
+  } else {
+    _statement.parseBlock.call(void 0, true /* isFunctionScope */, funcContextId);
+  }
+} exports.parseFunctionBody = parseFunctionBody;
+
+// Parses a comma-separated list of expressions, and returns them as
+// an array. `close` is the token type that ends the list, and
+// `allowEmpty` can be turned on to allow subsequent commas with
+// nothing in between them to be parsed as `null` (which is needed
+// for array literals).
+
+function parseExprList(close, allowEmpty = false) {
+  let first = true;
+  while (!_index3.eat.call(void 0, close) && !_base.state.error) {
+    if (first) {
+      first = false;
+    } else {
+      _util.expect.call(void 0, _types3.TokenType.comma);
+      if (_index3.eat.call(void 0, close)) break;
+    }
+    parseExprListItem(allowEmpty);
+  }
+}
+
+function parseExprListItem(allowEmpty) {
+  if (allowEmpty && _index3.match.call(void 0, _types3.TokenType.comma)) {
+    // Empty item; nothing more to parse for this item.
+  } else if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
+    _lval.parseSpread.call(void 0, );
+    parseParenItem();
+  } else if (_index3.match.call(void 0, _types3.TokenType.question)) {
+    // Partial function application proposal.
+    _index3.next.call(void 0, );
+  } else {
+    parseMaybeAssign(false, true);
+  }
+}
+
+// Parse the next token as an identifier.
+ function parseIdentifier() {
+  _index3.next.call(void 0, );
+  _base.state.tokens[_base.state.tokens.length - 1].type = _types3.TokenType.name;
+} exports.parseIdentifier = parseIdentifier;
+
+// Parses await expression inside async function.
+function parseAwait() {
+  parseMaybeUnary();
+}
+
+// Parses yield expression inside generator.
+function parseYield() {
+  _index3.next.call(void 0, );
+  if (!_index3.match.call(void 0, _types3.TokenType.semi) && !_util.canInsertSemicolon.call(void 0, )) {
+    _index3.eat.call(void 0, _types3.TokenType.star);
+    parseMaybeAssign();
+  }
+}
+
+// https://github.com/tc39/proposal-js-module-blocks
+function parseModuleExpression() {
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._module);
+  _util.expect.call(void 0, _types3.TokenType.braceL);
+  // For now, just call parseBlockBody to parse the block. In the future when we
+  // implement full support, we'll want to emit scopes and possibly other
+  // information.
+  _statement.parseBlockBody.call(void 0, _types3.TokenType.braceR);
+}
diff --git a/node_modules/sucrase/dist/parser/traverser/index.js b/node_modules/sucrase/dist/parser/traverser/index.js
new file mode 100644
index 0000000..72e4130
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/traverser/index.js
@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+var _index = require('../tokenizer/index');
+var _charcodes = require('../util/charcodes');
+var _base = require('./base');
+var _statement = require('./statement');
+
+ function parseFile() {
+  // If enabled, skip leading hashbang line.
+  if (
+    _base.state.pos === 0 &&
+    _base.input.charCodeAt(0) === _charcodes.charCodes.numberSign &&
+    _base.input.charCodeAt(1) === _charcodes.charCodes.exclamationMark
+  ) {
+    _index.skipLineComment.call(void 0, 2);
+  }
+  _index.nextToken.call(void 0, );
+  return _statement.parseTopLevel.call(void 0, );
+} exports.parseFile = parseFile;
diff --git a/node_modules/sucrase/dist/parser/traverser/lval.js b/node_modules/sucrase/dist/parser/traverser/lval.js
new file mode 100644
index 0000000..9057497
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/traverser/lval.js
@@ -0,0 +1,159 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _flow = require('../plugins/flow');
+var _typescript = require('../plugins/typescript');
+
+
+
+
+
+
+
+var _index = require('../tokenizer/index');
+var _keywords = require('../tokenizer/keywords');
+var _types = require('../tokenizer/types');
+var _base = require('./base');
+var _expression = require('./expression');
+var _util = require('./util');
+
+ function parseSpread() {
+  _index.next.call(void 0, );
+  _expression.parseMaybeAssign.call(void 0, false);
+} exports.parseSpread = parseSpread;
+
+ function parseRest(isBlockScope) {
+  _index.next.call(void 0, );
+  parseBindingAtom(isBlockScope);
+} exports.parseRest = parseRest;
+
+ function parseBindingIdentifier(isBlockScope) {
+  _expression.parseIdentifier.call(void 0, );
+  markPriorBindingIdentifier(isBlockScope);
+} exports.parseBindingIdentifier = parseBindingIdentifier;
+
+ function parseImportedIdentifier() {
+  _expression.parseIdentifier.call(void 0, );
+  _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
+} exports.parseImportedIdentifier = parseImportedIdentifier;
+
+ function markPriorBindingIdentifier(isBlockScope) {
+  let identifierRole;
+  if (_base.state.scopeDepth === 0) {
+    identifierRole = _index.IdentifierRole.TopLevelDeclaration;
+  } else if (isBlockScope) {
+    identifierRole = _index.IdentifierRole.BlockScopedDeclaration;
+  } else {
+    identifierRole = _index.IdentifierRole.FunctionScopedDeclaration;
+  }
+  _base.state.tokens[_base.state.tokens.length - 1].identifierRole = identifierRole;
+} exports.markPriorBindingIdentifier = markPriorBindingIdentifier;
+
+// Parses lvalue (assignable) atom.
+ function parseBindingAtom(isBlockScope) {
+  switch (_base.state.type) {
+    case _types.TokenType._this: {
+      // In TypeScript, "this" may be the name of a parameter, so allow it.
+      const oldIsType = _index.pushTypeContext.call(void 0, 0);
+      _index.next.call(void 0, );
+      _index.popTypeContext.call(void 0, oldIsType);
+      return;
+    }
+
+    case _types.TokenType._yield:
+    case _types.TokenType.name: {
+      _base.state.type = _types.TokenType.name;
+      parseBindingIdentifier(isBlockScope);
+      return;
+    }
+
+    case _types.TokenType.bracketL: {
+      _index.next.call(void 0, );
+      parseBindingList(_types.TokenType.bracketR, isBlockScope, true /* allowEmpty */);
+      return;
+    }
+
+    case _types.TokenType.braceL:
+      _expression.parseObj.call(void 0, true, isBlockScope);
+      return;
+
+    default:
+      _util.unexpected.call(void 0, );
+  }
+} exports.parseBindingAtom = parseBindingAtom;
+
+ function parseBindingList(
+  close,
+  isBlockScope,
+  allowEmpty = false,
+  allowModifiers = false,
+  contextId = 0,
+) {
+  let first = true;
+
+  let hasRemovedComma = false;
+  const firstItemTokenIndex = _base.state.tokens.length;
+
+  while (!_index.eat.call(void 0, close) && !_base.state.error) {
+    if (first) {
+      first = false;
+    } else {
+      _util.expect.call(void 0, _types.TokenType.comma);
+      _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
+      // After a "this" type in TypeScript, we need to set the following comma (if any) to also be
+      // a type token so that it will be removed.
+      if (!hasRemovedComma && _base.state.tokens[firstItemTokenIndex].isType) {
+        _base.state.tokens[_base.state.tokens.length - 1].isType = true;
+        hasRemovedComma = true;
+      }
+    }
+    if (allowEmpty && _index.match.call(void 0, _types.TokenType.comma)) {
+      // Empty item; nothing further to parse for this item.
+    } else if (_index.eat.call(void 0, close)) {
+      break;
+    } else if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
+      parseRest(isBlockScope);
+      parseAssignableListItemTypes();
+      // Support rest element trailing commas allowed by TypeScript <2.9.
+      _index.eat.call(void 0, _types.TokenType.comma);
+      _util.expect.call(void 0, close);
+      break;
+    } else {
+      parseAssignableListItem(allowModifiers, isBlockScope);
+    }
+  }
+} exports.parseBindingList = parseBindingList;
+
+function parseAssignableListItem(allowModifiers, isBlockScope) {
+  if (allowModifiers) {
+    _typescript.tsParseModifiers.call(void 0, [
+      _keywords.ContextualKeyword._public,
+      _keywords.ContextualKeyword._protected,
+      _keywords.ContextualKeyword._private,
+      _keywords.ContextualKeyword._readonly,
+      _keywords.ContextualKeyword._override,
+    ]);
+  }
+
+  parseMaybeDefault(isBlockScope);
+  parseAssignableListItemTypes();
+  parseMaybeDefault(isBlockScope, true /* leftAlreadyParsed */);
+}
+
+function parseAssignableListItemTypes() {
+  if (_base.isFlowEnabled) {
+    _flow.flowParseAssignableListItemTypes.call(void 0, );
+  } else if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseAssignableListItemTypes.call(void 0, );
+  }
+}
+
+// Parses assignment pattern around given atom if possible.
+ function parseMaybeDefault(isBlockScope, leftAlreadyParsed = false) {
+  if (!leftAlreadyParsed) {
+    parseBindingAtom(isBlockScope);
+  }
+  if (!_index.eat.call(void 0, _types.TokenType.eq)) {
+    return;
+  }
+  const eqIndex = _base.state.tokens.length - 1;
+  _expression.parseMaybeAssign.call(void 0, );
+  _base.state.tokens[eqIndex].rhsEndIndex = _base.state.tokens.length;
+} exports.parseMaybeDefault = parseMaybeDefault;
diff --git a/node_modules/sucrase/dist/parser/traverser/statement.js b/node_modules/sucrase/dist/parser/traverser/statement.js
new file mode 100644
index 0000000..6be3391
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/traverser/statement.js
@@ -0,0 +1,1332 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});/* eslint max-len: 0 */
+
+var _index = require('../index');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _flow = require('../plugins/flow');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _typescript = require('../plugins/typescript');
+
+
+
+
+
+
+
+
+
+
+
+
+var _tokenizer = require('../tokenizer');
+var _keywords = require('../tokenizer/keywords');
+var _state = require('../tokenizer/state');
+var _types = require('../tokenizer/types');
+var _charcodes = require('../util/charcodes');
+var _base = require('./base');
+
+
+
+
+
+
+
+
+
+
+
+
+var _expression = require('./expression');
+
+
+
+
+
+var _lval = require('./lval');
+
+
+
+
+
+
+
+
+
+
+
+
+var _util = require('./util');
+
+ function parseTopLevel() {
+  parseBlockBody(_types.TokenType.eof);
+  _base.state.scopes.push(new (0, _state.Scope)(0, _base.state.tokens.length, true));
+  if (_base.state.scopeDepth !== 0) {
+    throw new Error(`Invalid scope depth at end of file: ${_base.state.scopeDepth}`);
+  }
+  return new (0, _index.File)(_base.state.tokens, _base.state.scopes);
+} exports.parseTopLevel = parseTopLevel;
+
+// Parse a single statement.
+//
+// If expecting a statement and finding a slash operator, parse a
+// regular expression literal. This is to handle cases like
+// `if (foo) /blah/.exec(foo)`, where looking at the previous token
+// does not help.
+
+ function parseStatement(declaration) {
+  if (_base.isFlowEnabled) {
+    if (_flow.flowTryParseStatement.call(void 0, )) {
+      return;
+    }
+  }
+  if (_tokenizer.match.call(void 0, _types.TokenType.at)) {
+    parseDecorators();
+  }
+  parseStatementContent(declaration);
+} exports.parseStatement = parseStatement;
+
+function parseStatementContent(declaration) {
+  if (_base.isTypeScriptEnabled) {
+    if (_typescript.tsTryParseStatementContent.call(void 0, )) {
+      return;
+    }
+  }
+
+  const starttype = _base.state.type;
+
+  // Most types of statements are recognized by the keyword they
+  // start with. Many are trivial to parse, some require a bit of
+  // complexity.
+
+  switch (starttype) {
+    case _types.TokenType._break:
+    case _types.TokenType._continue:
+      parseBreakContinueStatement();
+      return;
+    case _types.TokenType._debugger:
+      parseDebuggerStatement();
+      return;
+    case _types.TokenType._do:
+      parseDoStatement();
+      return;
+    case _types.TokenType._for:
+      parseForStatement();
+      return;
+    case _types.TokenType._function:
+      if (_tokenizer.lookaheadType.call(void 0, ) === _types.TokenType.dot) break;
+      if (!declaration) _util.unexpected.call(void 0, );
+      parseFunctionStatement();
+      return;
+
+    case _types.TokenType._class:
+      if (!declaration) _util.unexpected.call(void 0, );
+      parseClass(true);
+      return;
+
+    case _types.TokenType._if:
+      parseIfStatement();
+      return;
+    case _types.TokenType._return:
+      parseReturnStatement();
+      return;
+    case _types.TokenType._switch:
+      parseSwitchStatement();
+      return;
+    case _types.TokenType._throw:
+      parseThrowStatement();
+      return;
+    case _types.TokenType._try:
+      parseTryStatement();
+      return;
+
+    case _types.TokenType._let:
+    case _types.TokenType._const:
+      if (!declaration) _util.unexpected.call(void 0, ); // NOTE: falls through to _var
+
+    case _types.TokenType._var:
+      parseVarStatement(starttype !== _types.TokenType._var);
+      return;
+
+    case _types.TokenType._while:
+      parseWhileStatement();
+      return;
+    case _types.TokenType.braceL:
+      parseBlock();
+      return;
+    case _types.TokenType.semi:
+      parseEmptyStatement();
+      return;
+    case _types.TokenType._export:
+    case _types.TokenType._import: {
+      const nextType = _tokenizer.lookaheadType.call(void 0, );
+      if (nextType === _types.TokenType.parenL || nextType === _types.TokenType.dot) {
+        break;
+      }
+      _tokenizer.next.call(void 0, );
+      if (starttype === _types.TokenType._import) {
+        parseImport();
+      } else {
+        parseExport();
+      }
+      return;
+    }
+    case _types.TokenType.name:
+      if (_base.state.contextualKeyword === _keywords.ContextualKeyword._async) {
+        const functionStart = _base.state.start;
+        // peek ahead and see if next token is a function
+        const snapshot = _base.state.snapshot();
+        _tokenizer.next.call(void 0, );
+        if (_tokenizer.match.call(void 0, _types.TokenType._function) && !_util.canInsertSemicolon.call(void 0, )) {
+          _util.expect.call(void 0, _types.TokenType._function);
+          parseFunction(functionStart, true);
+          return;
+        } else {
+          _base.state.restoreFromSnapshot(snapshot);
+        }
+      } else if (
+        _base.state.contextualKeyword === _keywords.ContextualKeyword._using &&
+        !_util.hasFollowingLineBreak.call(void 0, ) &&
+        // Statements like `using[0]` and `using in foo` aren't actual using
+        // declarations.
+        _tokenizer.lookaheadType.call(void 0, ) === _types.TokenType.name
+      ) {
+        parseVarStatement(true);
+        return;
+      } else if (startsAwaitUsing()) {
+        _util.expectContextual.call(void 0, _keywords.ContextualKeyword._await);
+        parseVarStatement(true);
+        return;
+      }
+    default:
+      // Do nothing.
+      break;
+  }
+
+  // If the statement does not start with a statement keyword or a
+  // brace, it's an ExpressionStatement or LabeledStatement. We
+  // simply start parsing an expression, and afterwards, if the
+  // next token is a colon and the expression was a simple
+  // Identifier node, we switch to interpreting it as a label.
+  const initialTokensLength = _base.state.tokens.length;
+  _expression.parseExpression.call(void 0, );
+  let simpleName = null;
+  if (_base.state.tokens.length === initialTokensLength + 1) {
+    const token = _base.state.tokens[_base.state.tokens.length - 1];
+    if (token.type === _types.TokenType.name) {
+      simpleName = token.contextualKeyword;
+    }
+  }
+  if (simpleName == null) {
+    _util.semicolon.call(void 0, );
+    return;
+  }
+  if (_tokenizer.eat.call(void 0, _types.TokenType.colon)) {
+    parseLabeledStatement();
+  } else {
+    // This was an identifier, so we might want to handle flow/typescript-specific cases.
+    parseIdentifierStatement(simpleName);
+  }
+}
+
+/**
+ * Determine if we're positioned at an `await using` declaration.
+ *
+ * Note that this can happen either in place of a regular variable declaration
+ * or in a loop body, and in both places, there are similar-looking cases where
+ * we need to return false.
+ *
+ * Examples returning true:
+ * await using foo = bar();
+ * for (await using a of b) {}
+ *
+ * Examples returning false:
+ * await using
+ * await using + 1
+ * await using instanceof T
+ * for (await using;;) {}
+ *
+ * For now, we early return if we don't see `await`, then do a simple
+ * backtracking-based lookahead for the `using` and identifier tokens. In the
+ * future, this could be optimized with a character-based approach.
+ */
+function startsAwaitUsing() {
+  if (!_util.isContextual.call(void 0, _keywords.ContextualKeyword._await)) {
+    return false;
+  }
+  const snapshot = _base.state.snapshot();
+  // await
+  _tokenizer.next.call(void 0, );
+  if (!_util.isContextual.call(void 0, _keywords.ContextualKeyword._using) || _util.hasPrecedingLineBreak.call(void 0, )) {
+    _base.state.restoreFromSnapshot(snapshot);
+    return false;
+  }
+  // using
+  _tokenizer.next.call(void 0, );
+  if (!_tokenizer.match.call(void 0, _types.TokenType.name) || _util.hasPrecedingLineBreak.call(void 0, )) {
+    _base.state.restoreFromSnapshot(snapshot);
+    return false;
+  }
+  _base.state.restoreFromSnapshot(snapshot);
+  return true;
+}
+
+ function parseDecorators() {
+  while (_tokenizer.match.call(void 0, _types.TokenType.at)) {
+    parseDecorator();
+  }
+} exports.parseDecorators = parseDecorators;
+
+function parseDecorator() {
+  _tokenizer.next.call(void 0, );
+  if (_tokenizer.eat.call(void 0, _types.TokenType.parenL)) {
+    _expression.parseExpression.call(void 0, );
+    _util.expect.call(void 0, _types.TokenType.parenR);
+  } else {
+    _expression.parseIdentifier.call(void 0, );
+    while (_tokenizer.eat.call(void 0, _types.TokenType.dot)) {
+      _expression.parseIdentifier.call(void 0, );
+    }
+    parseMaybeDecoratorArguments();
+  }
+}
+
+function parseMaybeDecoratorArguments() {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseMaybeDecoratorArguments.call(void 0, );
+  } else {
+    baseParseMaybeDecoratorArguments();
+  }
+}
+
+ function baseParseMaybeDecoratorArguments() {
+  if (_tokenizer.eat.call(void 0, _types.TokenType.parenL)) {
+    _expression.parseCallExpressionArguments.call(void 0, );
+  }
+} exports.baseParseMaybeDecoratorArguments = baseParseMaybeDecoratorArguments;
+
+function parseBreakContinueStatement() {
+  _tokenizer.next.call(void 0, );
+  if (!_util.isLineTerminator.call(void 0, )) {
+    _expression.parseIdentifier.call(void 0, );
+    _util.semicolon.call(void 0, );
+  }
+}
+
+function parseDebuggerStatement() {
+  _tokenizer.next.call(void 0, );
+  _util.semicolon.call(void 0, );
+}
+
+function parseDoStatement() {
+  _tokenizer.next.call(void 0, );
+  parseStatement(false);
+  _util.expect.call(void 0, _types.TokenType._while);
+  _expression.parseParenExpression.call(void 0, );
+  _tokenizer.eat.call(void 0, _types.TokenType.semi);
+}
+
+function parseForStatement() {
+  _base.state.scopeDepth++;
+  const startTokenIndex = _base.state.tokens.length;
+  parseAmbiguousForStatement();
+  const endTokenIndex = _base.state.tokens.length;
+  _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, false));
+  _base.state.scopeDepth--;
+}
+
+/**
+ * Determine if this token is a `using` declaration (explicit resource
+ * management) as part of a loop.
+ * https://github.com/tc39/proposal-explicit-resource-management
+ */
+function isUsingInLoop() {
+  if (!_util.isContextual.call(void 0, _keywords.ContextualKeyword._using)) {
+    return false;
+  }
+  // This must be `for (using of`, where `using` is the name of the loop
+  // variable.
+  if (_util.isLookaheadContextual.call(void 0, _keywords.ContextualKeyword._of)) {
+    return false;
+  }
+  return true;
+}
+
+// Disambiguating between a `for` and a `for`/`in` or `for`/`of`
+// loop is non-trivial. Basically, we have to parse the init `var`
+// statement or expression, disallowing the `in` operator (see
+// the second parameter to `parseExpression`), and then check
+// whether the next token is `in` or `of`. When there is no init
+// part (semicolon immediately after the opening parenthesis), it
+// is a regular `for` loop.
+function parseAmbiguousForStatement() {
+  _tokenizer.next.call(void 0, );
+
+  let forAwait = false;
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._await)) {
+    forAwait = true;
+    _tokenizer.next.call(void 0, );
+  }
+  _util.expect.call(void 0, _types.TokenType.parenL);
+
+  if (_tokenizer.match.call(void 0, _types.TokenType.semi)) {
+    if (forAwait) {
+      _util.unexpected.call(void 0, );
+    }
+    parseFor();
+    return;
+  }
+
+  const isAwaitUsing = startsAwaitUsing();
+  if (isAwaitUsing || _tokenizer.match.call(void 0, _types.TokenType._var) || _tokenizer.match.call(void 0, _types.TokenType._let) || _tokenizer.match.call(void 0, _types.TokenType._const) || isUsingInLoop()) {
+    if (isAwaitUsing) {
+      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._await);
+    }
+    _tokenizer.next.call(void 0, );
+    parseVar(true, _base.state.type !== _types.TokenType._var);
+    if (_tokenizer.match.call(void 0, _types.TokenType._in) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._of)) {
+      parseForIn(forAwait);
+      return;
+    }
+    parseFor();
+    return;
+  }
+
+  _expression.parseExpression.call(void 0, true);
+  if (_tokenizer.match.call(void 0, _types.TokenType._in) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._of)) {
+    parseForIn(forAwait);
+    return;
+  }
+  if (forAwait) {
+    _util.unexpected.call(void 0, );
+  }
+  parseFor();
+}
+
+function parseFunctionStatement() {
+  const functionStart = _base.state.start;
+  _tokenizer.next.call(void 0, );
+  parseFunction(functionStart, true);
+}
+
+function parseIfStatement() {
+  _tokenizer.next.call(void 0, );
+  _expression.parseParenExpression.call(void 0, );
+  parseStatement(false);
+  if (_tokenizer.eat.call(void 0, _types.TokenType._else)) {
+    parseStatement(false);
+  }
+}
+
+function parseReturnStatement() {
+  _tokenizer.next.call(void 0, );
+
+  // In `return` (and `break`/`continue`), the keywords with
+  // optional arguments, we eagerly look for a semicolon or the
+  // possibility to insert one.
+
+  if (!_util.isLineTerminator.call(void 0, )) {
+    _expression.parseExpression.call(void 0, );
+    _util.semicolon.call(void 0, );
+  }
+}
+
+function parseSwitchStatement() {
+  _tokenizer.next.call(void 0, );
+  _expression.parseParenExpression.call(void 0, );
+  _base.state.scopeDepth++;
+  const startTokenIndex = _base.state.tokens.length;
+  _util.expect.call(void 0, _types.TokenType.braceL);
+
+  // Don't bother validation; just go through any sequence of cases, defaults, and statements.
+  while (!_tokenizer.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    if (_tokenizer.match.call(void 0, _types.TokenType._case) || _tokenizer.match.call(void 0, _types.TokenType._default)) {
+      const isCase = _tokenizer.match.call(void 0, _types.TokenType._case);
+      _tokenizer.next.call(void 0, );
+      if (isCase) {
+        _expression.parseExpression.call(void 0, );
+      }
+      _util.expect.call(void 0, _types.TokenType.colon);
+    } else {
+      parseStatement(true);
+    }
+  }
+  _tokenizer.next.call(void 0, ); // Closing brace
+  const endTokenIndex = _base.state.tokens.length;
+  _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, false));
+  _base.state.scopeDepth--;
+}
+
+function parseThrowStatement() {
+  _tokenizer.next.call(void 0, );
+  _expression.parseExpression.call(void 0, );
+  _util.semicolon.call(void 0, );
+}
+
+function parseCatchClauseParam() {
+  _lval.parseBindingAtom.call(void 0, true /* isBlockScope */);
+
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsTryParseTypeAnnotation.call(void 0, );
+  }
+}
+
+function parseTryStatement() {
+  _tokenizer.next.call(void 0, );
+
+  parseBlock();
+
+  if (_tokenizer.match.call(void 0, _types.TokenType._catch)) {
+    _tokenizer.next.call(void 0, );
+    let catchBindingStartTokenIndex = null;
+    if (_tokenizer.match.call(void 0, _types.TokenType.parenL)) {
+      _base.state.scopeDepth++;
+      catchBindingStartTokenIndex = _base.state.tokens.length;
+      _util.expect.call(void 0, _types.TokenType.parenL);
+      parseCatchClauseParam();
+      _util.expect.call(void 0, _types.TokenType.parenR);
+    }
+    parseBlock();
+    if (catchBindingStartTokenIndex != null) {
+      // We need a special scope for the catch binding which includes the binding itself and the
+      // catch block.
+      const endTokenIndex = _base.state.tokens.length;
+      _base.state.scopes.push(new (0, _state.Scope)(catchBindingStartTokenIndex, endTokenIndex, false));
+      _base.state.scopeDepth--;
+    }
+  }
+  if (_tokenizer.eat.call(void 0, _types.TokenType._finally)) {
+    parseBlock();
+  }
+}
+
+ function parseVarStatement(isBlockScope) {
+  _tokenizer.next.call(void 0, );
+  parseVar(false, isBlockScope);
+  _util.semicolon.call(void 0, );
+} exports.parseVarStatement = parseVarStatement;
+
+function parseWhileStatement() {
+  _tokenizer.next.call(void 0, );
+  _expression.parseParenExpression.call(void 0, );
+  parseStatement(false);
+}
+
+function parseEmptyStatement() {
+  _tokenizer.next.call(void 0, );
+}
+
+function parseLabeledStatement() {
+  parseStatement(true);
+}
+
+/**
+ * Parse a statement starting with an identifier of the given name. Subclasses match on the name
+ * to handle statements like "declare".
+ */
+function parseIdentifierStatement(contextualKeyword) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseIdentifierStatement.call(void 0, contextualKeyword);
+  } else if (_base.isFlowEnabled) {
+    _flow.flowParseIdentifierStatement.call(void 0, contextualKeyword);
+  } else {
+    _util.semicolon.call(void 0, );
+  }
+}
+
+// Parse a semicolon-enclosed block of statements.
+ function parseBlock(isFunctionScope = false, contextId = 0) {
+  const startTokenIndex = _base.state.tokens.length;
+  _base.state.scopeDepth++;
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  if (contextId) {
+    _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
+  }
+  parseBlockBody(_types.TokenType.braceR);
+  if (contextId) {
+    _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
+  }
+  const endTokenIndex = _base.state.tokens.length;
+  _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, isFunctionScope));
+  _base.state.scopeDepth--;
+} exports.parseBlock = parseBlock;
+
+ function parseBlockBody(end) {
+  while (!_tokenizer.eat.call(void 0, end) && !_base.state.error) {
+    parseStatement(true);
+  }
+} exports.parseBlockBody = parseBlockBody;
+
+// Parse a regular `for` loop. The disambiguation code in
+// `parseStatement` will already have parsed the init statement or
+// expression.
+
+function parseFor() {
+  _util.expect.call(void 0, _types.TokenType.semi);
+  if (!_tokenizer.match.call(void 0, _types.TokenType.semi)) {
+    _expression.parseExpression.call(void 0, );
+  }
+  _util.expect.call(void 0, _types.TokenType.semi);
+  if (!_tokenizer.match.call(void 0, _types.TokenType.parenR)) {
+    _expression.parseExpression.call(void 0, );
+  }
+  _util.expect.call(void 0, _types.TokenType.parenR);
+  parseStatement(false);
+}
+
+// Parse a `for`/`in` and `for`/`of` loop, which are almost
+// same from parser's perspective.
+
+function parseForIn(forAwait) {
+  if (forAwait) {
+    _util.eatContextual.call(void 0, _keywords.ContextualKeyword._of);
+  } else {
+    _tokenizer.next.call(void 0, );
+  }
+  _expression.parseExpression.call(void 0, );
+  _util.expect.call(void 0, _types.TokenType.parenR);
+  parseStatement(false);
+}
+
+// Parse a list of variable declarations.
+
+function parseVar(isFor, isBlockScope) {
+  while (true) {
+    parseVarHead(isBlockScope);
+    if (_tokenizer.eat.call(void 0, _types.TokenType.eq)) {
+      const eqIndex = _base.state.tokens.length - 1;
+      _expression.parseMaybeAssign.call(void 0, isFor);
+      _base.state.tokens[eqIndex].rhsEndIndex = _base.state.tokens.length;
+    }
+    if (!_tokenizer.eat.call(void 0, _types.TokenType.comma)) {
+      break;
+    }
+  }
+}
+
+function parseVarHead(isBlockScope) {
+  _lval.parseBindingAtom.call(void 0, isBlockScope);
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsAfterParseVarHead.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    _flow.flowAfterParseVarHead.call(void 0, );
+  }
+}
+
+// Parse a function declaration or literal (depending on the
+// `isStatement` parameter).
+
+ function parseFunction(
+  functionStart,
+  isStatement,
+  optionalId = false,
+) {
+  if (_tokenizer.match.call(void 0, _types.TokenType.star)) {
+    _tokenizer.next.call(void 0, );
+  }
+
+  if (isStatement && !optionalId && !_tokenizer.match.call(void 0, _types.TokenType.name) && !_tokenizer.match.call(void 0, _types.TokenType._yield)) {
+    _util.unexpected.call(void 0, );
+  }
+
+  let nameScopeStartTokenIndex = null;
+
+  if (_tokenizer.match.call(void 0, _types.TokenType.name)) {
+    // Expression-style functions should limit their name's scope to the function body, so we make
+    // a new function scope to enforce that.
+    if (!isStatement) {
+      nameScopeStartTokenIndex = _base.state.tokens.length;
+      _base.state.scopeDepth++;
+    }
+    _lval.parseBindingIdentifier.call(void 0, false);
+  }
+
+  const startTokenIndex = _base.state.tokens.length;
+  _base.state.scopeDepth++;
+  parseFunctionParams();
+  _expression.parseFunctionBodyAndFinish.call(void 0, functionStart);
+  const endTokenIndex = _base.state.tokens.length;
+  // In addition to the block scope of the function body, we need a separate function-style scope
+  // that includes the params.
+  _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
+  _base.state.scopeDepth--;
+  if (nameScopeStartTokenIndex !== null) {
+    _base.state.scopes.push(new (0, _state.Scope)(nameScopeStartTokenIndex, endTokenIndex, true));
+    _base.state.scopeDepth--;
+  }
+} exports.parseFunction = parseFunction;
+
+ function parseFunctionParams(
+  allowModifiers = false,
+  funcContextId = 0,
+) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsStartParseFunctionParams.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    _flow.flowStartParseFunctionParams.call(void 0, );
+  }
+
+  _util.expect.call(void 0, _types.TokenType.parenL);
+  if (funcContextId) {
+    _base.state.tokens[_base.state.tokens.length - 1].contextId = funcContextId;
+  }
+  _lval.parseBindingList.call(void 0, 
+    _types.TokenType.parenR,
+    false /* isBlockScope */,
+    false /* allowEmpty */,
+    allowModifiers,
+    funcContextId,
+  );
+  if (funcContextId) {
+    _base.state.tokens[_base.state.tokens.length - 1].contextId = funcContextId;
+  }
+} exports.parseFunctionParams = parseFunctionParams;
+
+// Parse a class declaration or literal (depending on the
+// `isStatement` parameter).
+
+ function parseClass(isStatement, optionalId = false) {
+  // Put a context ID on the class keyword, the open-brace, and the close-brace, so that later
+  // code can easily navigate to meaningful points on the class.
+  const contextId = _base.getNextContextId.call(void 0, );
+
+  _tokenizer.next.call(void 0, );
+  _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
+  _base.state.tokens[_base.state.tokens.length - 1].isExpression = !isStatement;
+  // Like with functions, we declare a special "name scope" from the start of the name to the end
+  // of the class, but only with expression-style classes, to represent the fact that the name is
+  // available to the body of the class but not an outer declaration.
+  let nameScopeStartTokenIndex = null;
+  if (!isStatement) {
+    nameScopeStartTokenIndex = _base.state.tokens.length;
+    _base.state.scopeDepth++;
+  }
+  parseClassId(isStatement, optionalId);
+  parseClassSuper();
+  const openBraceIndex = _base.state.tokens.length;
+  parseClassBody(contextId);
+  if (_base.state.error) {
+    return;
+  }
+  _base.state.tokens[openBraceIndex].contextId = contextId;
+  _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
+  if (nameScopeStartTokenIndex !== null) {
+    const endTokenIndex = _base.state.tokens.length;
+    _base.state.scopes.push(new (0, _state.Scope)(nameScopeStartTokenIndex, endTokenIndex, false));
+    _base.state.scopeDepth--;
+  }
+} exports.parseClass = parseClass;
+
+function isClassProperty() {
+  return _tokenizer.match.call(void 0, _types.TokenType.eq) || _tokenizer.match.call(void 0, _types.TokenType.semi) || _tokenizer.match.call(void 0, _types.TokenType.braceR) || _tokenizer.match.call(void 0, _types.TokenType.bang) || _tokenizer.match.call(void 0, _types.TokenType.colon);
+}
+
+function isClassMethod() {
+  return _tokenizer.match.call(void 0, _types.TokenType.parenL) || _tokenizer.match.call(void 0, _types.TokenType.lessThan);
+}
+
+function parseClassBody(classContextId) {
+  _util.expect.call(void 0, _types.TokenType.braceL);
+
+  while (!_tokenizer.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    if (_tokenizer.eat.call(void 0, _types.TokenType.semi)) {
+      continue;
+    }
+
+    if (_tokenizer.match.call(void 0, _types.TokenType.at)) {
+      parseDecorator();
+      continue;
+    }
+    const memberStart = _base.state.start;
+    parseClassMember(memberStart, classContextId);
+  }
+}
+
+function parseClassMember(memberStart, classContextId) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseModifiers.call(void 0, [
+      _keywords.ContextualKeyword._declare,
+      _keywords.ContextualKeyword._public,
+      _keywords.ContextualKeyword._protected,
+      _keywords.ContextualKeyword._private,
+      _keywords.ContextualKeyword._override,
+    ]);
+  }
+  let isStatic = false;
+  if (_tokenizer.match.call(void 0, _types.TokenType.name) && _base.state.contextualKeyword === _keywords.ContextualKeyword._static) {
+    _expression.parseIdentifier.call(void 0, ); // eats 'static'
+    if (isClassMethod()) {
+      parseClassMethod(memberStart, /* isConstructor */ false);
+      return;
+    } else if (isClassProperty()) {
+      parseClassProperty();
+      return;
+    }
+    // otherwise something static
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._static;
+    isStatic = true;
+
+    if (_tokenizer.match.call(void 0, _types.TokenType.braceL)) {
+      // This is a static block. Mark the word "static" with the class context ID for class element
+      // detection and parse as a regular block.
+      _base.state.tokens[_base.state.tokens.length - 1].contextId = classContextId;
+      parseBlock();
+      return;
+    }
+  }
+
+  parseClassMemberWithIsStatic(memberStart, isStatic, classContextId);
+}
+
+function parseClassMemberWithIsStatic(
+  memberStart,
+  isStatic,
+  classContextId,
+) {
+  if (_base.isTypeScriptEnabled) {
+    if (_typescript.tsTryParseClassMemberWithIsStatic.call(void 0, isStatic)) {
+      return;
+    }
+  }
+  if (_tokenizer.eat.call(void 0, _types.TokenType.star)) {
+    // a generator
+    parseClassPropertyName(classContextId);
+    parseClassMethod(memberStart, /* isConstructor */ false);
+    return;
+  }
+
+  // Get the identifier name so we can tell if it's actually a keyword like "async", "get", or
+  // "set".
+  parseClassPropertyName(classContextId);
+  let isConstructor = false;
+  const token = _base.state.tokens[_base.state.tokens.length - 1];
+  // We allow "constructor" as either an identifier or a string.
+  if (token.contextualKeyword === _keywords.ContextualKeyword._constructor) {
+    isConstructor = true;
+  }
+  parsePostMemberNameModifiers();
+
+  if (isClassMethod()) {
+    parseClassMethod(memberStart, isConstructor);
+  } else if (isClassProperty()) {
+    parseClassProperty();
+  } else if (token.contextualKeyword === _keywords.ContextualKeyword._async && !_util.isLineTerminator.call(void 0, )) {
+    _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._async;
+    // an async method
+    const isGenerator = _tokenizer.match.call(void 0, _types.TokenType.star);
+    if (isGenerator) {
+      _tokenizer.next.call(void 0, );
+    }
+
+    // The so-called parsed name would have been "async": get the real name.
+    parseClassPropertyName(classContextId);
+    parsePostMemberNameModifiers();
+    parseClassMethod(memberStart, false /* isConstructor */);
+  } else if (
+    (token.contextualKeyword === _keywords.ContextualKeyword._get ||
+      token.contextualKeyword === _keywords.ContextualKeyword._set) &&
+    !(_util.isLineTerminator.call(void 0, ) && _tokenizer.match.call(void 0, _types.TokenType.star))
+  ) {
+    if (token.contextualKeyword === _keywords.ContextualKeyword._get) {
+      _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._get;
+    } else {
+      _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._set;
+    }
+    // `get\n*` is an uninitialized property named 'get' followed by a generator.
+    // a getter or setter
+    // The so-called parsed name would have been "get/set": get the real name.
+    parseClassPropertyName(classContextId);
+    parseClassMethod(memberStart, /* isConstructor */ false);
+  } else if (token.contextualKeyword === _keywords.ContextualKeyword._accessor && !_util.isLineTerminator.call(void 0, )) {
+    parseClassPropertyName(classContextId);
+    parseClassProperty();
+  } else if (_util.isLineTerminator.call(void 0, )) {
+    // an uninitialized class property (due to ASI, since we don't otherwise recognize the next token)
+    parseClassProperty();
+  } else {
+    _util.unexpected.call(void 0, );
+  }
+}
+
+function parseClassMethod(functionStart, isConstructor) {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsTryParseTypeParameters.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    if (_tokenizer.match.call(void 0, _types.TokenType.lessThan)) {
+      _flow.flowParseTypeParameterDeclaration.call(void 0, );
+    }
+  }
+  _expression.parseMethod.call(void 0, functionStart, isConstructor);
+}
+
+// Return the name of the class property, if it is a simple identifier.
+ function parseClassPropertyName(classContextId) {
+  _expression.parsePropertyName.call(void 0, classContextId);
+} exports.parseClassPropertyName = parseClassPropertyName;
+
+ function parsePostMemberNameModifiers() {
+  if (_base.isTypeScriptEnabled) {
+    const oldIsType = _tokenizer.pushTypeContext.call(void 0, 0);
+    _tokenizer.eat.call(void 0, _types.TokenType.question);
+    _tokenizer.popTypeContext.call(void 0, oldIsType);
+  }
+} exports.parsePostMemberNameModifiers = parsePostMemberNameModifiers;
+
+ function parseClassProperty() {
+  if (_base.isTypeScriptEnabled) {
+    _tokenizer.eatTypeToken.call(void 0, _types.TokenType.bang);
+    _typescript.tsTryParseTypeAnnotation.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    if (_tokenizer.match.call(void 0, _types.TokenType.colon)) {
+      _flow.flowParseTypeAnnotation.call(void 0, );
+    }
+  }
+
+  if (_tokenizer.match.call(void 0, _types.TokenType.eq)) {
+    const equalsTokenIndex = _base.state.tokens.length;
+    _tokenizer.next.call(void 0, );
+    _expression.parseMaybeAssign.call(void 0, );
+    _base.state.tokens[equalsTokenIndex].rhsEndIndex = _base.state.tokens.length;
+  }
+  _util.semicolon.call(void 0, );
+} exports.parseClassProperty = parseClassProperty;
+
+function parseClassId(isStatement, optionalId = false) {
+  if (
+    _base.isTypeScriptEnabled &&
+    (!isStatement || optionalId) &&
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)
+  ) {
+    return;
+  }
+
+  if (_tokenizer.match.call(void 0, _types.TokenType.name)) {
+    _lval.parseBindingIdentifier.call(void 0, true);
+  }
+
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsTryParseTypeParameters.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    if (_tokenizer.match.call(void 0, _types.TokenType.lessThan)) {
+      _flow.flowParseTypeParameterDeclaration.call(void 0, );
+    }
+  }
+}
+
+// Returns true if there was a superclass.
+function parseClassSuper() {
+  let hasSuper = false;
+  if (_tokenizer.eat.call(void 0, _types.TokenType._extends)) {
+    _expression.parseExprSubscripts.call(void 0, );
+    hasSuper = true;
+  } else {
+    hasSuper = false;
+  }
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsAfterParseClassSuper.call(void 0, hasSuper);
+  } else if (_base.isFlowEnabled) {
+    _flow.flowAfterParseClassSuper.call(void 0, hasSuper);
+  }
+}
+
+// Parses module export declaration.
+
+ function parseExport() {
+  const exportIndex = _base.state.tokens.length - 1;
+  if (_base.isTypeScriptEnabled) {
+    if (_typescript.tsTryParseExport.call(void 0, )) {
+      return;
+    }
+  }
+  // export * from '...'
+  if (shouldParseExportStar()) {
+    parseExportStar();
+  } else if (isExportDefaultSpecifier()) {
+    // export default from
+    _expression.parseIdentifier.call(void 0, );
+    if (_tokenizer.match.call(void 0, _types.TokenType.comma) && _tokenizer.lookaheadType.call(void 0, ) === _types.TokenType.star) {
+      _util.expect.call(void 0, _types.TokenType.comma);
+      _util.expect.call(void 0, _types.TokenType.star);
+      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._as);
+      _expression.parseIdentifier.call(void 0, );
+    } else {
+      parseExportSpecifiersMaybe();
+    }
+    parseExportFrom();
+  } else if (_tokenizer.eat.call(void 0, _types.TokenType._default)) {
+    // export default ...
+    parseExportDefaultExpression();
+  } else if (shouldParseExportDeclaration()) {
+    parseExportDeclaration();
+  } else {
+    // export { x, y as z } [from '...']
+    parseExportSpecifiers();
+    parseExportFrom();
+  }
+  _base.state.tokens[exportIndex].rhsEndIndex = _base.state.tokens.length;
+} exports.parseExport = parseExport;
+
+function parseExportDefaultExpression() {
+  if (_base.isTypeScriptEnabled) {
+    if (_typescript.tsTryParseExportDefaultExpression.call(void 0, )) {
+      return;
+    }
+  }
+  if (_base.isFlowEnabled) {
+    if (_flow.flowTryParseExportDefaultExpression.call(void 0, )) {
+      return;
+    }
+  }
+  const functionStart = _base.state.start;
+  if (_tokenizer.eat.call(void 0, _types.TokenType._function)) {
+    parseFunction(functionStart, true, true);
+  } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._async) && _tokenizer.lookaheadType.call(void 0, ) === _types.TokenType._function) {
+    // async function declaration
+    _util.eatContextual.call(void 0, _keywords.ContextualKeyword._async);
+    _tokenizer.eat.call(void 0, _types.TokenType._function);
+    parseFunction(functionStart, true, true);
+  } else if (_tokenizer.match.call(void 0, _types.TokenType._class)) {
+    parseClass(true, true);
+  } else if (_tokenizer.match.call(void 0, _types.TokenType.at)) {
+    parseDecorators();
+    parseClass(true, true);
+  } else {
+    _expression.parseMaybeAssign.call(void 0, );
+    _util.semicolon.call(void 0, );
+  }
+}
+
+function parseExportDeclaration() {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseExportDeclaration.call(void 0, );
+  } else if (_base.isFlowEnabled) {
+    _flow.flowParseExportDeclaration.call(void 0, );
+  } else {
+    parseStatement(true);
+  }
+}
+
+function isExportDefaultSpecifier() {
+  if (_base.isTypeScriptEnabled && _typescript.tsIsDeclarationStart.call(void 0, )) {
+    return false;
+  } else if (_base.isFlowEnabled && _flow.flowShouldDisallowExportDefaultSpecifier.call(void 0, )) {
+    return false;
+  }
+  if (_tokenizer.match.call(void 0, _types.TokenType.name)) {
+    return _base.state.contextualKeyword !== _keywords.ContextualKeyword._async;
+  }
+
+  if (!_tokenizer.match.call(void 0, _types.TokenType._default)) {
+    return false;
+  }
+
+  const _next = _tokenizer.nextTokenStart.call(void 0, );
+  const lookahead = _tokenizer.lookaheadTypeAndKeyword.call(void 0, );
+  const hasFrom =
+    lookahead.type === _types.TokenType.name && lookahead.contextualKeyword === _keywords.ContextualKeyword._from;
+  if (lookahead.type === _types.TokenType.comma) {
+    return true;
+  }
+  // lookahead again when `export default from` is seen
+  if (hasFrom) {
+    const nextAfterFrom = _base.input.charCodeAt(_tokenizer.nextTokenStartSince.call(void 0, _next + 4));
+    return nextAfterFrom === _charcodes.charCodes.quotationMark || nextAfterFrom === _charcodes.charCodes.apostrophe;
+  }
+  return false;
+}
+
+function parseExportSpecifiersMaybe() {
+  if (_tokenizer.eat.call(void 0, _types.TokenType.comma)) {
+    parseExportSpecifiers();
+  }
+}
+
+ function parseExportFrom() {
+  if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._from)) {
+    _expression.parseExprAtom.call(void 0, );
+    maybeParseImportAttributes();
+  }
+  _util.semicolon.call(void 0, );
+} exports.parseExportFrom = parseExportFrom;
+
+function shouldParseExportStar() {
+  if (_base.isFlowEnabled) {
+    return _flow.flowShouldParseExportStar.call(void 0, );
+  } else {
+    return _tokenizer.match.call(void 0, _types.TokenType.star);
+  }
+}
+
+function parseExportStar() {
+  if (_base.isFlowEnabled) {
+    _flow.flowParseExportStar.call(void 0, );
+  } else {
+    baseParseExportStar();
+  }
+}
+
+ function baseParseExportStar() {
+  _util.expect.call(void 0, _types.TokenType.star);
+
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._as)) {
+    parseExportNamespace();
+  } else {
+    parseExportFrom();
+  }
+} exports.baseParseExportStar = baseParseExportStar;
+
+function parseExportNamespace() {
+  _tokenizer.next.call(void 0, );
+  _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._as;
+  _expression.parseIdentifier.call(void 0, );
+  parseExportSpecifiersMaybe();
+  parseExportFrom();
+}
+
+function shouldParseExportDeclaration() {
+  return (
+    (_base.isTypeScriptEnabled && _typescript.tsIsDeclarationStart.call(void 0, )) ||
+    (_base.isFlowEnabled && _flow.flowShouldParseExportDeclaration.call(void 0, )) ||
+    _base.state.type === _types.TokenType._var ||
+    _base.state.type === _types.TokenType._const ||
+    _base.state.type === _types.TokenType._let ||
+    _base.state.type === _types.TokenType._function ||
+    _base.state.type === _types.TokenType._class ||
+    _util.isContextual.call(void 0, _keywords.ContextualKeyword._async) ||
+    _tokenizer.match.call(void 0, _types.TokenType.at)
+  );
+}
+
+// Parses a comma-separated list of module exports.
+ function parseExportSpecifiers() {
+  let first = true;
+
+  // export { x, y as z } [from '...']
+  _util.expect.call(void 0, _types.TokenType.braceL);
+
+  while (!_tokenizer.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    if (first) {
+      first = false;
+    } else {
+      _util.expect.call(void 0, _types.TokenType.comma);
+      if (_tokenizer.eat.call(void 0, _types.TokenType.braceR)) {
+        break;
+      }
+    }
+    parseExportSpecifier();
+  }
+} exports.parseExportSpecifiers = parseExportSpecifiers;
+
+function parseExportSpecifier() {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseExportSpecifier.call(void 0, );
+    return;
+  }
+  _expression.parseIdentifier.call(void 0, );
+  _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _tokenizer.IdentifierRole.ExportAccess;
+  if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
+    _expression.parseIdentifier.call(void 0, );
+  }
+}
+
+/**
+ * Starting at the `module` token in an import, determine if it was truly an
+ * import reflection token or just looks like one.
+ *
+ * Returns true for:
+ * import module foo from "foo";
+ * import module from from "foo";
+ *
+ * Returns false for:
+ * import module from "foo";
+ * import module, {bar} from "foo";
+ */
+function isImportReflection() {
+  const snapshot = _base.state.snapshot();
+  _util.expectContextual.call(void 0, _keywords.ContextualKeyword._module);
+  if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._from)) {
+    if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._from)) {
+      _base.state.restoreFromSnapshot(snapshot);
+      return true;
+    } else {
+      _base.state.restoreFromSnapshot(snapshot);
+      return false;
+    }
+  } else if (_tokenizer.match.call(void 0, _types.TokenType.comma)) {
+    _base.state.restoreFromSnapshot(snapshot);
+    return false;
+  } else {
+    _base.state.restoreFromSnapshot(snapshot);
+    return true;
+  }
+}
+
+/**
+ * Eat the "module" token from the import reflection proposal.
+ * https://github.com/tc39/proposal-import-reflection
+ */
+function parseMaybeImportReflection() {
+  // isImportReflection does snapshot/restore, so only run it if we see the word
+  // "module".
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._module) && isImportReflection()) {
+    _tokenizer.next.call(void 0, );
+  }
+}
+
+// Parses import declaration.
+
+ function parseImport() {
+  if (_base.isTypeScriptEnabled && _tokenizer.match.call(void 0, _types.TokenType.name) && _tokenizer.lookaheadType.call(void 0, ) === _types.TokenType.eq) {
+    _typescript.tsParseImportEqualsDeclaration.call(void 0, );
+    return;
+  }
+  if (_base.isTypeScriptEnabled && _util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
+    const lookahead = _tokenizer.lookaheadTypeAndKeyword.call(void 0, );
+    if (lookahead.type === _types.TokenType.name && lookahead.contextualKeyword !== _keywords.ContextualKeyword._from) {
+      // One of these `import type` cases:
+      // import type T = require('T');
+      // import type A from 'A';
+      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
+      if (_tokenizer.lookaheadType.call(void 0, ) === _types.TokenType.eq) {
+        _typescript.tsParseImportEqualsDeclaration.call(void 0, );
+        return;
+      }
+      // If this is an `import type...from` statement, then we already ate the
+      // type token, so proceed to the regular import parser.
+    } else if (lookahead.type === _types.TokenType.star || lookahead.type === _types.TokenType.braceL) {
+      // One of these `import type` cases, in which case we can eat the type token
+      // and proceed as normal:
+      // import type * as A from 'A';
+      // import type {a} from 'A';
+      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
+    }
+    // Otherwise, we are importing the name "type".
+  }
+
+  // import '...'
+  if (_tokenizer.match.call(void 0, _types.TokenType.string)) {
+    _expression.parseExprAtom.call(void 0, );
+  } else {
+    parseMaybeImportReflection();
+    parseImportSpecifiers();
+    _util.expectContextual.call(void 0, _keywords.ContextualKeyword._from);
+    _expression.parseExprAtom.call(void 0, );
+  }
+  maybeParseImportAttributes();
+  _util.semicolon.call(void 0, );
+} exports.parseImport = parseImport;
+
+// eslint-disable-next-line no-unused-vars
+function shouldParseDefaultImport() {
+  return _tokenizer.match.call(void 0, _types.TokenType.name);
+}
+
+function parseImportSpecifierLocal() {
+  _lval.parseImportedIdentifier.call(void 0, );
+}
+
+// Parses a comma-separated list of module imports.
+function parseImportSpecifiers() {
+  if (_base.isFlowEnabled) {
+    _flow.flowStartParseImportSpecifiers.call(void 0, );
+  }
+
+  let first = true;
+  if (shouldParseDefaultImport()) {
+    // import defaultObj, { x, y as z } from '...'
+    parseImportSpecifierLocal();
+
+    if (!_tokenizer.eat.call(void 0, _types.TokenType.comma)) return;
+  }
+
+  if (_tokenizer.match.call(void 0, _types.TokenType.star)) {
+    _tokenizer.next.call(void 0, );
+    _util.expectContextual.call(void 0, _keywords.ContextualKeyword._as);
+
+    parseImportSpecifierLocal();
+
+    return;
+  }
+
+  _util.expect.call(void 0, _types.TokenType.braceL);
+  while (!_tokenizer.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
+    if (first) {
+      first = false;
+    } else {
+      // Detect an attempt to deep destructure
+      if (_tokenizer.eat.call(void 0, _types.TokenType.colon)) {
+        _util.unexpected.call(void 0, 
+          "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
+        );
+      }
+
+      _util.expect.call(void 0, _types.TokenType.comma);
+      if (_tokenizer.eat.call(void 0, _types.TokenType.braceR)) {
+        break;
+      }
+    }
+
+    parseImportSpecifier();
+  }
+}
+
+function parseImportSpecifier() {
+  if (_base.isTypeScriptEnabled) {
+    _typescript.tsParseImportSpecifier.call(void 0, );
+    return;
+  }
+  if (_base.isFlowEnabled) {
+    _flow.flowParseImportSpecifier.call(void 0, );
+    return;
+  }
+  _lval.parseImportedIdentifier.call(void 0, );
+  if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._as)) {
+    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _tokenizer.IdentifierRole.ImportAccess;
+    _tokenizer.next.call(void 0, );
+    _lval.parseImportedIdentifier.call(void 0, );
+  }
+}
+
+/**
+ * Parse import attributes like `with {type: "json"}`, or the legacy form
+ * `assert {type: "json"}`.
+ *
+ * Import attributes technically have their own syntax, but are always parseable
+ * as a plain JS object, so just do that for simplicity.
+ */
+function maybeParseImportAttributes() {
+  if (_tokenizer.match.call(void 0, _types.TokenType._with) || (_util.isContextual.call(void 0, _keywords.ContextualKeyword._assert) && !_util.hasPrecedingLineBreak.call(void 0, ))) {
+    _tokenizer.next.call(void 0, );
+    _expression.parseObj.call(void 0, false, false);
+  }
+}
diff --git a/node_modules/sucrase/dist/parser/traverser/util.js b/node_modules/sucrase/dist/parser/traverser/util.js
new file mode 100644
index 0000000..8ade800
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/traverser/util.js
@@ -0,0 +1,104 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _index = require('../tokenizer/index');
+
+var _types = require('../tokenizer/types');
+var _charcodes = require('../util/charcodes');
+var _base = require('./base');
+
+// ## Parser utilities
+
+// Tests whether parsed token is a contextual keyword.
+ function isContextual(contextualKeyword) {
+  return _base.state.contextualKeyword === contextualKeyword;
+} exports.isContextual = isContextual;
+
+ function isLookaheadContextual(contextualKeyword) {
+  const l = _index.lookaheadTypeAndKeyword.call(void 0, );
+  return l.type === _types.TokenType.name && l.contextualKeyword === contextualKeyword;
+} exports.isLookaheadContextual = isLookaheadContextual;
+
+// Consumes contextual keyword if possible.
+ function eatContextual(contextualKeyword) {
+  return _base.state.contextualKeyword === contextualKeyword && _index.eat.call(void 0, _types.TokenType.name);
+} exports.eatContextual = eatContextual;
+
+// Asserts that following token is given contextual keyword.
+ function expectContextual(contextualKeyword) {
+  if (!eatContextual(contextualKeyword)) {
+    unexpected();
+  }
+} exports.expectContextual = expectContextual;
+
+// Test whether a semicolon can be inserted at the current position.
+ function canInsertSemicolon() {
+  return _index.match.call(void 0, _types.TokenType.eof) || _index.match.call(void 0, _types.TokenType.braceR) || hasPrecedingLineBreak();
+} exports.canInsertSemicolon = canInsertSemicolon;
+
+ function hasPrecedingLineBreak() {
+  const prevToken = _base.state.tokens[_base.state.tokens.length - 1];
+  const lastTokEnd = prevToken ? prevToken.end : 0;
+  for (let i = lastTokEnd; i < _base.state.start; i++) {
+    const code = _base.input.charCodeAt(i);
+    if (
+      code === _charcodes.charCodes.lineFeed ||
+      code === _charcodes.charCodes.carriageReturn ||
+      code === 0x2028 ||
+      code === 0x2029
+    ) {
+      return true;
+    }
+  }
+  return false;
+} exports.hasPrecedingLineBreak = hasPrecedingLineBreak;
+
+ function hasFollowingLineBreak() {
+  const nextStart = _index.nextTokenStart.call(void 0, );
+  for (let i = _base.state.end; i < nextStart; i++) {
+    const code = _base.input.charCodeAt(i);
+    if (
+      code === _charcodes.charCodes.lineFeed ||
+      code === _charcodes.charCodes.carriageReturn ||
+      code === 0x2028 ||
+      code === 0x2029
+    ) {
+      return true;
+    }
+  }
+  return false;
+} exports.hasFollowingLineBreak = hasFollowingLineBreak;
+
+ function isLineTerminator() {
+  return _index.eat.call(void 0, _types.TokenType.semi) || canInsertSemicolon();
+} exports.isLineTerminator = isLineTerminator;
+
+// Consume a semicolon, or, failing that, see if we are allowed to
+// pretend that there is a semicolon at this position.
+ function semicolon() {
+  if (!isLineTerminator()) {
+    unexpected('Unexpected token, expected ";"');
+  }
+} exports.semicolon = semicolon;
+
+// Expect a token of a given type. If found, consume it, otherwise,
+// raise an unexpected token error at given pos.
+ function expect(type) {
+  const matched = _index.eat.call(void 0, type);
+  if (!matched) {
+    unexpected(`Unexpected token, expected "${_types.formatTokenType.call(void 0, type)}"`);
+  }
+} exports.expect = expect;
+
+/**
+ * Transition the parser to an error state. All code needs to be written to naturally unwind in this
+ * state, which allows us to backtrack without exceptions and without error plumbing everywhere.
+ */
+ function unexpected(message = "Unexpected token", pos = _base.state.start) {
+  if (_base.state.error) {
+    return;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const err = new SyntaxError(message);
+  err.pos = pos;
+  _base.state.error = err;
+  _base.state.pos = _base.input.length;
+  _index.finishToken.call(void 0, _types.TokenType.eof);
+} exports.unexpected = unexpected;
diff --git a/node_modules/sucrase/dist/parser/util/charcodes.js b/node_modules/sucrase/dist/parser/util/charcodes.js
new file mode 100644
index 0000000..52bebc4
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/util/charcodes.js
@@ -0,0 +1,115 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var charCodes; (function (charCodes) {
+  const backSpace = 8; charCodes[charCodes["backSpace"] = backSpace] = "backSpace";
+  const lineFeed = 10; charCodes[charCodes["lineFeed"] = lineFeed] = "lineFeed"; //  '\n'
+  const tab = 9; charCodes[charCodes["tab"] = tab] = "tab"; //  '\t'
+  const carriageReturn = 13; charCodes[charCodes["carriageReturn"] = carriageReturn] = "carriageReturn"; //  '\r'
+  const shiftOut = 14; charCodes[charCodes["shiftOut"] = shiftOut] = "shiftOut";
+  const space = 32; charCodes[charCodes["space"] = space] = "space";
+  const exclamationMark = 33; charCodes[charCodes["exclamationMark"] = exclamationMark] = "exclamationMark"; //  '!'
+  const quotationMark = 34; charCodes[charCodes["quotationMark"] = quotationMark] = "quotationMark"; //  '"'
+  const numberSign = 35; charCodes[charCodes["numberSign"] = numberSign] = "numberSign"; //  '#'
+  const dollarSign = 36; charCodes[charCodes["dollarSign"] = dollarSign] = "dollarSign"; //  '$'
+  const percentSign = 37; charCodes[charCodes["percentSign"] = percentSign] = "percentSign"; //  '%'
+  const ampersand = 38; charCodes[charCodes["ampersand"] = ampersand] = "ampersand"; //  '&'
+  const apostrophe = 39; charCodes[charCodes["apostrophe"] = apostrophe] = "apostrophe"; //  '''
+  const leftParenthesis = 40; charCodes[charCodes["leftParenthesis"] = leftParenthesis] = "leftParenthesis"; //  '('
+  const rightParenthesis = 41; charCodes[charCodes["rightParenthesis"] = rightParenthesis] = "rightParenthesis"; //  ')'
+  const asterisk = 42; charCodes[charCodes["asterisk"] = asterisk] = "asterisk"; //  '*'
+  const plusSign = 43; charCodes[charCodes["plusSign"] = plusSign] = "plusSign"; //  '+'
+  const comma = 44; charCodes[charCodes["comma"] = comma] = "comma"; //  ','
+  const dash = 45; charCodes[charCodes["dash"] = dash] = "dash"; //  '-'
+  const dot = 46; charCodes[charCodes["dot"] = dot] = "dot"; //  '.'
+  const slash = 47; charCodes[charCodes["slash"] = slash] = "slash"; //  '/'
+  const digit0 = 48; charCodes[charCodes["digit0"] = digit0] = "digit0"; //  '0'
+  const digit1 = 49; charCodes[charCodes["digit1"] = digit1] = "digit1"; //  '1'
+  const digit2 = 50; charCodes[charCodes["digit2"] = digit2] = "digit2"; //  '2'
+  const digit3 = 51; charCodes[charCodes["digit3"] = digit3] = "digit3"; //  '3'
+  const digit4 = 52; charCodes[charCodes["digit4"] = digit4] = "digit4"; //  '4'
+  const digit5 = 53; charCodes[charCodes["digit5"] = digit5] = "digit5"; //  '5'
+  const digit6 = 54; charCodes[charCodes["digit6"] = digit6] = "digit6"; //  '6'
+  const digit7 = 55; charCodes[charCodes["digit7"] = digit7] = "digit7"; //  '7'
+  const digit8 = 56; charCodes[charCodes["digit8"] = digit8] = "digit8"; //  '8'
+  const digit9 = 57; charCodes[charCodes["digit9"] = digit9] = "digit9"; //  '9'
+  const colon = 58; charCodes[charCodes["colon"] = colon] = "colon"; //  ':'
+  const semicolon = 59; charCodes[charCodes["semicolon"] = semicolon] = "semicolon"; //  ';'
+  const lessThan = 60; charCodes[charCodes["lessThan"] = lessThan] = "lessThan"; //  '<'
+  const equalsTo = 61; charCodes[charCodes["equalsTo"] = equalsTo] = "equalsTo"; //  '='
+  const greaterThan = 62; charCodes[charCodes["greaterThan"] = greaterThan] = "greaterThan"; //  '>'
+  const questionMark = 63; charCodes[charCodes["questionMark"] = questionMark] = "questionMark"; //  '?'
+  const atSign = 64; charCodes[charCodes["atSign"] = atSign] = "atSign"; //  '@'
+  const uppercaseA = 65; charCodes[charCodes["uppercaseA"] = uppercaseA] = "uppercaseA"; //  'A'
+  const uppercaseB = 66; charCodes[charCodes["uppercaseB"] = uppercaseB] = "uppercaseB"; //  'B'
+  const uppercaseC = 67; charCodes[charCodes["uppercaseC"] = uppercaseC] = "uppercaseC"; //  'C'
+  const uppercaseD = 68; charCodes[charCodes["uppercaseD"] = uppercaseD] = "uppercaseD"; //  'D'
+  const uppercaseE = 69; charCodes[charCodes["uppercaseE"] = uppercaseE] = "uppercaseE"; //  'E'
+  const uppercaseF = 70; charCodes[charCodes["uppercaseF"] = uppercaseF] = "uppercaseF"; //  'F'
+  const uppercaseG = 71; charCodes[charCodes["uppercaseG"] = uppercaseG] = "uppercaseG"; //  'G'
+  const uppercaseH = 72; charCodes[charCodes["uppercaseH"] = uppercaseH] = "uppercaseH"; //  'H'
+  const uppercaseI = 73; charCodes[charCodes["uppercaseI"] = uppercaseI] = "uppercaseI"; //  'I'
+  const uppercaseJ = 74; charCodes[charCodes["uppercaseJ"] = uppercaseJ] = "uppercaseJ"; //  'J'
+  const uppercaseK = 75; charCodes[charCodes["uppercaseK"] = uppercaseK] = "uppercaseK"; //  'K'
+  const uppercaseL = 76; charCodes[charCodes["uppercaseL"] = uppercaseL] = "uppercaseL"; //  'L'
+  const uppercaseM = 77; charCodes[charCodes["uppercaseM"] = uppercaseM] = "uppercaseM"; //  'M'
+  const uppercaseN = 78; charCodes[charCodes["uppercaseN"] = uppercaseN] = "uppercaseN"; //  'N'
+  const uppercaseO = 79; charCodes[charCodes["uppercaseO"] = uppercaseO] = "uppercaseO"; //  'O'
+  const uppercaseP = 80; charCodes[charCodes["uppercaseP"] = uppercaseP] = "uppercaseP"; //  'P'
+  const uppercaseQ = 81; charCodes[charCodes["uppercaseQ"] = uppercaseQ] = "uppercaseQ"; //  'Q'
+  const uppercaseR = 82; charCodes[charCodes["uppercaseR"] = uppercaseR] = "uppercaseR"; //  'R'
+  const uppercaseS = 83; charCodes[charCodes["uppercaseS"] = uppercaseS] = "uppercaseS"; //  'S'
+  const uppercaseT = 84; charCodes[charCodes["uppercaseT"] = uppercaseT] = "uppercaseT"; //  'T'
+  const uppercaseU = 85; charCodes[charCodes["uppercaseU"] = uppercaseU] = "uppercaseU"; //  'U'
+  const uppercaseV = 86; charCodes[charCodes["uppercaseV"] = uppercaseV] = "uppercaseV"; //  'V'
+  const uppercaseW = 87; charCodes[charCodes["uppercaseW"] = uppercaseW] = "uppercaseW"; //  'W'
+  const uppercaseX = 88; charCodes[charCodes["uppercaseX"] = uppercaseX] = "uppercaseX"; //  'X'
+  const uppercaseY = 89; charCodes[charCodes["uppercaseY"] = uppercaseY] = "uppercaseY"; //  'Y'
+  const uppercaseZ = 90; charCodes[charCodes["uppercaseZ"] = uppercaseZ] = "uppercaseZ"; //  'Z'
+  const leftSquareBracket = 91; charCodes[charCodes["leftSquareBracket"] = leftSquareBracket] = "leftSquareBracket"; //  '['
+  const backslash = 92; charCodes[charCodes["backslash"] = backslash] = "backslash"; //  '\    '
+  const rightSquareBracket = 93; charCodes[charCodes["rightSquareBracket"] = rightSquareBracket] = "rightSquareBracket"; //  ']'
+  const caret = 94; charCodes[charCodes["caret"] = caret] = "caret"; //  '^'
+  const underscore = 95; charCodes[charCodes["underscore"] = underscore] = "underscore"; //  '_'
+  const graveAccent = 96; charCodes[charCodes["graveAccent"] = graveAccent] = "graveAccent"; //  '`'
+  const lowercaseA = 97; charCodes[charCodes["lowercaseA"] = lowercaseA] = "lowercaseA"; //  'a'
+  const lowercaseB = 98; charCodes[charCodes["lowercaseB"] = lowercaseB] = "lowercaseB"; //  'b'
+  const lowercaseC = 99; charCodes[charCodes["lowercaseC"] = lowercaseC] = "lowercaseC"; //  'c'
+  const lowercaseD = 100; charCodes[charCodes["lowercaseD"] = lowercaseD] = "lowercaseD"; //  'd'
+  const lowercaseE = 101; charCodes[charCodes["lowercaseE"] = lowercaseE] = "lowercaseE"; //  'e'
+  const lowercaseF = 102; charCodes[charCodes["lowercaseF"] = lowercaseF] = "lowercaseF"; //  'f'
+  const lowercaseG = 103; charCodes[charCodes["lowercaseG"] = lowercaseG] = "lowercaseG"; //  'g'
+  const lowercaseH = 104; charCodes[charCodes["lowercaseH"] = lowercaseH] = "lowercaseH"; //  'h'
+  const lowercaseI = 105; charCodes[charCodes["lowercaseI"] = lowercaseI] = "lowercaseI"; //  'i'
+  const lowercaseJ = 106; charCodes[charCodes["lowercaseJ"] = lowercaseJ] = "lowercaseJ"; //  'j'
+  const lowercaseK = 107; charCodes[charCodes["lowercaseK"] = lowercaseK] = "lowercaseK"; //  'k'
+  const lowercaseL = 108; charCodes[charCodes["lowercaseL"] = lowercaseL] = "lowercaseL"; //  'l'
+  const lowercaseM = 109; charCodes[charCodes["lowercaseM"] = lowercaseM] = "lowercaseM"; //  'm'
+  const lowercaseN = 110; charCodes[charCodes["lowercaseN"] = lowercaseN] = "lowercaseN"; //  'n'
+  const lowercaseO = 111; charCodes[charCodes["lowercaseO"] = lowercaseO] = "lowercaseO"; //  'o'
+  const lowercaseP = 112; charCodes[charCodes["lowercaseP"] = lowercaseP] = "lowercaseP"; //  'p'
+  const lowercaseQ = 113; charCodes[charCodes["lowercaseQ"] = lowercaseQ] = "lowercaseQ"; //  'q'
+  const lowercaseR = 114; charCodes[charCodes["lowercaseR"] = lowercaseR] = "lowercaseR"; //  'r'
+  const lowercaseS = 115; charCodes[charCodes["lowercaseS"] = lowercaseS] = "lowercaseS"; //  's'
+  const lowercaseT = 116; charCodes[charCodes["lowercaseT"] = lowercaseT] = "lowercaseT"; //  't'
+  const lowercaseU = 117; charCodes[charCodes["lowercaseU"] = lowercaseU] = "lowercaseU"; //  'u'
+  const lowercaseV = 118; charCodes[charCodes["lowercaseV"] = lowercaseV] = "lowercaseV"; //  'v'
+  const lowercaseW = 119; charCodes[charCodes["lowercaseW"] = lowercaseW] = "lowercaseW"; //  'w'
+  const lowercaseX = 120; charCodes[charCodes["lowercaseX"] = lowercaseX] = "lowercaseX"; //  'x'
+  const lowercaseY = 121; charCodes[charCodes["lowercaseY"] = lowercaseY] = "lowercaseY"; //  'y'
+  const lowercaseZ = 122; charCodes[charCodes["lowercaseZ"] = lowercaseZ] = "lowercaseZ"; //  'z'
+  const leftCurlyBrace = 123; charCodes[charCodes["leftCurlyBrace"] = leftCurlyBrace] = "leftCurlyBrace"; //  '{'
+  const verticalBar = 124; charCodes[charCodes["verticalBar"] = verticalBar] = "verticalBar"; //  '|'
+  const rightCurlyBrace = 125; charCodes[charCodes["rightCurlyBrace"] = rightCurlyBrace] = "rightCurlyBrace"; //  '}'
+  const tilde = 126; charCodes[charCodes["tilde"] = tilde] = "tilde"; //  '~'
+  const nonBreakingSpace = 160; charCodes[charCodes["nonBreakingSpace"] = nonBreakingSpace] = "nonBreakingSpace";
+  // eslint-disable-next-line no-irregular-whitespace
+  const oghamSpaceMark = 5760; charCodes[charCodes["oghamSpaceMark"] = oghamSpaceMark] = "oghamSpaceMark"; // ' '
+  const lineSeparator = 8232; charCodes[charCodes["lineSeparator"] = lineSeparator] = "lineSeparator";
+  const paragraphSeparator = 8233; charCodes[charCodes["paragraphSeparator"] = paragraphSeparator] = "paragraphSeparator";
+})(charCodes || (exports.charCodes = charCodes = {}));
+
+ function isDigit(code) {
+  return (
+    (code >= charCodes.digit0 && code <= charCodes.digit9) ||
+    (code >= charCodes.lowercaseA && code <= charCodes.lowercaseF) ||
+    (code >= charCodes.uppercaseA && code <= charCodes.uppercaseF)
+  );
+} exports.isDigit = isDigit;
diff --git a/node_modules/sucrase/dist/parser/util/identifier.js b/node_modules/sucrase/dist/parser/util/identifier.js
new file mode 100644
index 0000000..9a2813c
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/util/identifier.js
@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _charcodes = require('./charcodes');
+var _whitespace = require('./whitespace');
+
+function computeIsIdentifierChar(code) {
+  if (code < 48) return code === 36;
+  if (code < 58) return true;
+  if (code < 65) return false;
+  if (code < 91) return true;
+  if (code < 97) return code === 95;
+  if (code < 123) return true;
+  if (code < 128) return false;
+  throw new Error("Should not be called with non-ASCII char code.");
+}
+
+ const IS_IDENTIFIER_CHAR = new Uint8Array(65536); exports.IS_IDENTIFIER_CHAR = IS_IDENTIFIER_CHAR;
+for (let i = 0; i < 128; i++) {
+  exports.IS_IDENTIFIER_CHAR[i] = computeIsIdentifierChar(i) ? 1 : 0;
+}
+for (let i = 128; i < 65536; i++) {
+  exports.IS_IDENTIFIER_CHAR[i] = 1;
+}
+// Aside from whitespace and newlines, all characters outside the ASCII space are either
+// identifier characters or invalid. Since we're not performing code validation, we can just
+// treat all invalid characters as identifier characters.
+for (const whitespaceChar of _whitespace.WHITESPACE_CHARS) {
+  exports.IS_IDENTIFIER_CHAR[whitespaceChar] = 0;
+}
+exports.IS_IDENTIFIER_CHAR[0x2028] = 0;
+exports.IS_IDENTIFIER_CHAR[0x2029] = 0;
+
+ const IS_IDENTIFIER_START = exports.IS_IDENTIFIER_CHAR.slice(); exports.IS_IDENTIFIER_START = IS_IDENTIFIER_START;
+for (let numChar = _charcodes.charCodes.digit0; numChar <= _charcodes.charCodes.digit9; numChar++) {
+  exports.IS_IDENTIFIER_START[numChar] = 0;
+}
diff --git a/node_modules/sucrase/dist/parser/util/whitespace.js b/node_modules/sucrase/dist/parser/util/whitespace.js
new file mode 100644
index 0000000..55bb994
--- /dev/null
+++ b/node_modules/sucrase/dist/parser/util/whitespace.js
@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _charcodes = require('./charcodes');
+
+// https://tc39.github.io/ecma262/#sec-white-space
+ const WHITESPACE_CHARS = [
+  0x0009,
+  0x000b,
+  0x000c,
+  _charcodes.charCodes.space,
+  _charcodes.charCodes.nonBreakingSpace,
+  _charcodes.charCodes.oghamSpaceMark,
+  0x2000, // EN QUAD
+  0x2001, // EM QUAD
+  0x2002, // EN SPACE
+  0x2003, // EM SPACE
+  0x2004, // THREE-PER-EM SPACE
+  0x2005, // FOUR-PER-EM SPACE
+  0x2006, // SIX-PER-EM SPACE
+  0x2007, // FIGURE SPACE
+  0x2008, // PUNCTUATION SPACE
+  0x2009, // THIN SPACE
+  0x200a, // HAIR SPACE
+  0x202f, // NARROW NO-BREAK SPACE
+  0x205f, // MEDIUM MATHEMATICAL SPACE
+  0x3000, // IDEOGRAPHIC SPACE
+  0xfeff, // ZERO WIDTH NO-BREAK SPACE
+]; exports.WHITESPACE_CHARS = WHITESPACE_CHARS;
+
+ const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g; exports.skipWhiteSpace = skipWhiteSpace;
+
+ const IS_WHITESPACE = new Uint8Array(65536); exports.IS_WHITESPACE = IS_WHITESPACE;
+for (const char of exports.WHITESPACE_CHARS) {
+  exports.IS_WHITESPACE[char] = 1;
+}