hermes-transform 0.9.0 → 0.10.0

package/dist/generated/special-case-node-types.js.flow

@@ -14,277 +14,10 @@ The list of exported functions here must be kept in sync with the `NODES_WITH_SP
 list in `scripts/genTransformNodeTypes` to ensure there's no duplicates
 */
 
-import type {
-  ESNode,
-  ArrowFunctionExpression as ArrowFunctionExpressionType,
-  BigIntLiteral as BigIntLiteralType,
-  BlockComment as BlockCommentType,
-  BooleanLiteral as BooleanLiteralType,
-  ClassDeclaration as ClassDeclarationType,
-  Identifier as IdentifierType,
-  LineComment as LineCommentType,
-  NullLiteral as NullLiteralType,
-  NumericLiteral as NumericLiteralType,
-  RegExpLiteral as RegExpLiteralType,
-  StringLiteral as StringLiteralType,
-  TemplateElement as TemplateElementType,
-} from 'hermes-estree';
-import type {DetachedNode, MaybeDetachedNode} from '../detachedNode';
-
-import {
-  asDetachedNode,
-  detachedProps,
-  setParentPointersInDirectChildren,
-} from '../detachedNode';
-
-// hermes adds an `id` prop which is always null, and it adds an `expression`
-// boolean which is true when the body isn't a BlockStatement.
-// No need to make consumers set these
-export type ArrowFunctionExpressionProps = {
-  +params: $ReadOnlyArray<
-    MaybeDetachedNode<ArrowFunctionExpressionType['params'][number]>,
-  >,
-  +body: MaybeDetachedNode<ArrowFunctionExpressionType['body']>,
-  +typeParameters?: ?MaybeDetachedNode<
-    ArrowFunctionExpressionType['typeParameters'],
-  >,
-  +returnType?: ?MaybeDetachedNode<ArrowFunctionExpressionType['returnType']>,
-  +predicate?: ?MaybeDetachedNode<ArrowFunctionExpressionType['predicate']>,
-  +async: ArrowFunctionExpressionType['async'],
-};
-export function ArrowFunctionExpression(props: {
-  ...$ReadOnly<ArrowFunctionExpressionProps>,
-  +parent?: ESNode,
-}): DetachedNode<ArrowFunctionExpressionType> {
-  const node = detachedProps<ArrowFunctionExpressionType>(props.parent, {
-    type: 'ArrowFunctionExpression',
-    id: null,
-    // $FlowExpectedError[incompatible-use]
-    expression: props.body.type !== 'BlockStatement',
-    params: props.params.map(n => asDetachedNode(n)),
-    body: asDetachedNode(props.body),
-    typeParameters: asDetachedNode(props.typeParameters),
-    returnType: asDetachedNode(props.returnType),
-    predicate: asDetachedNode(props.predicate),
-    async: props.async,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export type ClassDeclarationProps = {
-  +id?: ?MaybeDetachedNode<ClassDeclarationType['id']>,
-  +typeParameters?: ?MaybeDetachedNode<ClassDeclarationType['typeParameters']>,
-  +superClass?: ?MaybeDetachedNode<ClassDeclarationType['superClass']>,
-  +superTypeParameters?: ?MaybeDetachedNode<
-    ClassDeclarationType['superTypeParameters'],
-  >,
-  // make this optional as it's rarer that people would want to include them
-  +implements?: $ReadOnlyArray<
-    MaybeDetachedNode<ClassDeclarationType['implements'][number]>,
-  >,
-  // make this optional as it's rarer that people would want to include them
-  +decorators?: $ReadOnlyArray<
-    MaybeDetachedNode<ClassDeclarationType['decorators'][number]>,
-  >,
-  +body: MaybeDetachedNode<ClassDeclarationType['body']>,
-};
-export function ClassDeclaration(props: {
-  ...$ReadOnly<ClassDeclarationProps>,
-  +parent?: ESNode,
-}): DetachedNode<ClassDeclarationType> {
-  const node = detachedProps<ClassDeclarationType>(props.parent, {
-    type: 'ClassDeclaration',
-    id: asDetachedNode(props.id),
-    typeParameters: asDetachedNode(props.typeParameters),
-    superClass: asDetachedNode(props.superClass),
-    superTypeParameters: asDetachedNode(props.superTypeParameters),
-    decorators: (props.decorators ?? []).map(n => asDetachedNode(n)),
-    implements: (props.implements ?? []).map(n => asDetachedNode(n)),
-    body: asDetachedNode(props.body),
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-// pattern/flags are on a subobject in the estree spec, but are flat on the hermes types
-// also the value is supposed to be a RegExp instance
-export type RegExpLiteralProps = {
-  +pattern: RegExpLiteralType['regex']['pattern'],
-  +flags: RegExpLiteralType['regex']['flags'],
-};
-export function RegExpLiteral(props: {
-  ...$ReadOnly<RegExpLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<RegExpLiteralType> {
-  const value = new RegExp(props.pattern, props.flags);
-  return detachedProps<RegExpLiteralType>(props.parent, {
-    type: 'Literal',
-    value,
-    raw: value.toString(),
-    regex: {
-      pattern: props.pattern,
-      flags: props.flags,
-    },
-  });
-}
-
-// raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
-export type TemplateElementProps = {
-  +tail: TemplateElementType['tail'],
-  +cooked: TemplateElementType['value']['cooked'],
-  +raw: TemplateElementType['value']['raw'],
-};
-export function TemplateElement(props: {
-  ...$ReadOnly<TemplateElementProps>,
-  +parent?: ESNode,
-}): DetachedNode<TemplateElementType> {
-  return detachedProps<TemplateElementType>(props.parent, {
-    type: 'TemplateElement',
-    tail: props.tail,
-    value: {
-      cooked: props.cooked,
-      raw: props.raw,
-    },
-  });
-}
-
-// Identifier has a bunch of stuff that usually you don't want to provide - so we have
-// this manual def to allow us to default some values
-export type IdentifierProps = {
-  +name: IdentifierType['name'],
-  +typeAnnotation?: ?MaybeDetachedNode<IdentifierType['typeAnnotation']>,
-  +optional?: IdentifierType['optional'],
-};
-export function Identifier(props: {
-  ...$ReadOnly<IdentifierProps>,
-  +parent?: ESNode,
-}): DetachedNode<IdentifierType> {
-  const node = detachedProps<IdentifierType>(props.parent, {
-    type: 'Identifier',
-    name: props.name,
-    optional: props.optional ?? false,
-    typeAnnotation: asDetachedNode(props.typeAnnotation),
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-//
-// Literals require a "raw" which is added by the estree transform, not hermes.
-//
-
-export type BigIntLiteralProps = {
-  +value: $FlowFixMe /* bigint | null */,
-  /**
-   * Only set this if you want to use a source-code representation like 1_1n, etc.
-   * By default "raw" will just be the exact number you've given.
-   */
-  +raw?: NumericLiteralType['raw'],
-};
-export function BigIntLiteral(props: {
-  ...$ReadOnly<BigIntLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<BigIntLiteralType> {
-  const node = detachedProps<BigIntLiteralType>(props.parent, {
-    type: 'Literal',
-    value: props.value,
-    raw: props.raw ?? `${props.value}n`,
-    bigint: `${props.value}`,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export type BooleanLiteralProps = {
-  +value: BooleanLiteralType['value'],
-};
-export function BooleanLiteral(props: {
-  ...$ReadOnly<BooleanLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<BooleanLiteralType> {
-  return detachedProps<BooleanLiteralType>(props.parent, {
-    type: 'Literal',
-    raw: props.value ? 'true' : 'false',
-    value: props.value,
-  });
-}
-
-export type NumericLiteralProps = {
-  +value: NumericLiteralType['value'],
-  /**
-   * Only set this if you want to use a source-code representation like 1e100, 0x11, 1_1, etc.
-   * By default "raw" will just be the exact number you've given.
-   */
-  +raw?: NumericLiteralType['raw'],
-};
-export function NumericLiteral(props: {
-  ...$ReadOnly<NumericLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<NumericLiteralType> {
-  return detachedProps<NumericLiteralType>(props.parent, {
-    type: 'Literal',
-    value: props.value,
-    raw: props.raw ?? `${props.value}`,
-  });
-}
-
-export type NullLiteralProps = {};
-export function NullLiteral(
-  props: {
-    +parent?: ESNode,
-  } = {...null},
-): DetachedNode<NullLiteralType> {
-  return detachedProps<NullLiteralType>(props.parent, {
-    type: 'Literal',
-    value: null,
-    raw: 'null',
-  });
-}
-
-export type StringLiteralProps = {
-  +value: StringLiteralType['value'],
-  +raw?: StringLiteralType['raw'],
-};
-export function StringLiteral(props: {
-  ...$ReadOnly<StringLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<StringLiteralType> {
-  const hasSingleQuote = props.value.includes('"');
-  const hasDoubleQuote = props.value.includes("'");
-  let raw = props.raw;
-  if (raw == null) {
-    if (hasSingleQuote && hasDoubleQuote) {
-      raw = `'${props.value.replace(/'/g, "\\'")}'`;
-    } else if (hasSingleQuote) {
-      raw = `"${props.value}"`;
-    } else {
-      raw = `'${props.value}'`;
-    }
-  }
-  return detachedProps<StringLiteralType>(props.parent, {
-    type: 'Literal',
-    raw,
-    value: props.value,
-  });
-}
-
-export type LineCommentProps = {+value: string};
-export function LineComment(props: LineCommentProps): LineCommentType {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-return]
-  return detachedProps<LineCommentType>(undefined, {
-    type: 'Line',
-    value: props.value,
-  });
-}
-
-export type BlockCommentProps = {+value: string};
-export function BlockComment(props: BlockCommentProps): BlockCommentType {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-return]
-  return detachedProps<BlockCommentType>(undefined, {
-    type: 'Block',
-    value: props.value,
-  });
-}
+export * from './special-case-node-types/Comment';
+export * from './special-case-node-types/DeclareExportDeclaration';
+export * from './special-case-node-types/ExportNamedDeclaration';
+export * from './special-case-node-types/Literal';
+export * from './special-case-node-types/ObjectTypeProperty';
+export * from './special-case-node-types/misc';
+export * from './special-case-node-types/Property';

