hermes-transform 0.5.0

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

@@ -0,0 +1,777 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+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;
+/**
+ * @typedef {import("./types/estree").Node} Node
+ * @typedef {import("./types/estree").Comment} Comment
+ * @typedef {import("../common/ast-path")} AstPath
+ *
+ * @typedef {Object} CommentContext
+ * @property {Comment} comment
+ * @property {Node} precedingNode
+ * @property {Node} enclosingNode
+ * @property {Node} followingNode
+ * @property {string} text
+ * @property {any} options
+ * @property {Node} ast
+ * @property {boolean} isLastComment
+ */
+
+/**
+ * @param {CommentContext} context
+ * @returns {boolean}
+ */
+
+
+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);
+  });
+}
+/**
+ * @param {CommentContext} context
+ * @returns {boolean}
+ */
+
+
+function handleEndOfLineComment(context) {
+  return [handleClosureTypeCastComments, handleLastFunctionArgComments, handleConditionalExpressionComments, handleImportSpecifierComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleLabeledStatementComments, handleCallExpressionComments, handlePropertyComments, handleOnlyComments, handleTypeAliasComments, handleVariableDeclaratorComments].some(function (fn) {
+    return fn(context);
+  });
+}
+/**
+ * @param {CommentContext} context
+ * @returns {boolean}
+ */
+
+
+function handleRemainingComment(context) {
+  return [handleIgnoreComments, handleIfStatementComments, handleWhileComments, handleObjectPropertyAssignment, handleCommentInEmptyParens, handleMethodNameComments, handleOnlyComments, handleCommentAfterArrowParams, handleFunctionNameComments, handleTSMappedTypeComments, handleBreakAndContinueStatementComments, handleTSFunctionTrailingComments].some(function (fn) {
+    return fn(context);
+  });
+}
+/**
+ * @param {Node} node
+ * @returns {void}
+ */
+
+
+function addBlockStatementFirstComment(node, comment) {
+  // @ts-expect-error
+  var firstNonEmptyNode = (node.body || node.properties).find(function (_ref) {
+    var type = _ref.type;
+    return type !== 'EmptyStatement';
+  });
+
+  if (firstNonEmptyNode) {
+    addLeadingComment(firstNonEmptyNode, comment);
+  } else {
+    addDanglingComment(node, comment);
+  }
+}
+/**
+ * @param {Node} node
+ * @returns {void}
+ */
+
+
+function addBlockOrNotComment(node, comment) {
+  if (node.type === 'BlockStatement') {
+    addBlockStatementFirstComment(node, comment);
+  } else {
+    addLeadingComment(node, comment);
+  }
+}
+
+function handleClosureTypeCastComments(_ref2) {
+  var comment = _ref2.comment,
+      followingNode = _ref2.followingNode;
+
+  if (followingNode && isTypeCastComment(comment)) {
+    addLeadingComment(followingNode, comment);
+    return true;
+  }
+
+  return false;
+} // There are often comments before the else clause of if statements like
+//
+//   if (1) { ... }
+//   // comment
+//   else { ... }
+//
+// They are being attached as leading comments of the BlockExpression which
+// is not well printed. What we want is to instead move the comment inside
+// of the block and make it leadingComment of the first element of the block
+// or dangling comment of the block if there is nothing inside
+//
+//   if (1) { ... }
+//   else {
+//     // comment
+//     ...
+//   }
+
+
+function handleIfStatementComments(_ref3) {
+  var comment = _ref3.comment,
+      precedingNode = _ref3.precedingNode,
+      enclosingNode = _ref3.enclosingNode,
+      followingNode = _ref3.followingNode,
+      text = _ref3.text;
+
+  if (!enclosingNode || enclosingNode.type !== 'IfStatement' || !followingNode) {
+    return false;
+  } // We unfortunately have no way using the AST or location of nodes to know
+  // if the comment is positioned before the condition parenthesis:
+  //   if (a /* comment */) {}
+  // The only workaround I found is to look at the next character to see if
+  // it is a ).
+
+
+  var nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
+
+  if (nextCharacter === ')') {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  } // Comments before `else`:
+  // - treat as trailing comments of the consequent, if it's a BlockStatement
+  // - treat as a dangling comment otherwise
+
+
+  if (precedingNode === enclosingNode.consequent && followingNode === enclosingNode.alternate) {
+    if (precedingNode.type === 'BlockStatement') {
+      addTrailingComment(precedingNode, comment);
+    } else {
+      addDanglingComment(enclosingNode, comment);
+    }
+
+    return true;
+  }
+
+  if (followingNode.type === 'BlockStatement') {
+    addBlockStatementFirstComment(followingNode, comment);
+    return true;
+  }
+
+  if (followingNode.type === 'IfStatement') {
+    addBlockOrNotComment(followingNode.consequent, comment);
+    return true;
+  } // For comments positioned after the condition parenthesis in an if statement
+  // before the consequent without brackets on, such as
+  // if (a) /* comment */ true,
+  // we look at the next character to see if the following node
+  // is the consequent for the if statement
+
+
+  if (enclosingNode.consequent === followingNode) {
+    addLeadingComment(followingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleWhileComments(_ref4) {
+  var comment = _ref4.comment,
+      precedingNode = _ref4.precedingNode,
+      enclosingNode = _ref4.enclosingNode,
+      followingNode = _ref4.followingNode,
+      text = _ref4.text;
+
+  if (!enclosingNode || enclosingNode.type !== 'WhileStatement' || !followingNode) {
+    return false;
+  } // We unfortunately have no way using the AST or location of nodes to know
+  // if the comment is positioned before the condition parenthesis:
+  //   while (a /* comment */) {}
+  // The only workaround I found is to look at the next character to see if
+  // it is a ).
+
+
+  var nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
+
+  if (nextCharacter === ')') {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  }
+
+  if (followingNode.type === 'BlockStatement') {
+    addBlockStatementFirstComment(followingNode, comment);
+    return true;
+  }
+
+  if (enclosingNode.body === followingNode) {
+    addLeadingComment(followingNode, comment);
+    return true;
+  }
+
+  return false;
+} // Same as IfStatement but for TryStatement
+
+
+function handleTryStatementComments(_ref5) {
+  var comment = _ref5.comment,
+      precedingNode = _ref5.precedingNode,
+      enclosingNode = _ref5.enclosingNode,
+      followingNode = _ref5.followingNode;
+
+  if (!enclosingNode || enclosingNode.type !== 'TryStatement' && enclosingNode.type !== 'CatchClause' || !followingNode) {
+    return false;
+  }
+
+  if (enclosingNode.type === 'CatchClause' && precedingNode) {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  }
+
+  if (followingNode.type === 'BlockStatement') {
+    addBlockStatementFirstComment(followingNode, comment);
+    return true;
+  }
+
+  if (followingNode.type === 'TryStatement') {
+    addBlockOrNotComment(followingNode.finalizer, comment);
+    return true;
+  }
+
+  if (followingNode.type === 'CatchClause') {
+    addBlockOrNotComment(followingNode.body, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleMemberExpressionComments(_ref6) {
+  var comment = _ref6.comment,
+      enclosingNode = _ref6.enclosingNode,
+      followingNode = _ref6.followingNode;
+
+  if (isMemberExpression(enclosingNode) && followingNode && followingNode.type === 'Identifier') {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  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));
+
+  if ((!precedingNode || !isSameLineAsPrecedingNode) && enclosingNode && (enclosingNode.type === 'ConditionalExpression' || enclosingNode.type === 'TSConditionalType') && followingNode) {
+    addLeadingComment(followingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleObjectPropertyAssignment(_ref8) {
+  var comment = _ref8.comment,
+      precedingNode = _ref8.precedingNode,
+      enclosingNode = _ref8.enclosingNode;
+
+  if (isObjectProperty(enclosingNode) && enclosingNode.shorthand && enclosingNode.key === precedingNode && enclosingNode.value.type === 'AssignmentPattern') {
+    addTrailingComment(enclosingNode.value.left, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleClassComments(_ref9) {
+  var comment = _ref9.comment,
+      precedingNode = _ref9.precedingNode,
+      enclosingNode = _ref9.enclosingNode,
+      followingNode = _ref9.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);
+      return true;
+    }
+
+    if (enclosingNode.body && followingNode === enclosingNode.body) {
+      addBlockStatementFirstComment(enclosingNode.body, comment);
+      return true;
+    } // Don't add leading comments to `implements`, `extends`, `mixins` to
+    // avoid printing the comment after the keyword.
+
+
+    if (followingNode) {
+      for (var _i = 0, _arr = ['implements', 'extends', 'mixins']; _i < _arr.length; _i++) {
+        var prop = _arr[_i];
+
+        if (enclosingNode[prop] && followingNode === enclosingNode[prop][0]) {
+          if (precedingNode && (precedingNode === enclosingNode.id || precedingNode === enclosingNode.typeParameters || precedingNode === enclosingNode.superClass)) {
+            addTrailingComment(precedingNode, comment);
+          } else {
+            addDanglingComment(enclosingNode, comment, prop);
+          }
+
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+function handleMethodNameComments(_ref10) {
+  var comment = _ref10.comment,
+      precedingNode = _ref10.precedingNode,
+      enclosingNode = _ref10.enclosingNode,
+      text = _ref10.text;
+
+  // This is only needed for estree parsers (flow, typescript) to attach
+  // after a method name:
+  // obj = { fn /*comment*/() {} };
+  if (enclosingNode && precedingNode && ( // "MethodDefinition" is handled in getCommentChildNodes
+  enclosingNode.type === 'Property' || enclosingNode.type === 'TSDeclareMethod' || enclosingNode.type === 'TSAbstractMethodDefinition') && precedingNode.type === 'Identifier' && enclosingNode.key === precedingNode && // special Property case: { key: /*comment*/(value) };
+  // comment should be attached to value instead of key
+  getNextNonSpaceNonCommentCharacter(text, precedingNode, locEnd) !== ':') {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  } // Print comments between decorators and class methods as a trailing comment
+  // on the decorator node instead of the method node
+
+
+  if (precedingNode && enclosingNode && precedingNode.type === 'Decorator' && (enclosingNode.type === 'ClassMethod' || enclosingNode.type === 'ClassProperty' || enclosingNode.type === 'PropertyDefinition' || enclosingNode.type === 'TSAbstractPropertyDefinition' || enclosingNode.type === 'TSAbstractMethodDefinition' || enclosingNode.type === 'TSDeclareMethod' || enclosingNode.type === 'MethodDefinition')) {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleFunctionNameComments(_ref11) {
+  var comment = _ref11.comment,
+      precedingNode = _ref11.precedingNode,
+      enclosingNode = _ref11.enclosingNode,
+      text = _ref11.text;
+
+  if (getNextNonSpaceNonCommentCharacter(text, comment, locEnd) !== '(') {
+    return false;
+  }
+
+  if (precedingNode && enclosingNode && (enclosingNode.type === 'FunctionDeclaration' || enclosingNode.type === 'FunctionExpression' || enclosingNode.type === 'ClassMethod' || enclosingNode.type === 'MethodDefinition' || enclosingNode.type === 'ObjectMethod')) {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleCommentAfterArrowParams(_ref12) {
+  var comment = _ref12.comment,
+      enclosingNode = _ref12.enclosingNode,
+      text = _ref12.text;
+
+  if (!(enclosingNode && enclosingNode.type === 'ArrowFunctionExpression')) {
+    return false;
+  }
+
+  var index = getNextNonSpaceNonCommentCharacterIndex(text, comment, locEnd);
+
+  if (index !== false && text.slice(index, index + 2) === '=>') {
+    addDanglingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleCommentInEmptyParens(_ref13) {
+  var comment = _ref13.comment,
+      enclosingNode = _ref13.enclosingNode,
+      text = _ref13.text;
+
+  if (getNextNonSpaceNonCommentCharacter(text, comment, locEnd) !== ')') {
+    return false;
+  } // Only add dangling comments to fix the case when no params are present,
+  // i.e. a function without any argument.
+
+
+  if (enclosingNode && (isRealFunctionLikeNode(enclosingNode) && getFunctionParameters(enclosingNode).length === 0 || isCallLikeExpression(enclosingNode) && getCallArguments(enclosingNode).length === 0)) {
+    addDanglingComment(enclosingNode, comment);
+    return true;
+  }
+
+  if (enclosingNode && (enclosingNode.type === 'MethodDefinition' || enclosingNode.type === 'TSAbstractMethodDefinition') && getFunctionParameters(enclosingNode.value).length === 0) {
+    addDanglingComment(enclosingNode.value, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleLastFunctionArgComments(_ref14) {
+  var comment = _ref14.comment,
+      precedingNode = _ref14.precedingNode,
+      enclosingNode = _ref14.enclosingNode,
+      followingNode = _ref14.followingNode,
+      text = _ref14.text;
+
+  // Flow function type definitions
+  if (precedingNode && precedingNode.type === 'FunctionTypeParam' && enclosingNode && enclosingNode.type === 'FunctionTypeAnnotation' && followingNode && followingNode.type !== 'FunctionTypeParam') {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  } // Real functions and TypeScript function type definitions
+
+
+  if (precedingNode && (precedingNode.type === 'Identifier' || precedingNode.type === 'AssignmentPattern') && enclosingNode && isRealFunctionLikeNode(enclosingNode) && getNextNonSpaceNonCommentCharacter(text, comment, locEnd) === ')') {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  }
+
+  if (enclosingNode && enclosingNode.type === 'FunctionDeclaration' && followingNode && followingNode.type === 'BlockStatement') {
+    var functionParamRightParenIndex = function () {
+      var parameters = getFunctionParameters(enclosingNode);
+
+      if (parameters.length > 0) {
+        return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(getLast(parameters)));
+      }
+
+      var functionParamLeftParenIndex = getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(enclosingNode.id));
+      return functionParamLeftParenIndex !== false && getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, functionParamLeftParenIndex + 1);
+    }();
+
+    if (locStart(comment) > functionParamRightParenIndex) {
+      addBlockStatementFirstComment(followingNode, comment);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function handleImportSpecifierComments(_ref15) {
+  var comment = _ref15.comment,
+      enclosingNode = _ref15.enclosingNode;
+
+  if (enclosingNode && enclosingNode.type === 'ImportSpecifier') {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleLabeledStatementComments(_ref16) {
+  var comment = _ref16.comment,
+      enclosingNode = _ref16.enclosingNode;
+
+  if (enclosingNode && enclosingNode.type === 'LabeledStatement') {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleBreakAndContinueStatementComments(_ref17) {
+  var comment = _ref17.comment,
+      enclosingNode = _ref17.enclosingNode;
+
+  if (enclosingNode && (enclosingNode.type === 'ContinueStatement' || enclosingNode.type === 'BreakStatement') && !enclosingNode.label) {
+    addTrailingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleCallExpressionComments(_ref18) {
+  var comment = _ref18.comment,
+      precedingNode = _ref18.precedingNode,
+      enclosingNode = _ref18.enclosingNode;
+
+  if (isCallExpression(enclosingNode) && precedingNode && enclosingNode.callee === precedingNode && enclosingNode.arguments.length > 0) {
+    addLeadingComment(enclosingNode.arguments[0], comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleUnionTypeComments(_ref19) {
+  var comment = _ref19.comment,
+      precedingNode = _ref19.precedingNode,
+      enclosingNode = _ref19.enclosingNode,
+      followingNode = _ref19.followingNode;
+
+  if (enclosingNode && (enclosingNode.type === 'UnionTypeAnnotation' || enclosingNode.type === 'TSUnionType')) {
+    if (isPrettierIgnoreComment(comment)) {
+      followingNode.prettierIgnore = true;
+      comment.unignore = true;
+    }
+
+    if (precedingNode) {
+      addTrailingComment(precedingNode, comment);
+      return true;
+    }
+
+    return false;
+  }
+
+  if (followingNode && (followingNode.type === 'UnionTypeAnnotation' || followingNode.type === 'TSUnionType') && isPrettierIgnoreComment(comment)) {
+    followingNode.types[0].prettierIgnore = true;
+    comment.unignore = true;
+  }
+
+  return false;
+}
+
+function handlePropertyComments(_ref20) {
+  var comment = _ref20.comment,
+      enclosingNode = _ref20.enclosingNode;
+
+  if (isObjectProperty(enclosingNode)) {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleOnlyComments(_ref21) {
+  var comment = _ref21.comment,
+      enclosingNode = _ref21.enclosingNode,
+      followingNode = _ref21.followingNode,
+      ast = _ref21.ast,
+      isLastComment = _ref21.isLastComment;
+
+  // With Flow the enclosingNode is undefined so use the AST instead.
+  if (ast && ast.body && ast.body.length === 0) {
+    if (isLastComment) {
+      addDanglingComment(ast, comment);
+    } else {
+      addLeadingComment(ast, comment);
+    }
+
+    return true;
+  }
+
+  if (enclosingNode && enclosingNode.type === 'Program' && enclosingNode.body.length === 0 && !isNonEmptyArray(enclosingNode.directives)) {
+    if (isLastComment) {
+      addDanglingComment(enclosingNode, comment);
+    } else {
+      addLeadingComment(enclosingNode, comment);
+    }
+
+    return true;
+  }
+
+  if (followingNode && followingNode.type === 'Program' && followingNode.body.length === 0 && enclosingNode && enclosingNode.type === 'ModuleExpression') {
+    addDanglingComment(followingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleForComments(_ref22) {
+  var comment = _ref22.comment,
+      enclosingNode = _ref22.enclosingNode;
+
+  if (enclosingNode && (enclosingNode.type === 'ForInStatement' || enclosingNode.type === 'ForOfStatement')) {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleImportDeclarationComments(_ref23) {
+  var comment = _ref23.comment,
+      precedingNode = _ref23.precedingNode,
+      enclosingNode = _ref23.enclosingNode,
+      text = _ref23.text;
+
+  if (precedingNode && precedingNode.type === 'ImportSpecifier' && enclosingNode && enclosingNode.type === 'ImportDeclaration' && hasNewline(text, locEnd(comment))) {
+    addTrailingComment(precedingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleAssignmentPatternComments(_ref24) {
+  var comment = _ref24.comment,
+      enclosingNode = _ref24.enclosingNode;
+
+  if (enclosingNode && enclosingNode.type === 'AssignmentPattern') {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleTypeAliasComments(_ref25) {
+  var comment = _ref25.comment,
+      enclosingNode = _ref25.enclosingNode;
+
+  if (enclosingNode && enclosingNode.type === 'TypeAlias') {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleVariableDeclaratorComments(_ref26) {
+  var comment = _ref26.comment,
+      enclosingNode = _ref26.enclosingNode,
+      followingNode = _ref26.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;
+  }
+
+  return false;
+}
+
+function handleTSFunctionTrailingComments(_ref27) {
+  var comment = _ref27.comment,
+      enclosingNode = _ref27.enclosingNode,
+      followingNode = _ref27.followingNode,
+      text = _ref27.text;
+
+  if (!followingNode && enclosingNode && (enclosingNode.type === 'TSMethodSignature' || enclosingNode.type === 'TSDeclareFunction' || enclosingNode.type === 'TSAbstractMethodDefinition') && getNextNonSpaceNonCommentCharacter(text, comment, locEnd) === ';') {
+    addTrailingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+function handleIgnoreComments(_ref28) {
+  var comment = _ref28.comment,
+      enclosingNode = _ref28.enclosingNode,
+      followingNode = _ref28.followingNode;
+
+  if (isPrettierIgnoreComment(comment) && enclosingNode && enclosingNode.type === 'TSMappedType' && followingNode && followingNode.type === 'TSTypeParameter' && followingNode.constraint) {
+    enclosingNode.prettierIgnore = true;
+    comment.unignore = true;
+    return true;
+  }
+}
+
+function handleTSMappedTypeComments(_ref29) {
+  var comment = _ref29.comment,
+      precedingNode = _ref29.precedingNode,
+      enclosingNode = _ref29.enclosingNode,
+      followingNode = _ref29.followingNode;
+
+  if (!enclosingNode || enclosingNode.type !== 'TSMappedType') {
+    return false;
+  }
+
+  if (followingNode && followingNode.type === 'TSTypeParameter' && followingNode.name) {
+    addLeadingComment(followingNode.name, comment);
+    return true;
+  }
+
+  if (precedingNode && precedingNode.type === 'TSTypeParameter' && precedingNode.constraint) {
+    addTrailingComment(precedingNode.constraint, comment);
+    return true;
+  }
+
+  return false;
+}
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */
+
+
+function isRealFunctionLikeNode(node) {
+  return node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'ObjectMethod' || node.type === 'ClassMethod' || node.type === 'TSDeclareFunction' || node.type === 'TSCallSignatureDeclaration' || node.type === 'TSConstructSignatureDeclaration' || node.type === 'TSMethodSignature' || node.type === 'TSConstructorType' || node.type === 'TSFunctionType' || node.type === 'TSDeclareMethod';
+}
+/**
+ * @param {any} node
+ * @returns {Node[] | void}
+ */
+
+
+function getCommentChildNodes(node, options) {
+  // Prevent attaching comments to FunctionExpression in this case:
+  //     class Foo {
+  //       bar() // comment
+  //       {
+  //         baz();
+  //       }
+  //     }
+  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]);
+  }
+}
+/**
+ * @param {Comment} comment
+ * @returns {boolean}
+ */
+
+
+function isTypeCastComment(comment) {
+  return isBlockComment(comment) && comment.value[0] === '*' && // TypeScript expects the type to be enclosed in curly brackets, however
+  // Closure Compiler accepts types in parens and even without any delimiters at all.
+  // That's why we just search for "@type".
+  /@type\b/.test(comment.value);
+}
+
+module.exports = {
+  handleOwnLineComment: handleOwnLineComment,
+  handleEndOfLineComment: handleEndOfLineComment,
+  handleRemainingComment: handleRemainingComment,
+  getCommentChildNodes: getCommentChildNodes
+};