hermes-parser 0.10.0 → 0.11.0

package/dist/HermesParserWASM.js.flow

@@ -40,8 +40,8 @@ type HermesParserWASM = $ReadOnly<{
     (
       'hermesParse',
       'number',
-      ['number', 'number', 'number', 'number', 'number'],
-    ): (number, number, CBoolean, CBoolean, CBoolean) => number,
+      ['number', 'number', 'number', 'number', 'number', 'number'],
+    ): (number, number, CBoolean, CBoolean, CBoolean, CBoolean) => number,
     ('hermesParseResult_free', 'void', ['number']): number => void,
     ('hermesParseResult_getError', 'string', ['number']): number => string,
     ('hermesParseResult_getErrorLine', 'number', ['number']): number => number,

package/dist/HermesToBabelAdapter.js

@@ -18,15 +18,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * 
  * @format
  */
-
-/*
-This class does some very "javascripty" things in the name of
-performance which are ultimately impossible to soundly type.
-
-So instead of adding strict types and a large number of suppression
-comments, instead it is left untyped and subclasses are strictly
-typed via a separate flow declaration file.
-*/
 class HermesToBabelAdapter extends _HermesASTAdapter.default {
   fixSourceLocation(node) {
     var _this$sourceFilename;
@@ -116,6 +107,12 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
 
       case 'IndexedAccessType':
       case 'OptionalIndexedAccessType':
+      case 'KeyofTypeAnnotation':
+      case 'ConditionalType':
+      case 'InferType':
+      case 'TupleTypeLabeledElement':
+      case 'TupleTypeSpreadElement':
+      case 'ObjectTypeMappedTypeProperty':
         return this.mapUnsupportedTypeAnnotation(node);
 
       case 'BigIntLiteral':
@@ -127,6 +124,21 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'BigIntTypeAnnotation':
         return this.mapBigIntTypeAnnotation(node);
 
+      case 'TypeofTypeAnnotation':
+        return this.mapTypeofTypeAnnotation(node);
+
+      case 'QualifiedTypeofIdentifier':
+        return this.mapQualifiedTypeofIdentifier(node);
+
+      case 'DeclareVariable':
+        return this.mapDeclareVariable(node);
+
+      case 'DeclareEnum':
+        return this.mapDeclareEnum(node);
+
+      case 'JSXElement':
+        return this.mapJSXElement(node);
+
       default:
         return this.mapNodeDefault(node);
     }
@@ -518,6 +530,38 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
     return node;
   }
 
