hermes-transform 0.36.1 → 0.37.0

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

@@ -28,14 +28,14 @@ import {
 } from '../../detachedNode';
 
 export type DestructuringObjectPropertyProps = {
-  +key: MaybeDetachedNode<DestructuringObjectPropertyType['key']>,
-  +value: MaybeDetachedNode<DestructuringObjectPropertyType['value']>,
-  +computed: DestructuringObjectPropertyType['computed'],
-  +shorthand: DestructuringObjectPropertyType['shorthand'],
+  readonly key: MaybeDetachedNode<DestructuringObjectPropertyType['key']>,
+  readonly value: MaybeDetachedNode<DestructuringObjectPropertyType['value']>,
+  readonly computed: DestructuringObjectPropertyType['computed'],
+  readonly shorthand: DestructuringObjectPropertyType['shorthand'],
 };
 export function DestructuringObjectProperty(props: {
-  ...$ReadOnly<DestructuringObjectPropertyProps>,
-  +parent?: ESNode,
+  ...Readonly<DestructuringObjectPropertyProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<DestructuringObjectPropertyType> {
   const node = detachedProps<DestructuringObjectPropertyType>(props.parent, {
     type: 'Property',
@@ -51,16 +51,16 @@ export function DestructuringObjectProperty(props: {
 }
 
 export type DestructuringObjectPropertyWithNonShorthandStaticNameProps = {
-  +key: MaybeDetachedNode<
+  readonly key: MaybeDetachedNode<
     DestructuringObjectPropertyWithNonShorthandStaticNameType['key'],
   >,
-  +value: MaybeDetachedNode<
+  readonly value: MaybeDetachedNode<
     DestructuringObjectPropertyWithNonShorthandStaticNameType['value'],
   >,
 };
 export function DestructuringObjectPropertyWithNonShorthandStaticName(props: {
-  ...$ReadOnly<DestructuringObjectPropertyWithNonShorthandStaticNameProps>,
-  +parent?: ESNode,
+  ...Readonly<DestructuringObjectPropertyWithNonShorthandStaticNameProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<DestructuringObjectPropertyWithNonShorthandStaticNameType> {
   const node =
     detachedProps<DestructuringObjectPropertyWithNonShorthandStaticNameType>(
@@ -80,16 +80,16 @@ export function DestructuringObjectPropertyWithNonShorthandStaticName(props: {
 }
 
 export type DestructuringObjectPropertyWithShorthandStaticNameProps = {
-  +key: MaybeDetachedNode<
+  readonly key: MaybeDetachedNode<
     DestructuringObjectPropertyWithShorthandStaticNameType['key'],
   >,
-  +value: MaybeDetachedNode<
+  readonly value: MaybeDetachedNode<
     DestructuringObjectPropertyWithShorthandStaticNameType['value'],
   >,
 };
 export function DestructuringObjectPropertyWithShorthandStaticName(props: {
-  ...$ReadOnly<DestructuringObjectPropertyWithShorthandStaticNameProps>,
-  +parent?: ESNode,
+  ...Readonly<DestructuringObjectPropertyWithShorthandStaticNameProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<DestructuringObjectPropertyWithShorthandStaticNameType> {
   const node =
     detachedProps<DestructuringObjectPropertyWithShorthandStaticNameType>(
@@ -109,16 +109,16 @@ export function DestructuringObjectPropertyWithShorthandStaticName(props: {
 }
 
 export type DestructuringObjectPropertyWithComputedNameProps = {
-  +key: MaybeDetachedNode<
+  readonly key: MaybeDetachedNode<
     DestructuringObjectPropertyWithComputedNameType['key'],
   >,
-  +value: MaybeDetachedNode<
+  readonly value: MaybeDetachedNode<
     DestructuringObjectPropertyWithComputedNameType['value'],
   >,
 };
 export function DestructuringObjectPropertyWithComputedName(props: {
-  ...$ReadOnly<DestructuringObjectPropertyWithComputedNameProps>,
-  +parent?: ESNode,
+  ...Readonly<DestructuringObjectPropertyWithComputedNameProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<DestructuringObjectPropertyWithComputedNameType> {
   const node = detachedProps<DestructuringObjectPropertyWithComputedNameType>(
     props.parent,
@@ -137,16 +137,16 @@ export function DestructuringObjectPropertyWithComputedName(props: {
 }
 
 export type ObjectPropertyProps = {
-  +key: MaybeDetachedNode<ObjectPropertyType['key']>,
-  +value: MaybeDetachedNode<ObjectPropertyType['value']>,
-  +kind: ObjectPropertyType['kind'],
-  +computed: ObjectPropertyType['computed'],
-  +method: ObjectPropertyType['method'],
-  +shorthand: ObjectPropertyType['shorthand'],
+  readonly key: MaybeDetachedNode<ObjectPropertyType['key']>,
+  readonly value: MaybeDetachedNode<ObjectPropertyType['value']>,
+  readonly kind: ObjectPropertyType['kind'],
+  readonly computed: ObjectPropertyType['computed'],
+  readonly method: ObjectPropertyType['method'],
+  readonly shorthand: ObjectPropertyType['shorthand'],
 };
 export function ObjectProperty(props: {
-  ...$ReadOnly<ObjectPropertyProps>,
-  +parent?: ESNode,
+  ...Readonly<ObjectPropertyProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<ObjectPropertyType> {
   const node = detachedProps<ObjectPropertyType>(props.parent, {
     type: 'Property',
@@ -162,16 +162,18 @@ export function ObjectProperty(props: {
 }
 
 export type ObjectPropertyWithNonShorthandStaticNameProps = {
-  +key: MaybeDetachedNode<ObjectPropertyWithNonShorthandStaticNameType['key']>,
-  +value: MaybeDetachedNode<
+  readonly key: MaybeDetachedNode<
+    ObjectPropertyWithNonShorthandStaticNameType['key'],
+  >,
+  readonly value: MaybeDetachedNode<
     ObjectPropertyWithNonShorthandStaticNameType['value'],
   >,
-  +kind: ObjectPropertyWithNonShorthandStaticNameType['kind'],
-  +method: ObjectPropertyWithNonShorthandStaticNameType['method'],
+  readonly kind: ObjectPropertyWithNonShorthandStaticNameType['kind'],
+  readonly method: ObjectPropertyWithNonShorthandStaticNameType['method'],
 };
 export function ObjectPropertyWithNonShorthandStaticName(props: {
-  ...$ReadOnly<ObjectPropertyWithNonShorthandStaticNameProps>,
-  +parent?: ESNode,
+  ...Readonly<ObjectPropertyWithNonShorthandStaticNameProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<ObjectPropertyWithNonShorthandStaticNameType> {
   const node = detachedProps<ObjectPropertyWithNonShorthandStaticNameType>(
     props.parent,
@@ -190,12 +192,16 @@ export function ObjectPropertyWithNonShorthandStaticName(props: {
 }
 
 export type ObjectPropertyWithShorthandStaticNameProps = {
-  +key: MaybeDetachedNode<ObjectPropertyWithShorthandStaticNameType['key']>,
-  +value: MaybeDetachedNode<ObjectPropertyWithShorthandStaticNameType['value']>,
+  readonly key: MaybeDetachedNode<
+    ObjectPropertyWithShorthandStaticNameType['key'],
+  >,
+  readonly value: MaybeDetachedNode<
+    ObjectPropertyWithShorthandStaticNameType['value'],
+  >,
 };
 export function ObjectPropertyWithShorthandStaticName(props: {
-  ...$ReadOnly<ObjectPropertyWithShorthandStaticNameProps>,
-  +parent?: ESNode,
+  ...Readonly<ObjectPropertyWithShorthandStaticNameProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<ObjectPropertyWithShorthandStaticNameType> {
   const node = detachedProps<ObjectPropertyWithShorthandStaticNameType>(
     props.parent,
@@ -214,14 +220,16 @@ export function ObjectPropertyWithShorthandStaticName(props: {
 }
 
 export type ObjectPropertyWithComputedNameProps = {
-  +key: MaybeDetachedNode<ObjectPropertyWithComputedNameType['key']>,
-  +value: MaybeDetachedNode<ObjectPropertyWithComputedNameType['value']>,
-  +kind: ObjectPropertyWithComputedNameType['kind'],
-  +method: ObjectPropertyWithComputedNameType['method'],
+  readonly key: MaybeDetachedNode<ObjectPropertyWithComputedNameType['key']>,
+  readonly value: MaybeDetachedNode<
+    ObjectPropertyWithComputedNameType['value'],
+  >,
+  readonly kind: ObjectPropertyWithComputedNameType['kind'],
+  readonly method: ObjectPropertyWithComputedNameType['method'],
 };
 export function ObjectPropertyWithComputedName(props: {
-  ...$ReadOnly<ObjectPropertyWithComputedNameProps>,
-  +parent?: ESNode,
+  ...Readonly<ObjectPropertyWithComputedNameProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<ObjectPropertyWithComputedNameType> {
   const node = detachedProps<ObjectPropertyWithComputedNameType>(props.parent, {
     type: 'Property',

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

@@ -14,28 +14,15 @@ exports.TemplateElement = TemplateElement;
 
 var _detachedNode = require("../../detachedNode");
 
-/**
- * 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
- */
 function ArrowFunctionExpression(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ArrowFunctionExpression',
     id: null,
-    // $FlowExpectedError[incompatible-use]
     expression: props.body.type !== 'BlockStatement',
     params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
     body: (0, _detachedNode.asDetachedNode)(props.body),
-    // $FlowFixMe[incompatible-type]
     typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
-    // $FlowFixMe[incompatible-type]
     returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
-    // $FlowFixMe[incompatible-type]
     predicate: (0, _detachedNode.asDetachedNode)(props.predicate),
     async: props.async
   });
@@ -48,13 +35,9 @@ function ClassDeclaration(props) {
 
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ClassDeclaration',
-    // $FlowFixMe[incompatible-type]
     id: (0, _detachedNode.asDetachedNode)(props.id),
-    // $FlowFixMe[incompatible-type]
     typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
-    // $FlowFixMe[incompatible-type]
     superClass: (0, _detachedNode.asDetachedNode)(props.superClass),
-    // $FlowFixMe[incompatible-type]
     superTypeArguments: (0, _detachedNode.asDetachedNode)(props.superTypeArguments),
     decorators: ((_props$decorators = props.decorators) != null ? _props$decorators : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
     implements: ((_props$implements = props.implements) != null ? _props$implements : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
@@ -62,8 +45,7 @@ function ClassDeclaration(props) {
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
-} // raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
-
+}
 
 function TemplateElement(props) {
   return (0, _detachedNode.detachedProps)(props.parent, {
@@ -74,9 +56,7 @@ function TemplateElement(props) {
       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
-
+}
 
 function Identifier(props) {
   var _props$optional;
@@ -85,14 +65,11 @@ function Identifier(props) {
     type: 'Identifier',
     name: props.name,
     optional: (_props$optional = props.optional) != null ? _props$optional : false,
-    // $FlowFixMe[incompatible-type]
     typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
-} // Program 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
-
+}
 
 function Program(props) {
   var _props$sourceType, _props$tokens, _props$comments;
@@ -103,17 +80,13 @@ function Program(props) {
     body: props.body.map(n => (0, _detachedNode.asDetachedNode)(n)),
     tokens: (_props$tokens = props.tokens) != null ? _props$tokens : [],
     comments: (_props$comments = props.comments) != null ? _props$comments : [],
-    interpreter: props.interpreter != null ? // $FlowFixMe[incompatible-type]
-    (0, _detachedNode.asDetachedNode)({
+    interpreter: props.interpreter != null ? (0, _detachedNode.asDetachedNode)({
       type: 'InterpreterDirective',
       value: props.interpreter
     }) : null,
     docblock: props.docblock
   });
-} // the type annotation is stored on the Identifier's typeAnnotation
-// which is super awkward to work with and type - so we flatten the input
-// and put it in the right spot after
-
+}
 
 function DeclareFunction(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
@@ -126,7 +99,6 @@ function DeclareFunction(props) {
         typeAnnotation: (0, _detachedNode.asDetachedNode)(props.functionType)
       })
     }),
-    // $FlowFixMe[incompatible-type]
     predicate: (0, _detachedNode.asDetachedNode)(props.predicate)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
@@ -145,8 +117,7 @@ function MemberExpression(props) {
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
-} // Ignore the hermes-specific `implicit` property.
-
+}
 
 function BlockStatement(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {

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

@@ -43,20 +43,24 @@ import {
 // boolean which is true when the body isn't a BlockStatement.
 // No need to make consumers set these
 export type ArrowFunctionExpressionProps = {
-  +params: $ReadOnlyArray<
+  readonly params: ReadonlyArray<
     MaybeDetachedNode<ArrowFunctionExpressionType['params'][number]>,
   >,
-  +body: MaybeDetachedNode<ArrowFunctionExpressionType['body']>,
-  +typeParameters?: ?MaybeDetachedNode<
+  readonly body: MaybeDetachedNode<ArrowFunctionExpressionType['body']>,
+  readonly typeParameters?: ?MaybeDetachedNode<
     ArrowFunctionExpressionType['typeParameters'],
   >,
-  +returnType?: ?MaybeDetachedNode<ArrowFunctionExpressionType['returnType']>,
-  +predicate?: ?MaybeDetachedNode<ArrowFunctionExpressionType['predicate']>,
-  +async: ArrowFunctionExpressionType['async'],
+  readonly returnType?: ?MaybeDetachedNode<
+    ArrowFunctionExpressionType['returnType'],
+  >,
+  readonly predicate?: ?MaybeDetachedNode<
+    ArrowFunctionExpressionType['predicate'],
+  >,
+  readonly async: ArrowFunctionExpressionType['async'],
 };
 export function ArrowFunctionExpression(props: {
-  ...$ReadOnly<ArrowFunctionExpressionProps>,
-  +parent?: ESNode,
+  ...Readonly<ArrowFunctionExpressionProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<ArrowFunctionExpressionType> {
   const node = detachedProps<ArrowFunctionExpressionType>(props.parent, {
     type: 'ArrowFunctionExpression',
@@ -78,25 +82,27 @@ export function ArrowFunctionExpression(props: {
 }
 
 export type ClassDeclarationProps = {
-  +id?: ?MaybeDetachedNode<ClassDeclarationType['id']>,
-  +typeParameters?: ?MaybeDetachedNode<ClassDeclarationType['typeParameters']>,
-  +superClass?: ?MaybeDetachedNode<ClassDeclarationType['superClass']>,
-  +superTypeArguments?: ?MaybeDetachedNode<
+  readonly id?: ?MaybeDetachedNode<ClassDeclarationType['id']>,
+  readonly typeParameters?: ?MaybeDetachedNode<
+    ClassDeclarationType['typeParameters'],
+  >,
+  readonly superClass?: ?MaybeDetachedNode<ClassDeclarationType['superClass']>,
+  readonly superTypeArguments?: ?MaybeDetachedNode<
     ClassDeclarationType['superTypeArguments'],
   >,
   // make this optional as it's rarer that people would want to include them
-  +implements?: $ReadOnlyArray<
+  readonly implements?: ReadonlyArray<
     MaybeDetachedNode<ClassDeclarationType['implements'][number]>,
   >,
   // make this optional as it's rarer that people would want to include them
-  +decorators?: $ReadOnlyArray<
+  readonly decorators?: ReadonlyArray<
     MaybeDetachedNode<ClassDeclarationType['decorators'][number]>,
   >,
-  +body: MaybeDetachedNode<ClassDeclarationType['body']>,
+  readonly body: MaybeDetachedNode<ClassDeclarationType['body']>,
 };
 export function ClassDeclaration(props: {
-  ...$ReadOnly<ClassDeclarationProps>,
-  +parent?: ESNode,
+  ...Readonly<ClassDeclarationProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<ClassDeclarationType> {
   const node = detachedProps<ClassDeclarationType>(props.parent, {
     type: 'ClassDeclaration',
@@ -118,13 +124,13 @@ export function ClassDeclaration(props: {
 
 // 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'],
+  readonly tail: TemplateElementType['tail'],
+  readonly cooked: TemplateElementType['value']['cooked'],
+  readonly raw: TemplateElementType['value']['raw'],
 };
 export function TemplateElement(props: {
-  ...$ReadOnly<TemplateElementProps>,
-  +parent?: ESNode,
+  ...Readonly<TemplateElementProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<TemplateElementType> {
   return detachedProps<TemplateElementType>(props.parent, {
     type: 'TemplateElement',
@@ -139,13 +145,15 @@ export function TemplateElement(props: {
 // 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'],
+  readonly name: IdentifierType['name'],
+  readonly typeAnnotation?: ?MaybeDetachedNode<
+    IdentifierType['typeAnnotation'],
+  >,
+  readonly optional?: IdentifierType['optional'],
 };
 export function Identifier(props: {
-  ...$ReadOnly<IdentifierProps>,
-  +parent?: ESNode,
+  ...Readonly<IdentifierProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<IdentifierType> {
   const node = detachedProps<IdentifierType>(props.parent, {
     type: 'Identifier',
@@ -161,15 +169,15 @@ export function Identifier(props: {
 // Program 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 ProgramProps = {
-  +sourceType?: ?ProgramType['sourceType'],
-  +body: $ReadOnlyArray<MaybeDetachedNode<ProgramType['body'][number]>>,
-  +tokens?: ?$ReadOnlyArray<MaybeDetachedNode<TokenType>>,
-  +comments?: ?$ReadOnlyArray<MaybeDetachedNode<CommentType>>,
-  +interpreter?: ?string,
-  +docblock?: ?DocblockMetadataType,
+  readonly sourceType?: ?ProgramType['sourceType'],
+  readonly body: ReadonlyArray<MaybeDetachedNode<ProgramType['body'][number]>>,
+  readonly tokens?: ?ReadonlyArray<MaybeDetachedNode<TokenType>>,
+  readonly comments?: ?ReadonlyArray<MaybeDetachedNode<CommentType>>,
+  readonly interpreter?: ?string,
+  readonly docblock?: ?DocblockMetadataType,
 };
 export function Program(props: {
-  ...$ReadOnly<ProgramProps>,
+  ...Readonly<ProgramProps>,
 }): DetachedNode<ProgramType> {
   return detachedProps<ProgramType>(null, {
     type: 'Program',
@@ -193,13 +201,13 @@ export function Program(props: {
 // which is super awkward to work with and type - so we flatten the input
 // and put it in the right spot after
 export type DeclareFunctionProps = {
-  +name: string,
-  +functionType: MaybeDetachedNode<FunctionTypeAnnotationType>,
-  +predicate?: ?MaybeDetachedNode<DeclareFunctionType['predicate']>,
+  readonly name: string,
+  readonly functionType: MaybeDetachedNode<FunctionTypeAnnotationType>,
+  readonly predicate?: ?MaybeDetachedNode<DeclareFunctionType['predicate']>,
 };
 export function DeclareFunction(props: {
-  ...$ReadOnly<DeclareFunctionProps>,
-  +parent?: ESNode,
+  ...Readonly<DeclareFunctionProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<DeclareFunctionType> {
   const node = detachedProps<DeclareFunctionType>(props.parent, {
     type: 'DeclareFunction',
@@ -219,15 +227,15 @@ export function DeclareFunction(props: {
 }
 
 export type MemberExpressionProps = {
-  +object: MaybeDetachedNode<MemberExpressionType['object']>,
-  +property: MaybeDetachedNode<MemberExpressionType['property']>,
-  +computed: MemberExpressionType['computed'],
-  +optional?: MemberExpressionType['optional'],
+  readonly object: MaybeDetachedNode<MemberExpressionType['object']>,
+  readonly property: MaybeDetachedNode<MemberExpressionType['property']>,
+  readonly computed: MemberExpressionType['computed'],
+  readonly optional?: MemberExpressionType['optional'],
 };
 
 export function MemberExpression(props: {
-  ...$ReadOnly<MemberExpressionProps>,
-  +parent?: ESNode,
+  ...Readonly<MemberExpressionProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<MemberExpressionType> {
   const node = detachedProps<MemberExpressionType>(props.parent, {
     type: 'MemberExpression',
@@ -242,11 +250,11 @@ export function MemberExpression(props: {
 
 // Ignore the hermes-specific `implicit` property.
 export type BlockStatementProps = {
-  +body: $ReadOnlyArray<MaybeDetachedNode<StatementType>>,
+  readonly body: ReadonlyArray<MaybeDetachedNode<StatementType>>,
 };
 export function BlockStatement(props: {
-  ...$ReadOnly<BlockStatementProps>,
-  +parent?: ESNode,
+  ...Readonly<BlockStatementProps>,
+  readonly parent?: ESNode,
 }): DetachedNode<BlockStatementType> {
   const node = detachedProps<BlockStatementType>(props.parent, {
     type: 'BlockStatement',

package/dist/index.js

@@ -1,12 +1,3 @@
-/**
- * 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", {

package/dist/src/detachedNode.js

@@ -15,30 +15,16 @@ exports.updateAllParentPointers = updateAllParentPointers;
 
 var _hermesParser = require("hermes-parser");
 
-/**
- * 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
- */
 const DETACHED_MARKER = Symbol.for('hermes-transform - Detached AST Node');
 const ORIGINAL_NODE = Symbol.for('hermes-transform - Original Node');
 
 function isDetachedNode(node) {
-  // $FlowExpectedError[invalid-in-lhs] flow doesn't support symbols as keys
   return DETACHED_MARKER in node;
 }
 
 function getOriginalNode(node) {
-  // $FlowExpectedError[prop-missing]
   return node[ORIGINAL_NODE];
 }
-/* $FlowExpectedError[unclear-type] Type safety is not needed for generated
- * code, this avoids us always having to pass a generic property within codegen */
-
 
 function asDetachedNodeForCodeGen(node) {
   if (node == null) {
@@ -66,30 +52,13 @@ const asDetachedNode = (node, {
   }
 
   return useDeepClone ? deepCloneNode(node, {}) : shallowCloneNode(node, {});
-}; // used by the node type function codegen
-
+};
 
 exports.asDetachedNode = asDetachedNode;
 
 function detachedProps(parent, props, config = {}) {
-  // $FlowExpectedError[incompatible-type]
   const detachedNode = { ...props,
     ...((config == null ? void 0 : config.preserveLocation) !== true ? {
-      // if this is [0,0] AND the file has a docblock then prettier will insert newlines between
-      // certain detached nodes. Because of "intended" formatting behaviour (https://github.com/prettier/prettier/issues/12078)
-      // this can cause us to output weirdly formatted code that should have been collapsed.
-      //
-      // prettier works backwards from the position you give it to find newlines or non whitespace
-      // tokens and uses this to determine if newlines should be inserted between nodes.
-      // By placing the range at [1, 1] we can ensure a token is always found before a newline
-      // and therefore no newlines will be placed between nodes.
-      //
-      // NOTE: we will still run into the bug if there is weird code like a docblock with whitespace
-      //       characters before it. However we assume this isn't going to happen because any file
-      //       already formatted by prettier will have that whitespace removed.
-      // We considered a more complex solution involving traversing the AST and manually updating
-      // detached node ranges after mutations are applied - however this is a lot heavier and will
-      // probably never be needed.
       range: [1, 1],
       loc: {
         start: {
@@ -102,12 +71,8 @@ function detachedProps(parent, props, config = {}) {
         }
       }
     } : {}),
-    // if not provided, then we purposely don't set this here
-    // and will rely on the tooling to update it as appropriate.
-    // nothing should be reading from this before it's set anyway.
     parent: parent
-  }; // mark the node as detached
-
+  };
   Object.defineProperty(detachedNode, DETACHED_MARKER, {
     configurable: false,
     enumerable: false,
@@ -126,10 +91,6 @@ function detachedProps(parent, props, config = {}) {
 
   return detachedNode;
 }
-/**
- * Shallowly clones the node, but not its children.
- */
-
 
 function shallowCloneNode(node, newProps, config = {}) {
   var _config$preserveLocat, _config$originalNode;
@@ -141,37 +102,22 @@ function shallowCloneNode(node, newProps, config = {}) {
     originalNode: (_config$originalNode = config.originalNode) != null ? _config$originalNode : node
   });
 }
-/**
- * Deeply clones node and its entire tree.
- */
-
 
 function deepCloneNode(node, newProps) {
-  // $FlowFixMe[unsafe-object-assign]
   const clone = Object.assign(JSON.parse(JSON.stringify(node, (key, value) => {
-    // null out parent pointers
     if (key === 'parent') {
       return undefined;
     }
 
     return value;
   })), newProps);
-  updateAllParentPointers(clone); // $FlowExpectedError[class-object-subtyping]
-
+  updateAllParentPointers(clone);
   return detachedProps(null, clone);
 }
-/**
- * Corrects the parent pointers in direct children of the given node
- */
-
 
 function setParentPointersInDirectChildren(node) {
   _hermesParser.astNodeMutationHelpers.setParentPointersInDirectChildren(node);
 }
-/**
- * Traverses the entire subtree to ensure the parent pointers are set correctly
- */
-
 
 function updateAllParentPointers(node) {
   _hermesParser.astNodeMutationHelpers.updateAllParentPointers(node);

package/dist/src/generated/node-types.js

@@ -1,24 +1,3 @@
-/**
- * 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, $FlowFixMe */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {

package/dist/src/generated/special-case-node-types/Comment.js

@@ -8,18 +8,7 @@ exports.LineComment = LineComment;
 
 var _detachedNode = require("../../detachedNode");
 
-/**
- * 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
- */
 function LineComment(props) {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-type]
   return (0, _detachedNode.detachedProps)(undefined, {
     type: 'Line',
     value: props.value
@@ -27,8 +16,6 @@ function LineComment(props) {
 }
 
 function BlockComment(props) {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-type]
   return (0, _detachedNode.detachedProps)(undefined, {
     type: 'Block',
     value: props.value