package/dist/index.js

@@ -12,11 +12,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.traverseWithContext = exports.traverse = exports.transform = exports.t = exports.SimpleTraverser = void 0;
+exports.traverseWithContext = exports.traverse = exports.transform = exports.t = exports.print = exports.parse = exports.cloneJSDocCommentsToNewNode = exports.asDetachedNode = exports.SimpleTraverser = void 0;
 
-var _SimpleTraverser = require("./traverse/SimpleTraverser");
+var _hermesParser = require("hermes-parser");
 
-exports.SimpleTraverser = _SimpleTraverser.SimpleTraverser;
+exports.SimpleTraverser = _hermesParser.SimpleTraverser;
 
 var _traverse = require("./traverse/traverse");
 
@@ -27,10 +27,26 @@ var _transform = require("./transform/transform");
 
 exports.transform = _transform.transform;
 
+var _parse = require("./transform/parse");
+
+exports.parse = _parse.parse;
+
+var _print = require("./transform/print");
+
+exports.print = _print.print;
+
 var _t = _interopRequireWildcard(require("./generated/node-types"));
 
 exports.t = _t;
 
+var _detachedNode = require("./detachedNode");
+
+exports.asDetachedNode = _detachedNode.asDetachedNode;
+
+var _comments = require("./transform/comments/comments");
+
+exports.cloneJSDocCommentsToNewNode = _comments.cloneJSDocCommentsToNewNode;
+
 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); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/index.js.flow