+  mapTypeofTypeAnnotation(nodeUnprocessed) {
+    nodeUnprocessed.argument = {
+      type: 'GenericTypeAnnotation',
+      id: nodeUnprocessed.argument,
+      typeParameters: null,
+      loc: nodeUnprocessed.argument.loc
+    };
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapQualifiedTypeofIdentifier(nodeUnprocessed) {
+    nodeUnprocessed.type = 'QualifiedTypeIdentifier';
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareVariable(nodeUnprocessed) {
+    delete nodeUnprocessed.kind;
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareEnum(nodeUnprocessed) {
+    nodeUnprocessed.id.typeAnnotation = this.mapUnsupportedTypeAnnotation(nodeUnprocessed.body);
+    delete nodeUnprocessed.body;
+    nodeUnprocessed.type = 'DeclareVariable';
+    return this.mapDeclareVariable(nodeUnprocessed);
+  }
+
+  mapJSXElement(nodeUnprocessed) {
+    delete nodeUnprocessed.openingElement.typeArguments;
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
 }
 
 exports.default = HermesToBabelAdapter;

package/dist/HermesToBabelAdapter.js.flow

@@ -4,19 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict
  * @format
  */
 
-/*
-This class does some very "javascripty" things in the name of
-performance which are ultimately impossible to soundly type.
-
-So instead of adding strict types and a large number of suppression
-comments, instead it is left untyped and subclasses are strictly
-typed via a separate flow declaration file.
-*/
-
 import type {HermesNode} from './HermesAST';
 
 import HermesASTAdapter from './HermesASTAdapter';
@@ -88,6 +79,12 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapFunction(node);
       case 'IndexedAccessType':
       case 'OptionalIndexedAccessType':
+      case 'KeyofTypeAnnotation':
+      case 'ConditionalType':
+      case 'InferType':
+      case 'TupleTypeLabeledElement':
+      case 'TupleTypeSpreadElement':
+      case 'ObjectTypeMappedTypeProperty':
         return this.mapUnsupportedTypeAnnotation(node);
       case 'BigIntLiteral':
         return this.mapBigIntLiteral(node);
@@ -95,6 +92,16 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapBigIntLiteralTypeAnnotation(node);
       case 'BigIntTypeAnnotation':
         return this.mapBigIntTypeAnnotation(node);
+      case 'TypeofTypeAnnotation':
+        return this.mapTypeofTypeAnnotation(node);
+      case 'QualifiedTypeofIdentifier':
+        return this.mapQualifiedTypeofIdentifier(node);
+      case 'DeclareVariable':
+        return this.mapDeclareVariable(node);
+      case 'DeclareEnum':
+        return this.mapDeclareEnum(node);
+      case 'JSXElement':
+        return this.mapJSXElement(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -496,4 +503,44 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
 
     return node;
   }
+
+  mapTypeofTypeAnnotation(nodeUnprocessed: HermesNode): HermesNode {
+    nodeUnprocessed.argument = {
+      type: 'GenericTypeAnnotation',
+      id: nodeUnprocessed.argument,
+      typeParameters: null,
+      loc: nodeUnprocessed.argument.loc,
+    };
+
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapQualifiedTypeofIdentifier(nodeUnprocessed: HermesNode): HermesNode {
+    nodeUnprocessed.type = 'QualifiedTypeIdentifier';
+
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareVariable(nodeUnprocessed: HermesNode): HermesNode {
+    delete nodeUnprocessed.kind;
+
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareEnum(nodeUnprocessed: HermesNode): HermesNode {
+    nodeUnprocessed.id.typeAnnotation = this.mapUnsupportedTypeAnnotation(
+      nodeUnprocessed.body,
+    );
+
+    delete nodeUnprocessed.body;
+
+    nodeUnprocessed.type = 'DeclareVariable';
+
+    return this.mapDeclareVariable(nodeUnprocessed);
+  }
+
+  mapJSXElement(nodeUnprocessed: HermesNode): HermesNode {
+    delete nodeUnprocessed.openingElement.typeArguments;
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
 }

package/dist/HermesToESTreeAdapter.js

@@ -20,15 +20,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * 
  * @format
  */
-
-/*
-This class does some very "javascripty" things in the name of
-performance which are ultimately impossible to soundly type.
-
-So instead of adding strict types and a large number of suppression
-comments, instead it is left untyped and subclasses are strictly
-typed via a separate flow declaration file.
-*/
 class HermesToESTreeAdapter extends _HermesASTAdapter.default {
   constructor(options, code) {
     super(options);
@@ -131,10 +122,10 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
   }
 
   mapProgram(node) {
-    node = this.mapNodeDefault(node);
+    const nodeDefault = this.mapNodeDefault(node);
     node.sourceType = this.getSourceType();
-    node.docblock = (0, _getModuleDocblock.getModuleDocblock)(node);
-    return node;
+    node.docblock = (0, _getModuleDocblock.getModuleDocblock)(nodeDefault);
+    return nodeDefault;
   }
 
   mapSimpleLiteral(node) {

package/dist/HermesToESTreeAdapter.js.flow

@@ -4,19 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict
  * @format
  */
 
-/*
-This class does some very "javascripty" things in the name of
-performance which are ultimately impossible to soundly type.
-
-So instead of adding strict types and a large number of suppression
-comments, instead it is left untyped and subclasses are strictly
-typed via a separate flow declaration file.
-*/
-
 import type {HermesNode} from './HermesAST';
 import type {ParserOptions} from './ParserOptions';
 
@@ -107,12 +98,12 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
   }
 
   mapProgram(node: HermesNode): HermesNode {
-    node = this.mapNodeDefault(node);
+    const nodeDefault = this.mapNodeDefault(node);
     node.sourceType = this.getSourceType();
 
-    node.docblock = getModuleDocblock(node);
+    node.docblock = getModuleDocblock(nodeDefault);
 
-    return node;
+    return nodeDefault;
   }
 
   mapSimpleLiteral(node: HermesNode): HermesNode {

package/dist/ParserOptions.js.flow

@@ -12,6 +12,7 @@ export type ParserOptions = {
   allowReturnOutsideFunction?: boolean,
   babel?: boolean,
   flow?: 'all' | 'detect',
+  enableExperimentalComponentSyntax?: boolean,
   sourceFilename?: string,
   sourceType?: 'module' | 'script' | 'unambiguous',
   tokens?: boolean,

package/dist/generated/ESTreeVisitorKeys.js

@@ -0,0 +1,194 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
+ */
+// lint directives to let us do some basic validation of generated files
+
+/* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
+
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
+'use strict';
+
+module.exports = {
+  AnyTypeAnnotation: [],
+  ArrayExpression: ['elements'],
+  ArrayPattern: ['elements', 'typeAnnotation'],
+  ArrayTypeAnnotation: ['elementType'],
+  ArrowFunctionExpression: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  AssignmentExpression: ['left', 'right'],
+  AssignmentPattern: ['left', 'right'],
+  AwaitExpression: ['argument'],
+  BigIntLiteralTypeAnnotation: [],
+  BigIntTypeAnnotation: [],
+  BinaryExpression: ['left', 'right'],
+  BlockStatement: ['body'],
+  BooleanLiteralTypeAnnotation: [],
+  BooleanTypeAnnotation: [],
+  BreakStatement: ['label'],
+  CallExpression: ['callee', 'typeArguments', 'arguments'],
+  CatchClause: ['param', 'body'],
+  ChainExpression: ['expression'],
+  ClassBody: ['body'],
+  ClassDeclaration: ['id', 'typeParameters', 'superClass', 'superTypeParameters', 'implements', 'decorators', 'body'],
+  ClassExpression: ['id', 'typeParameters', 'superClass', 'superTypeParameters', 'implements', 'decorators', 'body'],
+  ClassImplements: ['id', 'typeParameters'],
+  ComponentDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType'],
+  ComponentParameter: ['name', 'local'],
+  ComponentTypeAnnotation: ['params', 'rest', 'typeParameters', 'returnType'],
+  ComponentTypeParameter: ['name', 'typeAnnotation'],
+  ConditionalExpression: ['test', 'consequent', 'alternate'],
+  ConditionalTypeAnnotation: ['checkType', 'extendsType', 'trueType', 'falseType'],
+  ContinueStatement: ['label'],
+  DebuggerStatement: [],
+  DeclareClass: ['id', 'typeParameters', 'extends', 'implements', 'mixins', 'body'],
+  DeclareComponent: ['id', 'params', 'rest', 'typeParameters', 'returnType'],
+  DeclaredPredicate: ['value'],
+  DeclareEnum: ['id', 'body'],
+  DeclareExportAllDeclaration: ['source'],
+  DeclareExportDeclaration: ['declaration', 'specifiers', 'source'],
+  DeclareFunction: ['id', 'predicate'],
+  DeclareInterface: ['id', 'typeParameters', 'extends', 'body'],
+  DeclareModule: ['id', 'body'],
+  DeclareModuleExports: ['typeAnnotation'],
+  DeclareOpaqueType: ['id', 'typeParameters', 'impltype', 'supertype'],
+  DeclareTypeAlias: ['id', 'typeParameters', 'right'],
+  DeclareVariable: ['id'],
+  DoWhileStatement: ['body', 'test'],
+  EmptyStatement: [],
+  EmptyTypeAnnotation: [],
+  EnumBooleanBody: ['members'],
+  EnumBooleanMember: ['id', 'init'],
+  EnumDeclaration: ['id', 'body'],
+  EnumDefaultedMember: ['id'],
+  EnumNumberBody: ['members'],
+  EnumNumberMember: ['id', 'init'],
+  EnumStringBody: ['members'],
+  EnumStringMember: ['id', 'init'],
+  EnumSymbolBody: ['members'],
+  ExistsTypeAnnotation: [],
+  ExportAllDeclaration: ['exported', 'source'],
+  ExportDefaultDeclaration: ['declaration'],
+  ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
+  ExportSpecifier: ['exported', 'local'],
+  ExpressionStatement: ['expression'],
+  ForInStatement: ['left', 'right', 'body'],
+  ForOfStatement: ['left', 'right', 'body'],
+  ForStatement: ['init', 'test', 'update', 'body'],
+  FunctionDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  FunctionExpression: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  FunctionTypeAnnotation: ['params', 'this', 'returnType', 'rest', 'typeParameters'],
+  FunctionTypeParam: ['name', 'typeAnnotation'],
+  GenericTypeAnnotation: ['id', 'typeParameters'],
+  Identifier: ['typeAnnotation'],
+  IfStatement: ['test', 'consequent', 'alternate'],
+  ImportAttribute: ['key', 'value'],
+  ImportDeclaration: ['specifiers', 'source', 'assertions'],
+  ImportDefaultSpecifier: ['local'],
+  ImportExpression: ['source', 'attributes'],
+  ImportNamespaceSpecifier: ['local'],
+  ImportSpecifier: ['imported', 'local'],
+  IndexedAccessType: ['objectType', 'indexType'],
+  InferredPredicate: [],
+  InferTypeAnnotation: ['typeParameter'],
+  InterfaceDeclaration: ['id', 'typeParameters', 'extends', 'body'],
+  InterfaceExtends: ['id', 'typeParameters'],
+  InterfaceTypeAnnotation: ['extends', 'body'],
+  IntersectionTypeAnnotation: ['types'],
+  JSXAttribute: ['name', 'value'],
+  JSXClosingElement: ['name'],
+  JSXClosingFragment: [],
+  JSXElement: ['openingElement', 'children', 'closingElement'],
+  JSXEmptyExpression: [],
+  JSXExpressionContainer: ['expression'],
+  JSXFragment: ['openingFragment', 'children', 'closingFragment'],
+  JSXIdentifier: [],
+  JSXMemberExpression: ['object', 'property'],
+  JSXNamespacedName: ['namespace', 'name'],
+  JSXOpeningElement: ['name', 'attributes', 'typeArguments'],
+  JSXOpeningFragment: [],
+  JSXSpreadAttribute: ['argument'],
+  JSXSpreadChild: ['expression'],
+  JSXText: [],
+  KeyofTypeAnnotation: ['argument'],
+  LabeledStatement: ['label', 'body'],
+  LogicalExpression: ['left', 'right'],
+  MemberExpression: ['object', 'property'],
+  MetaProperty: ['meta', 'property'],
+  MethodDefinition: ['key', 'value'],
+  MixedTypeAnnotation: [],
+  NewExpression: ['callee', 'typeArguments', 'arguments'],
+  NullableTypeAnnotation: ['typeAnnotation'],
+  NullLiteralTypeAnnotation: [],
+  NumberLiteralTypeAnnotation: [],
+  NumberTypeAnnotation: [],
+  ObjectExpression: ['properties'],
+  ObjectPattern: ['properties', 'typeAnnotation'],
+  ObjectTypeAnnotation: ['properties', 'indexers', 'callProperties', 'internalSlots'],
+  ObjectTypeCallProperty: ['value'],
+  ObjectTypeIndexer: ['id', 'key', 'value', 'variance'],
+  ObjectTypeInternalSlot: ['id', 'value'],
+  ObjectTypeMappedTypeProperty: ['keyTparam', 'propType', 'sourceType', 'variance'],
+  ObjectTypeProperty: ['key', 'value', 'variance'],
+  ObjectTypeSpreadProperty: ['argument'],
+  OpaqueType: ['id', 'typeParameters', 'impltype', 'supertype'],
+  OptionalIndexedAccessType: ['objectType', 'indexType'],
+  PrivateIdentifier: [],
+  Program: ['body'],
+  Property: ['key', 'value'],
+  PropertyDefinition: ['key', 'value', 'variance', 'typeAnnotation', 'tsModifiers'],
+  QualifiedTypeIdentifier: ['qualification', 'id'],
+  QualifiedTypeofIdentifier: ['qualification', 'id'],
+  RestElement: ['argument'],
+  ReturnStatement: ['argument'],
+  SequenceExpression: ['expressions'],
+  SpreadElement: ['argument'],
+  StringLiteralTypeAnnotation: [],
+  StringTypeAnnotation: [],
+  Super: [],
+  SwitchCase: ['test', 'consequent'],
+  SwitchStatement: ['discriminant', 'cases'],
+  SymbolTypeAnnotation: [],
+  TaggedTemplateExpression: ['tag', 'quasi'],
+  TemplateElement: [],
+  TemplateLiteral: ['quasis', 'expressions'],
+  ThisExpression: [],
+  ThisTypeAnnotation: [],
+  ThrowStatement: ['argument'],
+  TryStatement: ['block', 'handler', 'finalizer'],
+  TupleTypeAnnotation: ['types'],
+  TupleTypeLabeledElement: ['label', 'elementType', 'variance'],
+  TupleTypeSpreadElement: ['label', 'typeAnnotation'],
+  TypeAlias: ['id', 'typeParameters', 'right'],
+  TypeAnnotation: ['typeAnnotation'],
+  TypeCastExpression: ['expression', 'typeAnnotation'],
+  TypeofTypeAnnotation: ['argument'],
+  TypeParameter: ['bound', 'variance', 'default'],
+  TypeParameterDeclaration: ['params'],
+  TypeParameterInstantiation: ['params'],
+  TypePredicate: ['parameterName', 'typeAnnotation'],
+  UnaryExpression: ['argument'],
+  UnionTypeAnnotation: ['types'],
+  UpdateExpression: ['argument'],
+  VariableDeclaration: ['declarations'],
+  VariableDeclarator: ['id', 'init'],
+  Variance: [],
+  VoidTypeAnnotation: [],
+  WhileStatement: ['test', 'body'],
+  WithStatement: ['object', 'body'],
+  YieldExpression: ['argument'],
+  OptionalMemberExpression: ['object', 'property'],
+  OptionalCallExpression: ['callee', 'typeArguments', 'arguments'],
+  Literal: []
+};

package/dist/generated/ESTreeVisitorKeys.js.flow

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+export type VisitorKeys = $ReadOnly<{[string]: $ReadOnlyArray<string>}>;
+
+declare module.exports: VisitorKeys;

package/dist/generated/{visitor-keys.js → ParserVisitorKeys.js}

@@ -18,7 +18,7 @@
 
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
 
-/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -113,11 +113,38 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     typeParameters: 'Node'
   },
+  ComponentDeclaration: {
+    id: 'Node',
+    params: 'NodeList',
+    body: 'Node',
+    typeParameters: 'Node',
+    returnType: 'Node'
+  },
+  ComponentParameter: {
+    name: 'Node',
+    local: 'Node'
+  },
+  ComponentTypeAnnotation: {
+    params: 'NodeList',
+    rest: 'Node',
+    typeParameters: 'Node',
+    returnType: 'Node'
+  },
+  ComponentTypeParameter: {
+    name: 'Node',
+    typeAnnotation: 'Node'
+  },
   ConditionalExpression: {
     test: 'Node',
     alternate: 'Node',
     consequent: 'Node'
   },
+  ConditionalTypeAnnotation: {
+    checkType: 'Node',
+    extendsType: 'Node',
+    trueType: 'Node',
+    falseType: 'Node'
+  },
   ContinueStatement: {
     label: 'Node'
   },
@@ -130,9 +157,20 @@ const HERMES_AST_VISITOR_KEYS = {
     mixins: 'NodeList',
     body: 'Node'
   },
+  DeclareComponent: {
+    id: 'Node',
+    params: 'NodeList',
+    rest: 'Node',
+    typeParameters: 'Node',
+    returnType: 'Node'
+  },
   DeclaredPredicate: {
     value: 'Node'
   },
+  DeclareEnum: {
+    id: 'Node',
+    body: 'Node'
+  },
   DeclareExportAllDeclaration: {
     source: 'Node'
   },
@@ -312,6 +350,9 @@ const HERMES_AST_VISITOR_KEYS = {
     indexType: 'Node'
   },
   InferredPredicate: {},
+  InferTypeAnnotation: {
+    typeParameter: 'Node'
+  },
   InterfaceDeclaration: {
     id: 'Node',
     typeParameters: 'Node',
@@ -362,7 +403,8 @@ const HERMES_AST_VISITOR_KEYS = {
   },
   JSXOpeningElement: {
     name: 'Node',
-    attributes: 'NodeList'
+    attributes: 'NodeList',
+    typeArguments: 'Node'
   },
   JSXOpeningFragment: {},
   JSXSpreadAttribute: {
@@ -372,6 +414,9 @@ const HERMES_AST_VISITOR_KEYS = {
     expression: 'Node'
   },
   JSXText: {},
+  KeyofTypeAnnotation: {
+    argument: 'Node'
+  },
   LabeledStatement: {
     label: 'Node',
     body: 'Node'
@@ -432,6 +477,12 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     value: 'Node'
   },
+  ObjectTypeMappedTypeProperty: {
+    keyTparam: 'Node',
+    propType: 'Node',
+    sourceType: 'Node',
+    variance: 'Node'
+  },
   ObjectTypeProperty: {
     key: 'Node',
     value: 'Node',
@@ -469,6 +520,10 @@ const HERMES_AST_VISITOR_KEYS = {
     qualification: 'Node',
     id: 'Node'
   },
+  QualifiedTypeofIdentifier: {
+    qualification: 'Node',
+    id: 'Node'
+  },
   RegExpLiteral: {},
   RestElement: {
     argument: 'Node'
@@ -517,6 +572,15 @@ const HERMES_AST_VISITOR_KEYS = {
   TupleTypeAnnotation: {
     types: 'NodeList'
   },
+  TupleTypeLabeledElement: {
+    label: 'Node',
+    elementType: 'Node',
+    variance: 'Node'
+  },
+  TupleTypeSpreadElement: {
+    label: 'Node',
+    typeAnnotation: 'Node'
+  },
   TypeAlias: {
     id: 'Node',
     typeParameters: 'Node',
@@ -543,6 +607,10 @@ const HERMES_AST_VISITOR_KEYS = {
   TypeParameterInstantiation: {
     params: 'NodeList'
   },
+  TypePredicate: {
+    parameterName: 'Node',
+    typeAnnotation: 'Node'
+  },
   UnaryExpression: {
     argument: 'Node'
   },

package/dist/index.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 var _exportNames = {
   parse: true,
+  FlowVisitorKeys: true,
   astArrayMutationHelpers: true,
   astNodeMutationHelpers: true
 };
@@ -26,6 +27,10 @@ var _HermesToBabelAdapter = _interopRequireDefault(require("./HermesToBabelAdapt
 
 var _HermesToESTreeAdapter = _interopRequireDefault(require("./HermesToESTreeAdapter"));
 
+var _ESTreeVisitorKeys = _interopRequireDefault(require("./generated/ESTreeVisitorKeys"));
+
+exports.FlowVisitorKeys = _ESTreeVisitorKeys.default;
+
 var _SimpleTraverser = require("./traverse/SimpleTraverser");
 
 Object.keys(_SimpleTraverser).forEach(function (key) {

package/dist/index.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict-local
+ * @flow strict
  * @format
  */
 
@@ -16,6 +16,7 @@ import type {ParserOptions} from './ParserOptions';
 import * as HermesParser from './HermesParser';
 import HermesToBabelAdapter from './HermesToBabelAdapter';
 import HermesToESTreeAdapter from './HermesToESTreeAdapter';
+import FlowVisitorKeys from './generated/ESTreeVisitorKeys';
 
 const DEFAULTS = {
   flow: 'detect',
@@ -86,5 +87,6 @@ export type {ParserOptions} from './ParserOptions';
 export * from './traverse/SimpleTraverser';
 export * from './transform/SimpleTransform';
 export * from './traverse/getVisitorKeys';
+export {FlowVisitorKeys};
 export * as astArrayMutationHelpers from './transform/astArrayMutationHelpers';
 export * as astNodeMutationHelpers from './transform/astNodeMutationHelpers';