hermes-parser 0.15.1 → 0.17.0

package/dist/generated/ParserVisitorKeys.js

@@ -49,6 +49,10 @@ const HERMES_AST_VISITOR_KEYS = {
     returnType: 'Node',
     predicate: 'Node'
   },
+  AsExpression: {
+    expression: 'Node',
+    typeAnnotation: 'Node'
+  },
   AssignmentExpression: {
     left: 'Node',
     right: 'Node'
@@ -595,6 +599,9 @@ const HERMES_AST_VISITOR_KEYS = {
   TypeofTypeAnnotation: {
     argument: 'Node'
   },
+  TypeOperator: {
+    typeAnnotation: 'Node'
+  },
   TypeParameter: {
     bound: 'Node',
     variance: 'Node',

package/dist/index.js

@@ -15,23 +15,30 @@ Object.defineProperty(exports, "__esModule", {
 var _exportNames = {
   parse: true,
   mutateESTreeASTForPrettier: true,
+  Transforms: true,
   FlowVisitorKeys: true,
   astArrayMutationHelpers: true,
   astNodeMutationHelpers: true
 };
-exports.mutateESTreeASTForPrettier = exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = void 0;
+exports.mutateESTreeASTForPrettier = exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = exports.Transforms = void 0;
 exports.parse = parse;
 
 var HermesParser = _interopRequireWildcard(require("./HermesParser"));
 
-var _HermesToBabelAdapter = _interopRequireDefault(require("./HermesToBabelAdapter"));
-
 var _HermesToESTreeAdapter = _interopRequireDefault(require("./HermesToESTreeAdapter"));
 
 var _ESTreeVisitorKeys = _interopRequireDefault(require("./generated/ESTreeVisitorKeys"));
 
 exports.FlowVisitorKeys = _ESTreeVisitorKeys.default;
 
+var StripComponentSyntax = _interopRequireWildcard(require("./estree/StripComponentSyntax"));
+
+var StripFlowTypesForBabel = _interopRequireWildcard(require("./estree/StripFlowTypesForBabel"));
+
+var TransformESTreeToBabel = _interopRequireWildcard(require("./babel/TransformESTreeToBabel"));
+
+var StripFlowTypes = _interopRequireWildcard(require("./estree/StripFlowTypes"));
+
 var _ParserOptions = require("./ParserOptions");
 
 Object.keys(_ParserOptions).forEach(function (key) {
@@ -107,20 +114,33 @@ function getOptions(options = { ...DEFAULTS
     throw new Error('sourceType option must be "script", "module", or "unambiguous" if set');
   }
 
+  if (options.enableExperimentalComponentSyntax == null) {
+    options.enableExperimentalComponentSyntax = true; // Enable by default
+  }
+
   options.tokens = options.tokens === true;
   options.allowReturnOutsideFunction = options.allowReturnOutsideFunction === true;
   return options;
 }
 
-function getAdapter(options, code) {
-  return options.babel === true ? new _HermesToBabelAdapter.default(options) : new _HermesToESTreeAdapter.default(options, code);
-} // $FlowExpectedError[unclear-type]
-
-
 // eslint-disable-next-line no-redeclare
 function parse(code, opts) {
   const options = getOptions(opts);
   const ast = HermesParser.parse(code, options);
-  const adapter = getAdapter(options, code);
-  return adapter.transform(ast);
-}
+  const estreeAdapter = new _HermesToESTreeAdapter.default(options, code);
+  const estreeAST = estreeAdapter.transform(ast);
+
+  if (options.babel !== true) {
+    return estreeAST;
+  }
+
+  const loweredESTreeAST = [StripComponentSyntax.transformProgram, StripFlowTypesForBabel.transformProgram].reduce((ast, transform) => transform(ast, options), estreeAST);
+  return TransformESTreeToBabel.transformProgram(loweredESTreeAST, options);
+}
+
+const Transforms = {
+  stripComponentSyntax: StripComponentSyntax.transformProgram,
+  stripFlowTypesForBabel: StripFlowTypesForBabel.transformProgram,
+  stripFlowTypes: StripFlowTypes.transformProgram
+};
+exports.Transforms = Transforms;

package/dist/index.js.flow

@@ -12,11 +12,15 @@
 
 import type {Program as ESTreeProgram} from 'hermes-estree';
 import type {ParserOptions} from './ParserOptions';
+import type {BabelFile} from './babel/TransformESTreeToBabel';
 
 import * as HermesParser from './HermesParser';
-import HermesToBabelAdapter from './HermesToBabelAdapter';
 import HermesToESTreeAdapter from './HermesToESTreeAdapter';
 import FlowVisitorKeys from './generated/ESTreeVisitorKeys';
+import * as StripComponentSyntax from './estree/StripComponentSyntax';
+import * as StripFlowTypesForBabel from './estree/StripFlowTypesForBabel';
+import * as TransformESTreeToBabel from './babel/TransformESTreeToBabel';
+import * as StripFlowTypes from './estree/StripFlowTypes';
 
 const DEFAULTS = {
   flow: 'detect',
@@ -44,6 +48,10 @@ function getOptions(options?: ParserOptions = {...DEFAULTS}) {
     );
   }
 
+  if (options.enableExperimentalComponentSyntax == null) {
+    options.enableExperimentalComponentSyntax = true; // Enable by default
+  }
+
   options.tokens = options.tokens === true;
   options.allowReturnOutsideFunction =
     options.allowReturnOutsideFunction === true;
@@ -51,18 +59,10 @@ function getOptions(options?: ParserOptions = {...DEFAULTS}) {
   return options;
 }
 
-function getAdapter(options: ParserOptions, code: string) {
-  return options.babel === true
-    ? new HermesToBabelAdapter(options)
-    : new HermesToESTreeAdapter(options, code);
-}
-
-// $FlowExpectedError[unclear-type]
-type BabelProgram = Object;
 declare function parse(
   code: string,
   opts: {...ParserOptions, babel: true},
-): BabelProgram;
+): BabelFile;
 // eslint-disable-next-line no-redeclare
 declare function parse(
   code: string,
@@ -75,12 +75,23 @@ declare function parse(
 export function parse(
   code: string,
   opts?: ParserOptions,
-): BabelProgram | ESTreeProgram {
+): BabelFile | ESTreeProgram {
   const options = getOptions(opts);
   const ast = HermesParser.parse(code, options);
-  const adapter = getAdapter(options, code);
 
-  return adapter.transform(ast);
+  const estreeAdapter = new HermesToESTreeAdapter(options, code);
+  const estreeAST = estreeAdapter.transform(ast);
+
+  if (options.babel !== true) {
+    return estreeAST;
+  }
+
+  const loweredESTreeAST = [
+    StripComponentSyntax.transformProgram,
+    StripFlowTypesForBabel.transformProgram,
+  ].reduce((ast, transform) => transform(ast, options), estreeAST);
+
+  return TransformESTreeToBabel.transformProgram(loweredESTreeAST, options);
 }
 
 export type {ParserOptions} from './ParserOptions';
@@ -92,3 +103,10 @@ export {FlowVisitorKeys};
 export * as astArrayMutationHelpers from './transform/astArrayMutationHelpers';
 export * as astNodeMutationHelpers from './transform/astNodeMutationHelpers';
 export {default as mutateESTreeASTForPrettier} from './utils/mutateESTreeASTForPrettier';
+
+const Transforms = {
+  stripComponentSyntax: StripComponentSyntax.transformProgram,
+  stripFlowTypesForBabel: StripFlowTypesForBabel.transformProgram,
+  stripFlowTypes: StripFlowTypes.transformProgram,
+};
+export {Transforms};

package/dist/transform/SimpleTransform.js

@@ -18,9 +18,17 @@ var _SimpleTraverser = require("../traverse/SimpleTraverser");
 
 var _astNodeMutationHelpers = require("./astNodeMutationHelpers");
 
+function setParentPointer(node, parent) {
+  if (parent != null) {
+    // $FlowExpectedError[cannot-write]
+    node.parent = parent;
+  }
+}
 /**
  * A simple class to recursively tranform AST trees.
  */
+
+
 class SimpleTransform {
   /**
    * Transform the given AST tree.
@@ -33,10 +41,18 @@ class SimpleTransform {
 
     _SimpleTraverser.SimpleTraverser.traverse(rootNode, {
       enter: (node, parent) => {
+        // Ensure the parent pointers are correctly set before entering the node.
+        setParentPointer(node, parent);
         const resultNode = options.transform(node);
 
         if (resultNode !== node) {
-          const traversedResultNode = resultNode != null ? this.transform(resultNode, options) : null;
+          let traversedResultNode = null;
+
+          if (resultNode != null) {
+            // Ensure the new node has the correct parent pointers before recursing again.
+            setParentPointer(resultNode, parent);
+            traversedResultNode = this.transform(resultNode, options);
+          }
 
           if (parent == null) {
             if (node !== rootNode) {
@@ -45,9 +61,10 @@ class SimpleTransform {
 
             resultRootNode = traversedResultNode;
           } else if (traversedResultNode == null) {
-            (0, _astNodeMutationHelpers.removeNodeOnParent)(node, parent);
+            (0, _astNodeMutationHelpers.removeNodeOnParent)(node, parent, options.visitorKeys);
           } else {
-            (0, _astNodeMutationHelpers.replaceNodeOnParent)(node, parent, traversedResultNode);
+            (0, _astNodeMutationHelpers.replaceNodeOnParent)(node, parent, traversedResultNode, options.visitorKeys);
+            setParentPointer(traversedResultNode, parent);
           }
 
           throw _SimpleTraverser.SimpleTraverser.Skip;
@@ -71,6 +88,16 @@ class SimpleTransform {
   static transform(node, options) {
     return new SimpleTransform().transform(node, options);
   }
+
+  static transformProgram(program, options) {
+    const result = SimpleTransform.transform(program, options);
+
+    if ((result == null ? void 0 : result.type) === 'Program') {
+      return result;
+    }
+
+    throw new Error('SimpleTransform.transformProgram: Expected program node.');
+  }
   /**
    * Return a new AST node with the given properties overrided if needed.
    *
@@ -84,8 +111,8 @@ class SimpleTransform {
    */
 
 
-  static nodeWith(node, overrideProps) {
-    return (0, _astNodeMutationHelpers.nodeWith)(node, overrideProps);
+  static nodeWith(node, overrideProps, visitorKeys) {
+    return (0, _astNodeMutationHelpers.nodeWith)(node, overrideProps, visitorKeys);
   }
 
 }

package/dist/transform/SimpleTransform.js.flow

@@ -11,7 +11,7 @@
 'use strict';
 
 import type {VisitorKeysType} from '../traverse/getVisitorKeys';
-import type {ESNode} from 'hermes-estree';
+import type {ESNode, Program} from 'hermes-estree';
 
 import {SimpleTraverser} from '../traverse/SimpleTraverser';
 import {
@@ -39,6 +39,13 @@ export type TransformOptions = $ReadOnly<{
   visitorKeys?: ?VisitorKeysType,
 }>;
 
+function setParentPointer(node: ESNode, parent: ?ESNode): void {
+  if (parent != null) {
+    // $FlowExpectedError[cannot-write]
+    node.parent = parent;
+  }
+}
+
 /**
  * A simple class to recursively tranform AST trees.
  */
@@ -53,10 +60,20 @@ export class SimpleTransform {
     let resultRootNode: ESNode | null = rootNode;
     SimpleTraverser.traverse(rootNode, {
       enter: (node: ESNode, parent: ?ESNode) => {
+        // Ensure the parent pointers are correctly set before entering the node.
+        setParentPointer(node, parent);
+
         const resultNode = options.transform(node);
         if (resultNode !== node) {
-          const traversedResultNode =
-            resultNode != null ? this.transform(resultNode, options) : null;
+          let traversedResultNode = null;
+
+          if (resultNode != null) {
+            // Ensure the new node has the correct parent pointers before recursing again.
+            setParentPointer(resultNode, parent);
+
+            traversedResultNode = this.transform(resultNode, options);
+          }
+
           if (parent == null) {
             if (node !== rootNode) {
               throw new Error(
@@ -65,9 +82,15 @@ export class SimpleTransform {
             }
             resultRootNode = traversedResultNode;
           } else if (traversedResultNode == null) {
-            removeNodeOnParent(node, parent);
+            removeNodeOnParent(node, parent, options.visitorKeys);
           } else {
-            replaceNodeOnParent(node, parent, traversedResultNode);
+            replaceNodeOnParent(
+              node,
+              parent,
+              traversedResultNode,
+              options.visitorKeys,
+            );
+            setParentPointer(traversedResultNode, parent);
           }
 
           throw SimpleTraverser.Skip;
@@ -88,6 +111,17 @@ export class SimpleTransform {
     return new SimpleTransform().transform(node, options);
   }
 
+  static transformProgram(
+    program: Program,
+    options: TransformOptions,
+  ): Program {
+    const result = SimpleTransform.transform(program, options);
+    if (result?.type === 'Program') {
+      return result;
+    }
+    throw new Error('SimpleTransform.transformProgram: Expected program node.');
+  }
+
   /**
    * Return a new AST node with the given properties overrided if needed.
    *
@@ -99,7 +133,11 @@ export class SimpleTransform {
    * @return Either the orginal node if the properties matched the existing node or a new node with
    *         the new properties.
    */
-  static nodeWith<T: ESNode>(node: T, overrideProps: Partial<T>): T {
-    return nodeWith<T>(node, overrideProps);
+  static nodeWith<T: ESNode>(
+    node: T,
+    overrideProps: Partial<T>,
+    visitorKeys?: VisitorKeysType,
+  ): T {
+    return nodeWith<T>(node, overrideProps, visitorKeys);
   }
 }

package/dist/transform/astNodeMutationHelpers.js

@@ -26,12 +26,12 @@ var _getVisitorKeys = require("../traverse/getVisitorKeys");
 
 var _SimpleTraverser = require("../traverse/SimpleTraverser");
 
-function getParentKey(target, parent) {
+function getParentKey(target, parent, visitorKeys) {
   if (parent == null) {
     throw new Error(`Expected parent node to be set on "${target.type}"`);
   }
 
-  for (const key of (0, _getVisitorKeys.getVisitorKeys)(parent)) {
+  for (const key of (0, _getVisitorKeys.getVisitorKeys)(parent, visitorKeys)) {
     if ((0, _getVisitorKeys.isNode)( // $FlowExpectedError[prop-missing]
     parent[key])) {
       if (parent[key] === target) {
@@ -65,8 +65,8 @@ function getParentKey(target, parent) {
  */
 
 
-function replaceNodeOnParent(originalNode, originalNodeParent, nodeToReplaceWith) {
-  const replacementParent = getParentKey(originalNode, originalNodeParent);
+function replaceNodeOnParent(originalNode, originalNodeParent, nodeToReplaceWith, visitorKeys) {
+  const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
   const parent = replacementParent.node;
 
   if (replacementParent.type === 'array') {
@@ -83,8 +83,8 @@ function replaceNodeOnParent(originalNode, originalNodeParent, nodeToReplaceWith
  */
 
 
-function removeNodeOnParent(originalNode, originalNodeParent) {
-  const replacementParent = getParentKey(originalNode, originalNodeParent);
+function removeNodeOnParent(originalNode, originalNodeParent, visitorKeys) {
+  const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
   const parent = replacementParent.node;
 
   if (replacementParent.type === 'array') {
@@ -101,8 +101,8 @@ function removeNodeOnParent(originalNode, originalNodeParent) {
  */
 
 
-function setParentPointersInDirectChildren(node) {
-  for (const key of (0, _getVisitorKeys.getVisitorKeys)(node)) {
+function setParentPointersInDirectChildren(node, visitorKeys) {
+  for (const key of (0, _getVisitorKeys.getVisitorKeys)(node, visitorKeys)) {
     if ((0, _getVisitorKeys.isNode)(node[key])) {
       node[key].parent = node;
     } else if (Array.isArray(node[key])) {
@@ -117,15 +117,16 @@ function setParentPointersInDirectChildren(node) {
  */
 
 
-function updateAllParentPointers(node) {
+function updateAllParentPointers(node, visitorKeys) {
   _SimpleTraverser.SimpleTraverser.traverse(node, {
     enter(node, parent) {
       // $FlowExpectedError[cannot-write]
       node.parent = parent;
     },
 
-    leave() {}
+    leave() {},
 
+    visitorKeys
   });
 }
 /**
@@ -135,11 +136,17 @@ function updateAllParentPointers(node) {
  */
 
 
-function nodeWith(node, overrideProps) {
+function nodeWith(node, overrideProps, visitorKeys) {
   // Check if this will actually result in a change, maintaining referential equality is important.
-  const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) => // $FlowExpectedError[incompatible-call]
-  // $FlowExpectedError[prop-missing]
-  Array.isArray(value) ? (0, _astArrayMutationHelpers.arrayIsEqual)(node[key], value) : node[key] === value);
+  const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) => {
+    if (Array.isArray(value)) {
+      // $FlowExpectedError[prop-missing]
+      return Array.isArray(node[key]) ? (0, _astArrayMutationHelpers.arrayIsEqual)(node[key], value) : false;
+    } // $FlowExpectedError[prop-missing]
+
+
+    return node[key] === value;
+  });
 
   if (willBeUnchanged) {
     return node;
@@ -151,7 +158,7 @@ function nodeWith(node, overrideProps) {
     ...overrideProps
   }; // Ensure parent pointers are correctly set within this nodes children.
 
-  setParentPointersInDirectChildren(newNode);
+  setParentPointersInDirectChildren(newNode, visitorKeys);
   return newNode;
 }
 /**
@@ -159,12 +166,12 @@ function nodeWith(node, overrideProps) {
  */
 
 
-function shallowCloneNode(node) {
+function shallowCloneNode(node, visitorKeys) {
   // $FlowExpectedError[cannot-spread-interface]
   const newNode = { ...node
   }; // Ensure parent pointers are correctly set within this nodes children.
 
-  setParentPointersInDirectChildren(newNode);
+  setParentPointersInDirectChildren(newNode, visitorKeys);
   return newNode;
 }
 /**
@@ -172,7 +179,7 @@ function shallowCloneNode(node) {
  */
 
 
-function deepCloneNode(node) {
+function deepCloneNode(node, visitorKeys) {
   const clone = JSON.parse(JSON.stringify(node, (key, value) => {
     // null out parent pointers
     if (key === 'parent') {
@@ -181,6 +188,6 @@ function deepCloneNode(node) {
 
     return value;
   }));
-  updateAllParentPointers(clone);
+  updateAllParentPointers(clone, visitorKeys);
   return clone;
 }

package/dist/transform/astNodeMutationHelpers.js.flow

@@ -11,6 +11,7 @@
 'use strict';
 
 import type {ESNode} from 'hermes-estree';
+import type {VisitorKeysType} from '../traverse/getVisitorKeys';
 
 import {
   arrayIsEqual,
@@ -23,6 +24,7 @@ import {SimpleTraverser} from '../traverse/SimpleTraverser';
 function getParentKey(
   target: ESNode,
   parent: ESNode,
+  visitorKeys?: ?VisitorKeysType,
 ): $ReadOnly<
   | {
       type: 'single',
@@ -39,7 +41,7 @@ function getParentKey(
   if (parent == null) {
     throw new Error(`Expected parent node to be set on "${target.type}"`);
   }
-  for (const key of getVisitorKeys(parent)) {
+  for (const key of getVisitorKeys(parent, visitorKeys)) {
     if (
       isNode(
         // $FlowExpectedError[prop-missing]
@@ -72,8 +74,13 @@ export function replaceNodeOnParent(
   originalNode: ESNode,
   originalNodeParent: ESNode,
   nodeToReplaceWith: ESNode,
+  visitorKeys?: ?VisitorKeysType,
 ): void {
-  const replacementParent = getParentKey(originalNode, originalNodeParent);
+  const replacementParent = getParentKey(
+    originalNode,
+    originalNodeParent,
+    visitorKeys,
+  );
   const parent = replacementParent.node;
   if (replacementParent.type === 'array') {
     // $FlowExpectedError[prop-missing]
@@ -95,8 +102,13 @@ export function replaceNodeOnParent(
 export function removeNodeOnParent(
   originalNode: ESNode,
   originalNodeParent: ESNode,
+  visitorKeys?: ?VisitorKeysType,
 ): void {
-  const replacementParent = getParentKey(originalNode, originalNodeParent);
+  const replacementParent = getParentKey(
+    originalNode,
+    originalNodeParent,
+    visitorKeys,
+  );
   const parent = replacementParent.node;
   if (replacementParent.type === 'array') {
     // $FlowExpectedError[prop-missing]
@@ -114,8 +126,11 @@ export function removeNodeOnParent(
 /**
  * Corrects the parent pointers in direct children of the given node.
  */
-export function setParentPointersInDirectChildren(node: ESNode): void {
-  for (const key: $FlowFixMe of getVisitorKeys(node)) {
+export function setParentPointersInDirectChildren(
+  node: ESNode,
+  visitorKeys?: ?VisitorKeysType,
+): void {
+  for (const key: $FlowFixMe of getVisitorKeys(node, visitorKeys)) {
     if (isNode(node[key])) {
       node[key].parent = node;
     } else if (Array.isArray(node[key])) {
@@ -129,13 +144,17 @@ export function setParentPointersInDirectChildren(node: ESNode): void {
 /**
  * Traverses the entire subtree to ensure the parent pointers are set correctly.
  */
-export function updateAllParentPointers(node: ESNode) {
+export function updateAllParentPointers(
+  node: ESNode,
+  visitorKeys?: ?VisitorKeysType,
+) {
   SimpleTraverser.traverse(node, {
     enter(node, parent) {
       // $FlowExpectedError[cannot-write]
       node.parent = parent;
     },
     leave() {},
+    visitorKeys,
   });
 }
 
@@ -144,12 +163,23 @@ export function updateAllParentPointers(node: ESNode) {
  *
  * This will only create a new object if the overrides actually result in a change.
  */
-export function nodeWith<T: ESNode>(node: T, overrideProps: Partial<T>): T {
+export function nodeWith<T: ESNode>(
+  node: T,
+  overrideProps: Partial<T>,
+  visitorKeys?: ?VisitorKeysType,
+): T {
   // Check if this will actually result in a change, maintaining referential equality is important.
-  const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) =>
-    // $FlowExpectedError[incompatible-call]
-    // $FlowExpectedError[prop-missing]
-    Array.isArray(value) ? arrayIsEqual(node[key], value) : node[key] === value,
+  const willBeUnchanged = Object.entries(overrideProps).every(
+    ([key, value]) => {
+      if (Array.isArray(value)) {
+        // $FlowExpectedError[prop-missing]
+        return Array.isArray(node[key])
+          ? arrayIsEqual(node[key], value)
+          : false;
+      }
+      // $FlowExpectedError[prop-missing]
+      return node[key] === value;
+    },
   );
   if (willBeUnchanged) {
     return node;
@@ -163,7 +193,7 @@ export function nodeWith<T: ESNode>(node: T, overrideProps: Partial<T>): T {
   };
 
   // Ensure parent pointers are correctly set within this nodes children.
-  setParentPointersInDirectChildren(newNode);
+  setParentPointersInDirectChildren(newNode, visitorKeys);
 
   return newNode;
 }
@@ -171,12 +201,15 @@ export function nodeWith<T: ESNode>(node: T, overrideProps: Partial<T>): T {
 /**
  * Shallow clones node, providing a new reference for an existing node.
  */
-export function shallowCloneNode<T: ESNode>(node: T): T {
+export function shallowCloneNode<T: ESNode>(
+  node: T,
+  visitorKeys?: ?VisitorKeysType,
+): T {
   // $FlowExpectedError[cannot-spread-interface]
   const newNode: T = {...node};
 
   // Ensure parent pointers are correctly set within this nodes children.
-  setParentPointersInDirectChildren(newNode);
+  setParentPointersInDirectChildren(newNode, visitorKeys);
 
   return newNode;
 }
@@ -184,7 +217,10 @@ export function shallowCloneNode<T: ESNode>(node: T): T {
 /**
  * Deeply clones node and its entire tree.
  */
-export function deepCloneNode<T: ESNode>(node: T): T {
+export function deepCloneNode<T: ESNode>(
+  node: T,
+  visitorKeys?: ?VisitorKeysType,
+): T {
   const clone: T = JSON.parse(
     JSON.stringify(node, (key, value) => {
       // null out parent pointers
@@ -195,7 +231,7 @@ export function deepCloneNode<T: ESNode>(node: T): T {
     }),
   );
 
-  updateAllParentPointers(clone);
+  updateAllParentPointers(clone, visitorKeys);
 
   return clone;
 }

package/dist/utils/createSyntaxError.js

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSyntaxError = createSyntaxError;
+
+function createSyntaxError(node, err) {
+  const syntaxError = new SyntaxError(err); // $FlowExpectedError[prop-missing]
+
+  syntaxError.loc = {
+    line: node.loc.start.line,
+    column: node.loc.start.column
+  };
+  return syntaxError;
+}