hermes-transform 0.5.0 → 0.6.0

package/dist/transform/comments/prettier/language-js/comments.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -8,43 +8,34 @@
  */
 'use strict';
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-var _require = require('../common/util.js'),
-    getLast = _require.getLast,
-    hasNewline = _require.hasNewline,
-    addLeadingComment = _require.addLeadingComment,
-    getNextNonSpaceNonCommentCharacterIndexWithStartIndex = _require.getNextNonSpaceNonCommentCharacterIndexWithStartIndex,
-    getNextNonSpaceNonCommentCharacterIndex = _require.getNextNonSpaceNonCommentCharacterIndex,
-    hasNewlineInRange = _require.hasNewlineInRange,
-    addTrailingComment = _require.addTrailingComment,
-    addDanglingComment = _require.addDanglingComment,
-    getNextNonSpaceNonCommentCharacter = _require.getNextNonSpaceNonCommentCharacter,
-    isNonEmptyArray = _require.isNonEmptyArray;
-
-var _require2 = require('./utils.js'),
-    isBlockComment = _require2.isBlockComment,
-    getFunctionParameters = _require2.getFunctionParameters,
-    isPrettierIgnoreComment = _require2.isPrettierIgnoreComment,
-    isCallLikeExpression = _require2.isCallLikeExpression,
-    getCallArguments = _require2.getCallArguments,
-    isCallExpression = _require2.isCallExpression,
-    isMemberExpression = _require2.isMemberExpression,
-    isObjectProperty = _require2.isObjectProperty;
-
-var _require3 = require('./loc.js'),
-    locStart = _require3.locStart,
-    locEnd = _require3.locEnd;
+const {
+  getLast,
+  hasNewline,
+  addLeadingComment,
+  getNextNonSpaceNonCommentCharacterIndexWithStartIndex,
+  getNextNonSpaceNonCommentCharacterIndex,
+  hasNewlineInRange,
+  addTrailingComment,
+  addDanglingComment,
+  getNextNonSpaceNonCommentCharacter,
+  isNonEmptyArray
+} = require('../common/util.js');
+
+const {
+  isBlockComment,
+  getFunctionParameters,
+  isPrettierIgnoreComment,
+  isCallLikeExpression,
+  getCallArguments,
+  isCallExpression,
+  isMemberExpression,
+  isObjectProperty
+} = require('./utils.js');
+
+const {
+  locStart,
+  locEnd
+} = require('./loc.js');
 /**
  * @typedef {import("./types/estree").Node} Node
  * @typedef {import("./types/estree").Comment} Comment
@@ -68,9 +59,7 @@ var _require3 = require('./loc.js'),
 
 
 function handleOwnLineComment(context) {
-  return [handleIgnoreComments, handleLastFunctionArgComments, handleMemberExpressionComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleImportSpecifierComments, handleForComments, handleUnionTypeComments, handleOnlyComments, handleImportDeclarationComments, handleAssignmentPatternComments, handleMethodNameComments, handleLabeledStatementComments].some(function (fn) {
-    return fn(context);
-  });
+  return [handleIgnoreComments, handleLastFunctionArgComments, handleMemberExpressionComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleImportSpecifierComments, handleForComments, handleUnionTypeComments, handleOnlyComments, handleImportDeclarationComments, handleAssignmentPatternComments, handleMethodNameComments, handleLabeledStatementComments].some(fn => fn(context));
 }
 /**
  * @param {CommentContext} context
@@ -79,9 +68,7 @@ function handleOwnLineComment(context) {
 
 
 function handleEndOfLineComment(context) {
-  return [handleClosureTypeCastComments, handleLastFunctionArgComments, handleConditionalExpressionComments, handleImportSpecifierComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleLabeledStatementComments, handleCallExpressionComments, handlePropertyComments, handleOnlyComments, handleTypeAliasComments, handleVariableDeclaratorComments].some(function (fn) {
-    return fn(context);
-  });
+  return [handleClosureTypeCastComments, handleLastFunctionArgComments, handleConditionalExpressionComments, handleImportSpecifierComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleLabeledStatementComments, handleCallExpressionComments, handlePropertyComments, handleOnlyComments, handleTypeAliasComments, handleVariableDeclaratorComments].some(fn => fn(context));
 }
 /**
  * @param {CommentContext} context
@@ -90,9 +77,7 @@ function handleEndOfLineComment(context) {
 
 
 function handleRemainingComment(context) {
-  return [handleIgnoreComments, handleIfStatementComments, handleWhileComments, handleObjectPropertyAssignment, handleCommentInEmptyParens, handleMethodNameComments, handleOnlyComments, handleCommentAfterArrowParams, handleFunctionNameComments, handleTSMappedTypeComments, handleBreakAndContinueStatementComments, handleTSFunctionTrailingComments].some(function (fn) {
-    return fn(context);
-  });
+  return [handleIgnoreComments, handleIfStatementComments, handleWhileComments, handleObjectPropertyAssignment, handleCommentInEmptyParens, handleMethodNameComments, handleOnlyComments, handleCommentAfterArrowParams, handleFunctionNameComments, handleTSMappedTypeComments, handleBreakAndContinueStatementComments, handleTSFunctionTrailingComments].some(fn => fn(context));
 }
 /**
  * @param {Node} node
@@ -102,10 +87,9 @@ function handleRemainingComment(context) {
 
 function addBlockStatementFirstComment(node, comment) {
   // @ts-expect-error
-  var firstNonEmptyNode = (node.body || node.properties).find(function (_ref) {
-    var type = _ref.type;
-    return type !== 'EmptyStatement';
-  });
+  const firstNonEmptyNode = (node.body || node.properties).find(({
+    type
+  }) => type !== 'EmptyStatement');
 
   if (firstNonEmptyNode) {
     addLeadingComment(firstNonEmptyNode, comment);
@@ -127,10 +111,10 @@ function addBlockOrNotComment(node, comment) {
   }
 }
 
-function handleClosureTypeCastComments(_ref2) {
-  var comment = _ref2.comment,
-      followingNode = _ref2.followingNode;
-
+function handleClosureTypeCastComments({
+  comment,
+  followingNode
+}) {
   if (followingNode && isTypeCastComment(comment)) {
     addLeadingComment(followingNode, comment);
     return true;
@@ -155,13 +139,13 @@ function handleClosureTypeCastComments(_ref2) {
 //   }
 
 
-function handleIfStatementComments(_ref3) {
-  var comment = _ref3.comment,
-      precedingNode = _ref3.precedingNode,
-      enclosingNode = _ref3.enclosingNode,
-      followingNode = _ref3.followingNode,
-      text = _ref3.text;
-
+function handleIfStatementComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode,
+  text
+}) {
   if (!enclosingNode || enclosingNode.type !== 'IfStatement' || !followingNode) {
     return false;
   } // We unfortunately have no way using the AST or location of nodes to know
@@ -171,7 +155,7 @@ function handleIfStatementComments(_ref3) {
   // it is a ).
 
 
-  var nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
+  const nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
 
   if (nextCharacter === ')') {
     addTrailingComment(precedingNode, comment);
@@ -214,13 +198,13 @@ function handleIfStatementComments(_ref3) {
   return false;
 }
 
-function handleWhileComments(_ref4) {
-  var comment = _ref4.comment,
-      precedingNode = _ref4.precedingNode,
-      enclosingNode = _ref4.enclosingNode,
-      followingNode = _ref4.followingNode,
-      text = _ref4.text;
-
+function handleWhileComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode,
+  text
+}) {
   if (!enclosingNode || enclosingNode.type !== 'WhileStatement' || !followingNode) {
     return false;
   } // We unfortunately have no way using the AST or location of nodes to know
@@ -230,7 +214,7 @@ function handleWhileComments(_ref4) {
   // it is a ).
 
 
-  var nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
+  const nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
 
   if (nextCharacter === ')') {
     addTrailingComment(precedingNode, comment);
@@ -251,12 +235,12 @@ function handleWhileComments(_ref4) {
 } // Same as IfStatement but for TryStatement
 
 
-function handleTryStatementComments(_ref5) {
-  var comment = _ref5.comment,
-      precedingNode = _ref5.precedingNode,
-      enclosingNode = _ref5.enclosingNode,
-      followingNode = _ref5.followingNode;
-
+function handleTryStatementComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode
+}) {
   if (!enclosingNode || enclosingNode.type !== 'TryStatement' && enclosingNode.type !== 'CatchClause' || !followingNode) {
     return false;
   }
@@ -284,11 +268,11 @@ function handleTryStatementComments(_ref5) {
   return false;
 }
 
-function handleMemberExpressionComments(_ref6) {
-  var comment = _ref6.comment,
-      enclosingNode = _ref6.enclosingNode,
-      followingNode = _ref6.followingNode;
-
+function handleMemberExpressionComments({
+  comment,
+  enclosingNode,
+  followingNode
+}) {
   if (isMemberExpression(enclosingNode) && followingNode && followingNode.type === 'Identifier') {
     addLeadingComment(enclosingNode, comment);
     return true;
@@ -297,13 +281,14 @@ function handleMemberExpressionComments(_ref6) {
   return false;
 }
 
-function handleConditionalExpressionComments(_ref7) {
-  var comment = _ref7.comment,
-      precedingNode = _ref7.precedingNode,
-      enclosingNode = _ref7.enclosingNode,
-      followingNode = _ref7.followingNode,
-      text = _ref7.text;
-  var isSameLineAsPrecedingNode = precedingNode && !hasNewlineInRange(text, locEnd(precedingNode), locStart(comment));
+function handleConditionalExpressionComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode,
+  text
+}) {
+  const isSameLineAsPrecedingNode = precedingNode && !hasNewlineInRange(text, locEnd(precedingNode), locStart(comment));
 
   if ((!precedingNode || !isSameLineAsPrecedingNode) && enclosingNode && (enclosingNode.type === 'ConditionalExpression' || enclosingNode.type === 'TSConditionalType') && followingNode) {
     addLeadingComment(followingNode, comment);
@@ -313,11 +298,11 @@ function handleConditionalExpressionComments(_ref7) {
   return false;
 }
 
-function handleObjectPropertyAssignment(_ref8) {
-  var comment = _ref8.comment,
-      precedingNode = _ref8.precedingNode,
-      enclosingNode = _ref8.enclosingNode;
-
+function handleObjectPropertyAssignment({
+  comment,
+  precedingNode,
+  enclosingNode
+}) {
   if (isObjectProperty(enclosingNode) && enclosingNode.shorthand && enclosingNode.key === precedingNode && enclosingNode.value.type === 'AssignmentPattern') {
     addTrailingComment(enclosingNode.value.left, comment);
     return true;
@@ -326,12 +311,12 @@ function handleObjectPropertyAssignment(_ref8) {
   return false;
 }
 
-function handleClassComments(_ref9) {
-  var comment = _ref9.comment,
-      precedingNode = _ref9.precedingNode,
-      enclosingNode = _ref9.enclosingNode,
-      followingNode = _ref9.followingNode;
-
+function handleClassComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode
+}) {
   if (enclosingNode && (enclosingNode.type === 'ClassDeclaration' || enclosingNode.type === 'ClassExpression' || enclosingNode.type === 'DeclareClass' || enclosingNode.type === 'DeclareInterface' || enclosingNode.type === 'InterfaceDeclaration' || enclosingNode.type === 'TSInterfaceDeclaration')) {
     if (isNonEmptyArray(enclosingNode.decorators) && !(followingNode && followingNode.type === 'Decorator')) {
       addTrailingComment(getLast(enclosingNode.decorators), comment);
@@ -346,9 +331,7 @@ function handleClassComments(_ref9) {
 
 
     if (followingNode) {
-      for (var _i = 0, _arr = ['implements', 'extends', 'mixins']; _i < _arr.length; _i++) {
-        var prop = _arr[_i];
-
+      for (const prop of ['implements', 'extends', 'mixins']) {
         if (enclosingNode[prop] && followingNode === enclosingNode[prop][0]) {
           if (precedingNode && (precedingNode === enclosingNode.id || precedingNode === enclosingNode.typeParameters || precedingNode === enclosingNode.superClass)) {
             addTrailingComment(precedingNode, comment);
@@ -365,12 +348,12 @@ function handleClassComments(_ref9) {
   return false;
 }
 
-function handleMethodNameComments(_ref10) {
-  var comment = _ref10.comment,
-      precedingNode = _ref10.precedingNode,
-      enclosingNode = _ref10.enclosingNode,
-      text = _ref10.text;
-
+function handleMethodNameComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  text
+}) {
   // This is only needed for estree parsers (flow, typescript) to attach
   // after a method name:
   // obj = { fn /*comment*/() {} };
