hermes-parser 0.9.0 → 0.10.1

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;
@@ -121,6 +112,12 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'BigIntLiteral':
         return this.mapBigIntLiteral(node);
 
+      case 'BigIntLiteralTypeAnnotation':
+        return this.mapBigIntLiteralTypeAnnotation(node);
+
+      case 'BigIntTypeAnnotation':
+        return this.mapBigIntTypeAnnotation(node);
+
       default:
         return this.mapNodeDefault(node);
     }
@@ -436,10 +433,36 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
   }
 
   mapBigIntLiteral(node) {
-    const bigint = node.bigint.replace(/n$/, '').replace(/_/, '');
-    node.value = typeof BigInt === 'function' ? BigInt(bigint) : null;
+    node.value = this.getBigIntLiteralValue(node.bigint).value;
+    return node;
+  }
+
+  mapBigIntLiteralTypeAnnotation(node) {
+    node.value = this.getBigIntLiteralValue(node.raw).value;
     return node;
   }
+  /**
+   * Babel does not parse the bigint keyword type as the keyword node.
+   * So we need to down-level the AST to a plain GenericTypeAnnotation
+   */
+
+
+  mapBigIntTypeAnnotation(node) {
+    return {
+      type: 'GenericTypeAnnotation',
+      id: {
+        type: 'Identifier',
+        name: 'bigint',
+        loc: node.loc,
+        start: node.start,
+        end: node.end
+      },
+      typeParameters: null,
+      loc: node.loc,
+      start: node.start,
+      end: node.end
+    };
+  }
 
   mapPrivateProperty(nodeUnprocessed) {
     const node = this.mapNodeDefault(nodeUnprocessed);

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';
@@ -91,6 +82,10 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapUnsupportedTypeAnnotation(node);
       case 'BigIntLiteral':
         return this.mapBigIntLiteral(node);
+      case 'BigIntLiteralTypeAnnotation':
+        return this.mapBigIntLiteralTypeAnnotation(node);
+      case 'BigIntTypeAnnotation':
+        return this.mapBigIntTypeAnnotation(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -413,10 +408,33 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
   }
 
   mapBigIntLiteral(node: HermesNode): HermesNode {
-    const bigint = node.bigint.replace(/n$/, '').replace(/_/, '');
-    node.value = typeof BigInt === 'function' ? BigInt(bigint) : null;
+    node.value = this.getBigIntLiteralValue(node.bigint).value;
     return node;
   }
+  mapBigIntLiteralTypeAnnotation(node: HermesNode): HermesNode {
+    node.value = this.getBigIntLiteralValue(node.raw).value;
+    return node;
+  }
+  /**
+   * Babel does not parse the bigint keyword type as the keyword node.
+   * So we need to down-level the AST to a plain GenericTypeAnnotation
+   */
+  mapBigIntTypeAnnotation(node: HermesNode): HermesNode {
+    return {
+      type: 'GenericTypeAnnotation',
+      id: {
+        type: 'Identifier',
+        name: 'bigint',
+        loc: node.loc,
+        start: node.start,
+        end: node.end,
+      },
+      typeParameters: null,
+      loc: node.loc,
+      start: node.start,
+      end: node.end,
+    };
+  }
 
   mapPrivateProperty(nodeUnprocessed: HermesNode): HermesNode {
     const node = 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) {
@@ -173,14 +164,8 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
 
   mapBigIntLiteral(node) {
     const newNode = this.mapSimpleLiteral(node);
-    const bigint = node.bigint // estree spec is to not have a trailing `n` on this property
-    // https://github.com/estree/estree/blob/db962bb417a97effcfe9892f87fbb93c81a68584/es2020.md#bigintliteral
-    .replace(/n$/, '') // `BigInt` doesn't accept numeric separator and `bigint` property should not include numeric separator
-    .replace(/_/, '');
     return { ...newNode,
-      // coerce the string to a bigint value if supported by the environment
-      value: typeof BigInt === 'function' ? BigInt(bigint) : null,
-      bigint
+      ...this.getBigIntLiteralValue(node.bigint)
     };
   }
 
@@ -214,8 +199,9 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
   }
 
   mapBigIntLiteralTypeAnnotation(node) {
-    node.value = null;
-    return node;
+    return { ...node,
+      ...this.getBigIntLiteralValue(node.raw)
+    };
   }
 
   mapTemplateElement(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 {
@@ -150,17 +141,9 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
 
   mapBigIntLiteral(node: HermesNode): HermesNode {
     const newNode = this.mapSimpleLiteral(node);
-    const bigint = node.bigint
-      // estree spec is to not have a trailing `n` on this property
-      // https://github.com/estree/estree/blob/db962bb417a97effcfe9892f87fbb93c81a68584/es2020.md#bigintliteral
-      .replace(/n$/, '')
-      // `BigInt` doesn't accept numeric separator and `bigint` property should not include numeric separator
-      .replace(/_/, '');
     return {
       ...newNode,
-      // coerce the string to a bigint value if supported by the environment
-      value: typeof BigInt === 'function' ? BigInt(bigint) : null,
-      bigint,
+      ...this.getBigIntLiteralValue(node.bigint),
     };
   }
 
@@ -193,8 +176,10 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
   }
 
   mapBigIntLiteralTypeAnnotation(node: HermesNode): HermesNode {
-    node.value = null;
-    return node;
+    return {
+      ...node,
+      ...this.getBigIntLiteralValue(node.raw),
+    };
   }
 
   mapTemplateElement(node: HermesNode): HermesNode {

package/dist/generated/ESTreeVisitorKeys.js

@@ -0,0 +1,180 @@
+/**
+ * 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'],
+  ConditionalExpression: ['test', 'consequent', 'alternate'],
+  ContinueStatement: ['label'],
+  DebuggerStatement: [],
+  DeclareClass: ['id', 'typeParameters', 'extends', 'implements', 'mixins', 'body'],
+  DeclaredPredicate: ['value'],
+  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: [],
+  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'],
+  JSXOpeningFragment: [],
+  JSXSpreadAttribute: ['argument'],
+  JSXSpreadChild: ['expression'],
+  JSXText: [],
+  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'],
+  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'],
+  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'],
+  TypeAlias: ['id', 'typeParameters', 'right'],
+  TypeAnnotation: ['typeAnnotation'],
+  TypeCastExpression: ['expression', 'typeAnnotation'],
+  TypeofTypeAnnotation: ['argument'],
+  TypeParameter: ['bound', 'variance', 'default'],
+  TypeParameterDeclaration: ['params'],
+  TypeParameterInstantiation: ['params'],
+  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}

@@ -6,12 +6,19 @@
  *
  * 
  * @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 */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -55,6 +62,7 @@ const HERMES_AST_VISITOR_KEYS = {
   },
   BigIntLiteral: {},
   BigIntLiteralTypeAnnotation: {},
+  BigIntTypeAnnotation: {},
   BinaryExpression: {
     left: 'Node',
     right: 'Node'
@@ -454,7 +462,8 @@ const HERMES_AST_VISITOR_KEYS = {
     key: 'Node',
     value: 'Node',
     variance: 'Node',
-    typeAnnotation: 'Node'
+    typeAnnotation: 'Node',
+    tsModifiers: 'Node'
   },
   QualifiedTypeIdentifier: {
     qualification: 'Node',

package/dist/getModuleDocblock.js

@@ -19,7 +19,8 @@ const DIRECTIVE_REGEX = /^\s*@([a-zA-Z0-9_-]+)( +.+)?$/;
 function parseDocblockString(docblock) {
   const directiveLines = docblock.split('\n') // remove the leading " *" from each line
   .map(line => line.trimStart().replace(/^\* ?/, '').trim()).filter(line => line.startsWith('@'));
-  const directives = {};
+  const directives = // $FlowExpectedError[incompatible-type] - flow types  this return as {...}
+  Object.create(null);
 
   for (const line of directiveLines) {
     var _match$;

package/dist/getModuleDocblock.js.flow

@@ -24,7 +24,9 @@ export function parseDocblockString(docblock: string): DocblockDirectives {
 
   const directives: {
     [string]: Array<string>,
-  } = {};
+  } =
+    // $FlowExpectedError[incompatible-type] - flow types  this return as {...}
+    Object.create(null);
 
   for (const line of directiveLines) {
     const match = DIRECTIVE_REGEX.exec(line);

package/dist/index.js

@@ -12,6 +12,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  parse: true,
+  FlowVisitorKeys: true,
+  astArrayMutationHelpers: true,
+  astNodeMutationHelpers: true
+};
+exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = void 0;
 exports.parse = parse;
 
 var HermesParser = _interopRequireWildcard(require("./HermesParser"));
@@ -20,6 +27,45 @@ 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) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTraverser[key]) return;
+  exports[key] = _SimpleTraverser[key];
+});
+
+var _SimpleTransform = require("./transform/SimpleTransform");
+
+Object.keys(_SimpleTransform).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTransform[key]) return;
+  exports[key] = _SimpleTransform[key];
+});
+
+var _getVisitorKeys = require("./traverse/getVisitorKeys");
+
+Object.keys(_getVisitorKeys).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getVisitorKeys[key]) return;
+  exports[key] = _getVisitorKeys[key];
+});
+
+var _astArrayMutationHelpers = _interopRequireWildcard(require("./transform/astArrayMutationHelpers"));
+
+exports.astArrayMutationHelpers = _astArrayMutationHelpers;
+
+var _astNodeMutationHelpers = _interopRequireWildcard(require("./transform/astNodeMutationHelpers"));
+
+exports.astNodeMutationHelpers = _astNodeMutationHelpers;
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

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',
@@ -83,3 +84,9 @@ export function parse(
 }
 
 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';