@@ -13,9 +13,13 @@
 export type {TraversalContextBase, Visitor} from './traverse/traverse';
 export type {TransformVisitor} from './transform/transform';
 export type {TransformContext} from './transform/TransformContext';
-export type {DetachedNode} from './detachedNode';
+export type {DetachedNode, MaybeDetachedNode} from './detachedNode';
 
-export {SimpleTraverser} from './traverse/SimpleTraverser';
+export {SimpleTraverser} from 'hermes-parser';
 export {traverse, traverseWithContext} from './traverse/traverse';
 export {transform} from './transform/transform';
+export {parse} from './transform/parse';
+export {print} from './transform/print';
 export * as t from './generated/node-types';
+export {asDetachedNode} from './detachedNode';
+export {cloneJSDocCommentsToNewNode} from './transform/comments/comments';

package/dist/transform/TransformContext.js

@@ -68,7 +68,7 @@ function getTransformContext() {
 
       return nodes.map(node => {
         if (node == null) {
-          // $FlowExpectedError[incompatible-call]
+          // $FlowExpectedError[incompatible-return]
           return node;
         }
 

package/dist/transform/TransformContext.js.flow

@@ -362,9 +362,9 @@ export function getTransformContext(): TransformContextAdditions {
         return null;
       }
 
-      return nodes.map(node => {
+      return nodes.map((node): DetachedNode<?ESNode> => {
         if (node == null) {
-          // $FlowExpectedError[incompatible-call]
+          // $FlowExpectedError[incompatible-return]
           return node;
         }
         return shallowCloneNode<T>(node, {});

package/dist/transform/comments/comments.js

@@ -10,6 +10,7 @@ exports.appendCommentToSource = appendCommentToSource;
 exports.attachComments = attachComments;
 exports.cloneComment = cloneComment;
 exports.cloneCommentWithMarkers = cloneCommentWithMarkers;
+exports.cloneJSDocCommentsToNewNode = cloneJSDocCommentsToNewNode;
 exports.getCommentsForNode = getCommentsForNode;
 exports.getLeadingCommentsForNode = getLeadingCommentsForNode;
 exports.getTrailingCommentsForNode = getTrailingCommentsForNode;
@@ -26,6 +27,8 @@ var _printerEstree = _interopRequireDefault(require("./prettier/language-js/prin
 
 var _util = require("./prettier/common/util");
 
+var _hermesEstree = require("hermes-estree");
+
 var _os = require("os");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -59,6 +62,14 @@ function moveCommentsToNewNode(oldNode, newNode) {
   setCommentsOnNode(oldNode, []);
 }
 
+function cloneJSDocCommentsToNewNode(oldNode, newNode) {
+  const comments = getCommentsForNode(oldNode).filter(comment => {
+    return (0, _hermesEstree.isBlockComment)(comment) && // JSDoc comments always start with an extra asterisk
+    comment.value.startsWith('*');
+  });
+  setCommentsOnNode(newNode, comments.map(cloneCommentWithMarkers));
+}
+
 function setCommentsOnNode(node, comments) {
   // $FlowExpectedError - this property is secretly added by prettier.
   node.comments = comments;

package/dist/transform/comments/comments.js.flow

@@ -9,7 +9,7 @@
  */
 
 import type {Comment, ESNode, Program} from 'hermes-estree';
-import type {DetachedNode} from '../../detachedNode';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
 
 // $FlowExpectedError[untyped-import]
 import {attach as untypedAttach} from './prettier/main/comments';
@@ -23,6 +23,7 @@ import {
   // $FlowExpectedError[untyped-import]
   addTrailingComment as untypedAddTrailingComment,
 } from './prettier/common/util';
+import {isBlockComment} from 'hermes-estree';
 import {EOL} from 'os';
 
 export type Options = $ReadOnly<{}>;
@@ -54,6 +55,20 @@ export function moveCommentsToNewNode(
   setCommentsOnNode(oldNode, []);
 }
 
+export function cloneJSDocCommentsToNewNode(
+  oldNode: ESNode,
+  newNode: MaybeDetachedNode<ESNode>,
+): void {
+  const comments = getCommentsForNode(oldNode).filter(comment => {
+    return (
+      isBlockComment(comment) &&
+      // JSDoc comments always start with an extra asterisk
+      comment.value.startsWith('*')
+    );
+  });
+  setCommentsOnNode(newNode, comments.map(cloneCommentWithMarkers));
+}
+
 export function setCommentsOnNode(
   node: ESNode | DetachedNode<ESNode>,
   comments: $ReadOnlyArray<Comment>,

package/dist/transform/comments/prettier/main/comments.js

@@ -50,7 +50,7 @@ function getSortedChildNodes(node, options, resultArray) {
     return childNodesCache.get(node);
   }
 
-  const childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || typeof node === 'object' && Object.entries(node).filter(([key]) => key !== 'enclosingNode' && key !== 'precedingNode' && key !== 'followingNode' && key !== 'tokens' && key !== 'comments').map(([, value]) => value);
+  const childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || typeof node === 'object' && Object.entries(node).filter(([key]) => key !== 'enclosingNode' && key !== 'precedingNode' && key !== 'followingNode' && key !== 'tokens' && key !== 'comments' && key !== 'parent').map(([, value]) => value);
 
   if (!childNodes) {
     return;

package/dist/transform/comments/prettier/main/comments.js.flow

@@ -57,7 +57,8 @@ function getSortedChildNodes(node, options, resultArray) {
             key !== 'precedingNode' &&
             key !== 'followingNode' &&
             key !== 'tokens' &&
-            key !== 'comments',
+            key !== 'comments' &&
+            key !== 'parent',
         )
         .map(([, value]) => value));
 

package/dist/transform/mutations/InsertStatement.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createInsertStatementMutation = createInsertStatementMutation;
 exports.performInsertStatementMutation = performInsertStatementMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _getStatementParent = require("./utils/getStatementParent");
 
@@ -58,13 +58,13 @@ function performInsertStatementMutation(mutationContext, mutation) {
     switch (mutation.side) {
       case 'before':
         {
-          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
+          parent[insertionParent.key] = _hermesParser.astArrayMutationHelpers.insertInArray(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
           break;
         }
 
       case 'after':
         {
-          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex + 1, mutation.nodesToInsert);
+          parent[insertionParent.key] = _hermesParser.astArrayMutationHelpers.insertInArray(parent[insertionParent.key], insertionParent.targetIndex + 1, mutation.nodesToInsert);
           break;
         }
     }

package/dist/transform/mutations/InsertStatement.js.flow

@@ -12,7 +12,7 @@ import type {ESNode, ModuleDeclaration, Statement} from 'hermes-estree';
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {insertInArray} from './utils/arrayUtils';
+import {astArrayMutationHelpers} from 'hermes-parser';
 import {getStatementParent} from './utils/getStatementParent';
 import {isValidModuleDeclarationParent} from './utils/isValidModuleDeclarationParent';
 import {InvalidInsertionError} from '../Errors';
@@ -73,7 +73,7 @@ export function performInsertStatementMutation(
     } = insertionParent.parent;
     switch (mutation.side) {
       case 'before': {
-        parent[insertionParent.key] = insertInArray(
+        parent[insertionParent.key] = astArrayMutationHelpers.insertInArray(
           parent[insertionParent.key],
           insertionParent.targetIndex,
           mutation.nodesToInsert,
@@ -82,7 +82,7 @@ export function performInsertStatementMutation(
       }
 
       case 'after': {
-        parent[insertionParent.key] = insertInArray(
+        parent[insertionParent.key] = astArrayMutationHelpers.insertInArray(
           parent[insertionParent.key],
           insertionParent.targetIndex + 1,
           mutation.nodesToInsert,

package/dist/transform/mutations/RemoveComment.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRemoveCommentMutation = createRemoveCommentMutation;
 exports.performRemoveCommentMutations = performRemoveCommentMutations;
 
-var _SimpleTraverser = require("../../traverse/SimpleTraverser");
+var _hermesParser = require("hermes-parser");
 
 var _comments = require("../comments/comments");
 
@@ -33,7 +33,7 @@ function performRemoveCommentMutations(ast, mutations) {
 
   const commentsToRemove = new Set(mutations.map(m => m.comment));
 
-  _SimpleTraverser.SimpleTraverser.traverse(ast, {
+  _hermesParser.SimpleTraverser.traverse(ast, {
     enter(node) {
       if (node === ast) {
         return;
@@ -56,7 +56,7 @@ function performRemoveCommentMutations(ast, mutations) {
 
       if (commentsToRemove.size === 0) {
         // no more comments to process - so we can exit traversal
-        throw _SimpleTraverser.SimpleTraverserBreak;
+        throw _hermesParser.SimpleTraverserBreak;
       }
     },
 

package/dist/transform/mutations/RemoveComment.js.flow

@@ -9,10 +9,8 @@
  */
 
 import type {Comment, Program} from 'hermes-estree';
-import {
-  SimpleTraverser,
-  SimpleTraverserBreak,
-} from '../../traverse/SimpleTraverser';
+
+import {SimpleTraverser, SimpleTraverserBreak} from 'hermes-parser';
 import {getCommentsForNode, setCommentsOnNode} from '../comments/comments';
 
 export type RemoveCommentMutation = $ReadOnly<{
@@ -70,7 +68,7 @@ function intersectSets<T>(
   first: $ReadOnlySet<T>,
   other: $ReadOnlySet<T>,
 ): Set<T> {
-  const ret = new Set();
+  const ret = new Set<T>();
   for (const value of first) {
     if (other.has(value)) {
       ret.add(value);

package/dist/transform/mutations/RemoveNode.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRemoveNodeMutation = createRemoveNodeMutation;
 exports.performRemoveNodeMutation = performRemoveNodeMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _Errors = require("../Errors");
 
@@ -187,6 +187,6 @@ function performRemoveNodeMutation(mutationContext, mutation) {
   mutationContext.markDeletion(mutation.node);
   mutationContext.markMutation(removalParent.parent, removalParent.key);
   const parent = removalParent.parent;
-  parent[removalParent.key] = (0, _arrayUtils.removeFromArray)(parent[removalParent.key], removalParent.targetIndex);
+  parent[removalParent.key] = _hermesParser.astArrayMutationHelpers.removeFromArray(parent[removalParent.key], removalParent.targetIndex);
   return removalParent.parent;
 }

package/dist/transform/mutations/RemoveNode.js.flow

@@ -30,7 +30,7 @@ import type {
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {removeFromArray} from './utils/arrayUtils';
+import {astArrayMutationHelpers} from 'hermes-parser';
 import {InvalidRemovalError} from '../Errors';
 
 export type RemoveNodeMutation = $ReadOnly<{
@@ -281,7 +281,7 @@ export function performRemoveNodeMutation(
   const parent: interface {
     [string]: $ReadOnlyArray<DetachedNode<RemoveNodeMutation['node']>>,
   } = removalParent.parent;
-  parent[removalParent.key] = removeFromArray(
+  parent[removalParent.key] = astArrayMutationHelpers.removeFromArray(
     parent[removalParent.key],
     removalParent.targetIndex,
   );

package/dist/transform/mutations/RemoveStatement.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRemoveStatementMutation = createRemoveStatementMutation;
 exports.performRemoveStatementMutation = performRemoveStatementMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _getStatementParent = require("./utils/getStatementParent");
 
@@ -39,7 +39,7 @@ function performRemoveStatementMutation(mutationContext, mutation) {
 
   if (removalParent.type === 'array') {
     const parent = removalParent.parent;
-    parent[removalParent.key] = (0, _arrayUtils.removeFromArray)(parent[removalParent.key], removalParent.targetIndex);
+    parent[removalParent.key] = _hermesParser.astArrayMutationHelpers.removeFromArray(parent[removalParent.key], removalParent.targetIndex);
   } else {
     // The parent has a 1:1 relationship on this key, so we can't just
     // remove the node. Instead we replace it with an empty block statement.

package/dist/transform/mutations/RemoveStatement.js.flow

@@ -12,7 +12,7 @@ import type {ESNode, ModuleDeclaration, Statement} from 'hermes-estree';
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {removeFromArray} from './utils/arrayUtils';
+import {astArrayMutationHelpers} from 'hermes-parser';
 import {getStatementParent} from './utils/getStatementParent';
 import * as t from '../../generated/node-types';
 
@@ -43,7 +43,7 @@ export function performRemoveStatementMutation(
     const parent: interface {
       [string]: $ReadOnlyArray<DetachedNode<Statement | ModuleDeclaration>>,
     } = removalParent.parent;
-    parent[removalParent.key] = removeFromArray(
+    parent[removalParent.key] = astArrayMutationHelpers.removeFromArray(
       parent[removalParent.key],
       removalParent.targetIndex,
     );