@@ -392,12 +375,12 @@ function handleMethodNameComments(_ref10) {
   return false;
 }
 
-function handleFunctionNameComments(_ref11) {
-  var comment = _ref11.comment,
-      precedingNode = _ref11.precedingNode,
-      enclosingNode = _ref11.enclosingNode,
-      text = _ref11.text;
-
+function handleFunctionNameComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  text
+}) {
   if (getNextNonSpaceNonCommentCharacter(text, comment, locEnd) !== '(') {
     return false;
   }
@@ -410,16 +393,16 @@ function handleFunctionNameComments(_ref11) {
   return false;
 }
 
-function handleCommentAfterArrowParams(_ref12) {
-  var comment = _ref12.comment,
-      enclosingNode = _ref12.enclosingNode,
-      text = _ref12.text;
-
+function handleCommentAfterArrowParams({
+  comment,
+  enclosingNode,
+  text
+}) {
   if (!(enclosingNode && enclosingNode.type === 'ArrowFunctionExpression')) {
     return false;
   }
 
-  var index = getNextNonSpaceNonCommentCharacterIndex(text, comment, locEnd);
+  const index = getNextNonSpaceNonCommentCharacterIndex(text, comment, locEnd);
 
   if (index !== false && text.slice(index, index + 2) === '=>') {
     addDanglingComment(enclosingNode, comment);
@@ -429,11 +412,11 @@ function handleCommentAfterArrowParams(_ref12) {
   return false;
 }
 
-function handleCommentInEmptyParens(_ref13) {
-  var comment = _ref13.comment,
-      enclosingNode = _ref13.enclosingNode,
-      text = _ref13.text;
-
+function handleCommentInEmptyParens({
+  comment,
+  enclosingNode,
+  text
+}) {
   if (getNextNonSpaceNonCommentCharacter(text, comment, locEnd) !== ')') {
     return false;
   } // Only add dangling comments to fix the case when no params are present,
@@ -453,13 +436,13 @@ function handleCommentInEmptyParens(_ref13) {
   return false;
 }
 
-function handleLastFunctionArgComments(_ref14) {
-  var comment = _ref14.comment,
-      precedingNode = _ref14.precedingNode,
-      enclosingNode = _ref14.enclosingNode,
-      followingNode = _ref14.followingNode,
-      text = _ref14.text;
-
+function handleLastFunctionArgComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode,
+  text
+}) {
   // Flow function type definitions
   if (precedingNode && precedingNode.type === 'FunctionTypeParam' && enclosingNode && enclosingNode.type === 'FunctionTypeAnnotation' && followingNode && followingNode.type !== 'FunctionTypeParam') {
     addTrailingComment(precedingNode, comment);
@@ -473,16 +456,16 @@ function handleLastFunctionArgComments(_ref14) {
   }
 
   if (enclosingNode && enclosingNode.type === 'FunctionDeclaration' && followingNode && followingNode.type === 'BlockStatement') {
-    var functionParamRightParenIndex = function () {
-      var parameters = getFunctionParameters(enclosingNode);
+    const functionParamRightParenIndex = (() => {
+      const parameters = getFunctionParameters(enclosingNode);
 
       if (parameters.length > 0) {
         return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(getLast(parameters)));
       }
 
-      var functionParamLeftParenIndex = getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(enclosingNode.id));
+      const functionParamLeftParenIndex = getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(enclosingNode.id));
       return functionParamLeftParenIndex !== false && getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, functionParamLeftParenIndex + 1);
-    }();
+    })();
 
     if (locStart(comment) > functionParamRightParenIndex) {
       addBlockStatementFirstComment(followingNode, comment);
@@ -493,10 +476,10 @@ function handleLastFunctionArgComments(_ref14) {
   return false;
 }
 
-function handleImportSpecifierComments(_ref15) {
-  var comment = _ref15.comment,
-      enclosingNode = _ref15.enclosingNode;
-
+function handleImportSpecifierComments({
+  comment,
+  enclosingNode
+}) {
   if (enclosingNode && enclosingNode.type === 'ImportSpecifier') {
     addLeadingComment(enclosingNode, comment);
     return true;
@@ -505,10 +488,10 @@ function handleImportSpecifierComments(_ref15) {
   return false;
 }
 
-function handleLabeledStatementComments(_ref16) {
-  var comment = _ref16.comment,
-      enclosingNode = _ref16.enclosingNode;
-
+function handleLabeledStatementComments({
+  comment,
+  enclosingNode
+}) {
   if (enclosingNode && enclosingNode.type === 'LabeledStatement') {
     addLeadingComment(enclosingNode, comment);
     return true;
@@ -517,10 +500,10 @@ function handleLabeledStatementComments(_ref16) {
   return false;
 }
 
-function handleBreakAndContinueStatementComments(_ref17) {
-  var comment = _ref17.comment,
-      enclosingNode = _ref17.enclosingNode;
-
+function handleBreakAndContinueStatementComments({
+  comment,
+  enclosingNode
+}) {
   if (enclosingNode && (enclosingNode.type === 'ContinueStatement' || enclosingNode.type === 'BreakStatement') && !enclosingNode.label) {
     addTrailingComment(enclosingNode, comment);
     return true;
@@ -529,11 +512,11 @@ function handleBreakAndContinueStatementComments(_ref17) {
   return false;
 }
 
-function handleCallExpressionComments(_ref18) {
-  var comment = _ref18.comment,
-      precedingNode = _ref18.precedingNode,
-      enclosingNode = _ref18.enclosingNode;
-
+function handleCallExpressionComments({
+  comment,
+  precedingNode,
+  enclosingNode
+}) {
   if (isCallExpression(enclosingNode) && precedingNode && enclosingNode.callee === precedingNode && enclosingNode.arguments.length > 0) {
     addLeadingComment(enclosingNode.arguments[0], comment);
     return true;
@@ -542,12 +525,12 @@ function handleCallExpressionComments(_ref18) {
   return false;
 }
 
-function handleUnionTypeComments(_ref19) {
-  var comment = _ref19.comment,
-      precedingNode = _ref19.precedingNode,
-      enclosingNode = _ref19.enclosingNode,
-      followingNode = _ref19.followingNode;
-
+function handleUnionTypeComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode
+}) {
   if (enclosingNode && (enclosingNode.type === 'UnionTypeAnnotation' || enclosingNode.type === 'TSUnionType')) {
     if (isPrettierIgnoreComment(comment)) {
       followingNode.prettierIgnore = true;
@@ -570,10 +553,10 @@ function handleUnionTypeComments(_ref19) {
   return false;
 }
 
-function handlePropertyComments(_ref20) {
-  var comment = _ref20.comment,
-      enclosingNode = _ref20.enclosingNode;
-
+function handlePropertyComments({
+  comment,
+  enclosingNode
+}) {
   if (isObjectProperty(enclosingNode)) {
     addLeadingComment(enclosingNode, comment);
     return true;
@@ -582,13 +565,13 @@ function handlePropertyComments(_ref20) {
   return false;
 }
 
-function handleOnlyComments(_ref21) {
-  var comment = _ref21.comment,
-      enclosingNode = _ref21.enclosingNode,
-      followingNode = _ref21.followingNode,
-      ast = _ref21.ast,
-      isLastComment = _ref21.isLastComment;
-
+function handleOnlyComments({
+  comment,
+  enclosingNode,
+  followingNode,
+  ast,
+  isLastComment
+}) {
   // With Flow the enclosingNode is undefined so use the AST instead.
   if (ast && ast.body && ast.body.length === 0) {
     if (isLastComment) {
@@ -618,10 +601,10 @@ function handleOnlyComments(_ref21) {
   return false;
 }
 
-function handleForComments(_ref22) {
-  var comment = _ref22.comment,
-      enclosingNode = _ref22.enclosingNode;
-
+function handleForComments({
+  comment,
+  enclosingNode
+}) {
   if (enclosingNode && (enclosingNode.type === 'ForInStatement' || enclosingNode.type === 'ForOfStatement')) {
     addLeadingComment(enclosingNode, comment);
     return true;
@@ -630,12 +613,12 @@ function handleForComments(_ref22) {
   return false;
 }
 
-function handleImportDeclarationComments(_ref23) {
-  var comment = _ref23.comment,
-      precedingNode = _ref23.precedingNode,
-      enclosingNode = _ref23.enclosingNode,
-      text = _ref23.text;
-
+function handleImportDeclarationComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  text
+}) {
   if (precedingNode && precedingNode.type === 'ImportSpecifier' && enclosingNode && enclosingNode.type === 'ImportDeclaration' && hasNewline(text, locEnd(comment))) {
     addTrailingComment(precedingNode, comment);
     return true;
@@ -644,10 +627,10 @@ function handleImportDeclarationComments(_ref23) {
   return false;
 }
 
-function handleAssignmentPatternComments(_ref24) {
-  var comment = _ref24.comment,
-      enclosingNode = _ref24.enclosingNode;
-
+function handleAssignmentPatternComments({
+  comment,
+  enclosingNode
+}) {
   if (enclosingNode && enclosingNode.type === 'AssignmentPattern') {
     addLeadingComment(enclosingNode, comment);
     return true;
@@ -656,10 +639,10 @@ function handleAssignmentPatternComments(_ref24) {
   return false;
 }
 
-function handleTypeAliasComments(_ref25) {
-  var comment = _ref25.comment,
-      enclosingNode = _ref25.enclosingNode;
-
+function handleTypeAliasComments({
+  comment,
+  enclosingNode
+}) {
   if (enclosingNode && enclosingNode.type === 'TypeAlias') {
     addLeadingComment(enclosingNode, comment);
     return true;
@@ -668,11 +651,11 @@ function handleTypeAliasComments(_ref25) {
   return false;
 }
 
-function handleVariableDeclaratorComments(_ref26) {
-  var comment = _ref26.comment,
-      enclosingNode = _ref26.enclosingNode,
-      followingNode = _ref26.followingNode;
-
+function handleVariableDeclaratorComments({
+  comment,
+  enclosingNode,
+  followingNode
+}) {
   if (enclosingNode && (enclosingNode.type === 'VariableDeclarator' || enclosingNode.type === 'AssignmentExpression') && followingNode && (followingNode.type === 'ObjectExpression' || followingNode.type === 'ArrayExpression' || followingNode.type === 'TemplateLiteral' || followingNode.type === 'TaggedTemplateExpression' || isBlockComment(comment))) {
     addLeadingComment(followingNode, comment);
     return true;
@@ -681,12 +664,12 @@ function handleVariableDeclaratorComments(_ref26) {
   return false;
 }
 
-function handleTSFunctionTrailingComments(_ref27) {
-  var comment = _ref27.comment,
-      enclosingNode = _ref27.enclosingNode,
-      followingNode = _ref27.followingNode,
-      text = _ref27.text;
-
+function handleTSFunctionTrailingComments({
+  comment,
+  enclosingNode,
+  followingNode,
+  text
+}) {
   if (!followingNode && enclosingNode && (enclosingNode.type === 'TSMethodSignature' || enclosingNode.type === 'TSDeclareFunction' || enclosingNode.type === 'TSAbstractMethodDefinition') && getNextNonSpaceNonCommentCharacter(text, comment, locEnd) === ';') {
     addTrailingComment(enclosingNode, comment);
     return true;
@@ -695,11 +678,11 @@ function handleTSFunctionTrailingComments(_ref27) {
   return false;
 }
 
-function handleIgnoreComments(_ref28) {
-  var comment = _ref28.comment,
-      enclosingNode = _ref28.enclosingNode,
-      followingNode = _ref28.followingNode;
-
+function handleIgnoreComments({
+  comment,
+  enclosingNode,
+  followingNode
+}) {
   if (isPrettierIgnoreComment(comment) && enclosingNode && enclosingNode.type === 'TSMappedType' && followingNode && followingNode.type === 'TSTypeParameter' && followingNode.constraint) {
     enclosingNode.prettierIgnore = true;
     comment.unignore = true;
@@ -707,12 +690,12 @@ function handleIgnoreComments(_ref28) {
   }
 }
 
-function handleTSMappedTypeComments(_ref29) {
-  var comment = _ref29.comment,
-      precedingNode = _ref29.precedingNode,
-      enclosingNode = _ref29.enclosingNode,
-      followingNode = _ref29.followingNode;
-
+function handleTSMappedTypeComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode
+}) {
   if (!enclosingNode || enclosingNode.type !== 'TSMappedType') {
     return false;
   }
@@ -753,7 +736,7 @@ function getCommentChildNodes(node, options) {
   //       }
   //     }
   if ((options.parser === 'typescript' || options.parser === 'flow' || options.parser === 'espree' || options.parser === 'meriyah' || options.parser === '__babel_estree') && node.type === 'MethodDefinition' && node.value && node.value.type === 'FunctionExpression' && getFunctionParameters(node.value).length === 0 && !node.value.returnType && !isNonEmptyArray(node.value.typeParameters) && node.value.body) {
-    return [].concat(_toConsumableArray(node.decorators || []), [node.key, node.value.body]);
+    return [...(node.decorators || []), node.key, node.value.body];
   }
 }
 /**
@@ -770,8 +753,8 @@ function isTypeCastComment(comment) {
 }
 
 module.exports = {
-  handleOwnLineComment: handleOwnLineComment,
-  handleEndOfLineComment: handleEndOfLineComment,
-  handleRemainingComment: handleRemainingComment,
-  getCommentChildNodes: getCommentChildNodes
+  handleOwnLineComment,
+  handleEndOfLineComment,
+  handleRemainingComment,
+  getCommentChildNodes
 };