hermes-transform 0.5.0 → 0.6.0

package/dist/transform/comments/prettier/main/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,61 +8,34 @@
  */
 'use strict';
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+const assert = require('assert');
 
-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."); }
+const {
+  hasNewline,
+  addLeadingComment,
+  addDanglingComment,
+  addTrailingComment
+} = require('../common/util.js');
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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; }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var assert = require('assert');
-
-var _require = require('../common/util.js'),
-    hasNewline = _require.hasNewline,
-    addLeadingComment = _require.addLeadingComment,
-    addDanglingComment = _require.addDanglingComment,
-    addTrailingComment = _require.addTrailingComment;
-
-var childNodesCache = new WeakMap();
+const childNodesCache = new WeakMap();
 
 function getSortedChildNodes(node, options, resultArray) {
   if (!node) {
     return;
   }
 
-  var printer = options.printer,
-      locStart = options.locStart,
-      locEnd = options.locEnd;
+  const {
+    printer,
+    locStart,
+    locEnd
+  } = options;
 
   if (resultArray) {
     if (printer.canAttachComment && printer.canAttachComment(node)) {
       // This reverse insertion sort almost always takes constant
       // time because we almost always (maybe always?) append the
       // nodes in order anyway.
-      var i;
+      let i;
 
       for (i = resultArray.length - 1; i >= 0; --i) {
         if (locStart(resultArray[i]) <= locStart(node) && locEnd(resultArray[i]) <= locEnd(node)) {
@@ -77,17 +50,7 @@ function getSortedChildNodes(node, options, resultArray) {
     return childNodesCache.get(node);
   }
 
-  var childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || _typeof(node) === 'object' && Object.entries(node).filter(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 1),
-        key = _ref2[0];
-
-    return key !== 'enclosingNode' && key !== 'precedingNode' && key !== 'followingNode' && key !== 'tokens' && key !== 'comments';
-  }).map(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-        value = _ref4[1];
-
-    return 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').map(([, value]) => value);
 
   if (!childNodes) {
     return;
@@ -98,18 +61,8 @@ function getSortedChildNodes(node, options, resultArray) {
     childNodesCache.set(node, resultArray);
   }
 
-  var _iterator = _createForOfIteratorHelper(childNodes),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var childNode = _step.value;
-      getSortedChildNodes(childNode, options, resultArray);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  for (const childNode of childNodes) {
+    getSortedChildNodes(childNode, options, resultArray);
   }
 
   return resultArray;
@@ -119,22 +72,24 @@ function getSortedChildNodes(node, options, resultArray) {
 
 
 function decorateComment(node, comment, options, enclosingNode) {
-  var locStart = options.locStart,
-      locEnd = options.locEnd;
-  var commentStart = locStart(comment);
-  var commentEnd = locEnd(comment);
-  var childNodes = getSortedChildNodes(node, options);
-  var precedingNode;
-  var followingNode; // Time to dust off the old binary search robes and wizard hat.
-
-  var left = 0;
-  var right = childNodes.length;
+  const {
+    locStart,
+    locEnd
+  } = options;
+  const commentStart = locStart(comment);
+  const commentEnd = locEnd(comment);
+  const childNodes = getSortedChildNodes(node, options);
+  let precedingNode;
+  let followingNode; // Time to dust off the old binary search robes and wizard hat.
+
+  let left = 0;
+  let right = childNodes.length;
 
   while (left < right) {
-    var middle = left + right >> 1;
-    var child = childNodes[middle];
-    var start = locStart(child);
-    var end = locEnd(child); // The comment is completely contained by this child node.
+    const middle = left + right >> 1;
+    const child = childNodes[middle];
+    const start = locStart(child);
+    const end = locEnd(child); // The comment is completely contained by this child node.
 
     if (start <= commentStart && commentEnd <= end) {
       // Abandon the binary search at this level.
@@ -169,8 +124,10 @@ function decorateComment(node, comment, options, enclosingNode) {
 
 
   if (enclosingNode && enclosingNode.type === 'TemplateLiteral') {
-    var quasis = enclosingNode.quasis;
-    var commentIndex = findExpressionIndexForComment(quasis, comment, options);
+    const {
+      quasis
+    } = enclosingNode;
+    const commentIndex = findExpressionIndexForComment(quasis, comment, options);
 
     if (precedingNode && findExpressionIndexForComment(quasis, precedingNode, options) !== commentIndex) {
       precedingNode = null;
@@ -182,210 +139,189 @@ function decorateComment(node, comment, options, enclosingNode) {
   }
 
   return {
-    enclosingNode: enclosingNode,
-    precedingNode: precedingNode,
-    followingNode: followingNode
+    enclosingNode,
+    precedingNode,
+    followingNode
   };
 }
 
-var returnFalse = function returnFalse() {
-  return false;
-};
+const returnFalse = () => false;
 
 function attach(comments, ast, text, options) {
   if (!Array.isArray(comments)) {
     return;
   }
 
-  var tiesToBreak = [];
-  var locStart = options.locStart,
-      locEnd = options.locEnd,
-      _options$printer$hand = options.printer.handleComments,
-      handleComments = _options$printer$hand === void 0 ? {} : _options$printer$hand; // TODO: Make this as default behavior
-
-  var avoidAstMutation = handleComments.avoidAstMutation,
-      _handleComments$ownLi = handleComments.ownLine,
-      handleOwnLineComment = _handleComments$ownLi === void 0 ? returnFalse : _handleComments$ownLi,
-      _handleComments$endOf = handleComments.endOfLine,
-      handleEndOfLineComment = _handleComments$endOf === void 0 ? returnFalse : _handleComments$endOf,
-      _handleComments$remai = handleComments.remaining,
-      handleRemainingComment = _handleComments$remai === void 0 ? returnFalse : _handleComments$remai;
-  var decoratedComments = comments.map(function (comment, index) {
-    return _objectSpread(_objectSpread({}, decorateComment(ast, comment, options)), {}, {
-      comment: comment,
-      text: text,
-      options: options,
-      ast: ast,
-      isLastComment: comments.length - 1 === index
-    });
-  });
-
-  var _iterator2 = _createForOfIteratorHelper(decoratedComments.entries()),
-      _step2;
-
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var _step2$value = _slicedToArray(_step2.value, 2),
-          index = _step2$value[0],
-          context = _step2$value[1];
-
-      var _comment = context.comment,
-          precedingNode = context.precedingNode,
-          enclosingNode = context.enclosingNode,
-          followingNode = context.followingNode,
-          _text = context.text,
-          _options = context.options,
-          _ast = context.ast,
-          isLastComment = context.isLastComment;
-
-      if (_options.parser === 'json' || _options.parser === 'json5' || _options.parser === '__js_expression' || _options.parser === '__vue_expression') {
-        if (locStart(_comment) - locStart(_ast) <= 0) {
-          addLeadingComment(_ast, _comment);
-          continue;
-        }
+  const tiesToBreak = [];
+  const {
+    locStart,
+    locEnd,
+    printer: {
+      handleComments = {}
+    }
+  } = options; // TODO: Make this as default behavior
+
+  const {
+    avoidAstMutation,
+    ownLine: handleOwnLineComment = returnFalse,
+    endOfLine: handleEndOfLineComment = returnFalse,
+    remaining: handleRemainingComment = returnFalse
+  } = handleComments;
+  const decoratedComments = comments.map((comment, index) => ({ ...decorateComment(ast, comment, options),
+    comment,
+    text,
+    options,
+    ast,
+    isLastComment: comments.length - 1 === index
+  }));
+
+  for (const [index, context] of decoratedComments.entries()) {
+    const {
+      comment,
+      precedingNode,
+      enclosingNode,
+      followingNode,
+      text,
+      options,
+      ast,
+      isLastComment
+    } = context;
+
+    if (options.parser === 'json' || options.parser === 'json5' || options.parser === '__js_expression' || options.parser === '__vue_expression') {
+      if (locStart(comment) - locStart(ast) <= 0) {
+        addLeadingComment(ast, comment);
+        continue;
+      }
 
-        if (locEnd(_comment) - locEnd(_ast) >= 0) {
-          addTrailingComment(_ast, _comment);
-          continue;
-        }
+      if (locEnd(comment) - locEnd(ast) >= 0) {
+        addTrailingComment(ast, comment);
+        continue;
       }
+    }
+
+    let args;
 
-      var args = void 0;
+    if (avoidAstMutation) {
+      args = [context];
+    } else {
+      comment.enclosingNode = enclosingNode;
+      comment.precedingNode = precedingNode;
+      comment.followingNode = followingNode;
+      args = [comment, text, options, ast, isLastComment];
+    }
 
-      if (avoidAstMutation) {
-        args = [context];
+    if (isOwnLineComment(text, options, decoratedComments, index)) {
+      comment.placement = 'ownLine'; // If a comment exists on its own line, prefer a leading comment.
+      // We also need to check if it's the first line of the file.
+
+      if (handleOwnLineComment(...args)) {// We're good
+      } else if (followingNode) {
+        // Always a leading comment.
+        addLeadingComment(followingNode, comment);
+      } else if (precedingNode) {
+        addTrailingComment(precedingNode, comment);
+      } else if (enclosingNode) {
+        addDanglingComment(enclosingNode, comment);
       } else {
-        _comment.enclosingNode = enclosingNode;
-        _comment.precedingNode = precedingNode;
-        _comment.followingNode = followingNode;
-        args = [_comment, _text, _options, _ast, isLastComment];
+        // There are no nodes, let's attach it to the root of the ast
+
+        /* istanbul ignore next */
+        addDanglingComment(ast, comment);
       }
+    } else if (isEndOfLineComment(text, options, decoratedComments, index)) {
+      comment.placement = 'endOfLine';
+
+      if (handleEndOfLineComment(...args)) {// We're good
+      } else if (precedingNode) {
+        // There is content before this comment on the same line, but
+        // none after it, so prefer a trailing comment of the previous node.
+        addTrailingComment(precedingNode, comment);
+      } else if (followingNode) {
+        addLeadingComment(followingNode, comment);
+      } else if (enclosingNode) {
+        addDanglingComment(enclosingNode, comment);
+      } else {
+        // There are no nodes, let's attach it to the root of the ast
 
-      if (isOwnLineComment(_text, _options, decoratedComments, index)) {
-        _comment.placement = 'ownLine'; // If a comment exists on its own line, prefer a leading comment.
-        // We also need to check if it's the first line of the file.
-
-        if (handleOwnLineComment.apply(void 0, _toConsumableArray(args))) {// We're good
-        } else if (followingNode) {
-          // Always a leading comment.
-          addLeadingComment(followingNode, _comment);
-        } else if (precedingNode) {
-          addTrailingComment(precedingNode, _comment);
-        } else if (enclosingNode) {
-          addDanglingComment(enclosingNode, _comment);
-        } else {
-          // There are no nodes, let's attach it to the root of the ast
-
-          /* istanbul ignore next */
-          addDanglingComment(_ast, _comment);
-        }
-      } else if (isEndOfLineComment(_text, _options, decoratedComments, index)) {
-        _comment.placement = 'endOfLine';
-
-        if (handleEndOfLineComment.apply(void 0, _toConsumableArray(args))) {// We're good
-        } else if (precedingNode) {
-          // There is content before this comment on the same line, but
-          // none after it, so prefer a trailing comment of the previous node.
-          addTrailingComment(precedingNode, _comment);
-        } else if (followingNode) {
-          addLeadingComment(followingNode, _comment);
-        } else if (enclosingNode) {
-          addDanglingComment(enclosingNode, _comment);
-        } else {
-          // There are no nodes, let's attach it to the root of the ast
-
-          /* istanbul ignore next */
-          addDanglingComment(_ast, _comment);
+        /* istanbul ignore next */
+        addDanglingComment(ast, comment);
+      }
+    } else {
+      comment.placement = 'remaining';
+
+      if (handleRemainingComment(...args)) {// We're good
+      } else if (precedingNode && followingNode) {
+        // Otherwise, text exists both before and after the comment on
+        // the same line. If there is both a preceding and following
+        // node, use a tie-breaking algorithm to determine if it should
+        // be attached to the next or previous node. In the last case,
+        // simply attach the right node;
+        const tieCount = tiesToBreak.length;
+
+        if (tieCount > 0) {
+          const lastTie = tiesToBreak[tieCount - 1];
+
+          if (lastTie.followingNode !== followingNode) {
+            breakTies(tiesToBreak, text, options);
+          }
         }
+
+        tiesToBreak.push(context);
+      } else if (precedingNode) {
+        addTrailingComment(precedingNode, comment);
+      } else if (followingNode) {
+        addLeadingComment(followingNode, comment);
+      } else if (enclosingNode) {
+        addDanglingComment(enclosingNode, comment);
       } else {
-        _comment.placement = 'remaining';
-
-        if (handleRemainingComment.apply(void 0, _toConsumableArray(args))) {// We're good
-        } else if (precedingNode && followingNode) {
-          // Otherwise, text exists both before and after the comment on
-          // the same line. If there is both a preceding and following
-          // node, use a tie-breaking algorithm to determine if it should
-          // be attached to the next or previous node. In the last case,
-          // simply attach the right node;
-          var tieCount = tiesToBreak.length;
-
-          if (tieCount > 0) {
-            var lastTie = tiesToBreak[tieCount - 1];
-
-            if (lastTie.followingNode !== followingNode) {
-              breakTies(tiesToBreak, _text, _options);
-            }
-          }
+        // There are no nodes, let's attach it to the root of the ast
 
-          tiesToBreak.push(context);
-        } else if (precedingNode) {
-          addTrailingComment(precedingNode, _comment);
-        } else if (followingNode) {
-          addLeadingComment(followingNode, _comment);
-        } else if (enclosingNode) {
-          addDanglingComment(enclosingNode, _comment);
-        } else {
-          // There are no nodes, let's attach it to the root of the ast
-
-          /* istanbul ignore next */
-          addDanglingComment(_ast, _comment);
-        }
+        /* istanbul ignore next */
+        addDanglingComment(ast, comment);
       }
     }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
   }
 
   breakTies(tiesToBreak, text, options);
 
   if (!avoidAstMutation) {
-    var _iterator3 = _createForOfIteratorHelper(comments),
-        _step3;
-
-    try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        var comment = _step3.value;
-        // These node references were useful for breaking ties, but we
-        // don't need them anymore, and they create cycles in the AST that
-        // may lead to infinite recursion if we don't delete them here.
-        delete comment.precedingNode;
-        delete comment.enclosingNode;
-        delete comment.followingNode;
-      }
-    } catch (err) {
-      _iterator3.e(err);
-    } finally {
-      _iterator3.f();
+    for (const comment of comments) {
+      // These node references were useful for breaking ties, but we
+      // don't need them anymore, and they create cycles in the AST that
+      // may lead to infinite recursion if we don't delete them here.
+      delete comment.precedingNode;
+      delete comment.enclosingNode;
+      delete comment.followingNode;
     }
   }
 }
 
-var isAllEmptyAndNoLineBreak = function isAllEmptyAndNoLineBreak(text) {
-  return !/[\S\n\u2028\u2029]/.test(text);
-};
+const isAllEmptyAndNoLineBreak = text => !/[\S\n\u2028\u2029]/.test(text);
 
 function isOwnLineComment(text, options, decoratedComments, commentIndex) {
-  var _decoratedComments$co = decoratedComments[commentIndex],
-      comment = _decoratedComments$co.comment,
-      precedingNode = _decoratedComments$co.precedingNode;
-  var locStart = options.locStart,
-      locEnd = options.locEnd;
-  var start = locStart(comment);
+  const {
+    comment,
+    precedingNode
+  } = decoratedComments[commentIndex];
+  const {
+    locStart,
+    locEnd
+  } = options;
+  let start = locStart(comment);
 
   if (precedingNode) {
     // Find first comment on the same line
-    for (var index = commentIndex - 1; index >= 0; index--) {
-      var _decoratedComments$in = decoratedComments[index],
-          _comment2 = _decoratedComments$in.comment,
-          currentCommentPrecedingNode = _decoratedComments$in.precedingNode;
+    for (let index = commentIndex - 1; index >= 0; index--) {
+      const {
+        comment,
+        precedingNode: currentCommentPrecedingNode
+      } = decoratedComments[index];
 
-      if (currentCommentPrecedingNode !== precedingNode || !isAllEmptyAndNoLineBreak(text.slice(locEnd(_comment2), start))) {
+      if (currentCommentPrecedingNode !== precedingNode || !isAllEmptyAndNoLineBreak(text.slice(locEnd(comment), start))) {
         break;
       }
 
-      start = locStart(_comment2);
+      start = locStart(comment);
     }
   }
 
@@ -395,25 +331,29 @@ function isOwnLineComment(text, options, decoratedComments, commentIndex) {
 }
 
 function isEndOfLineComment(text, options, decoratedComments, commentIndex) {
-  var _decoratedComments$co2 = decoratedComments[commentIndex],
-      comment = _decoratedComments$co2.comment,
-      followingNode = _decoratedComments$co2.followingNode;
-  var locStart = options.locStart,
-      locEnd = options.locEnd;
-  var end = locEnd(comment);
+  const {
+    comment,
+    followingNode
+  } = decoratedComments[commentIndex];
+  const {
+    locStart,
+    locEnd
+  } = options;
+  let end = locEnd(comment);
 
   if (followingNode) {
     // Find last comment on the same line
-    for (var index = commentIndex + 1; index < decoratedComments.length; index++) {
-      var _decoratedComments$in2 = decoratedComments[index],
-          _comment3 = _decoratedComments$in2.comment,
-          currentCommentFollowingNode = _decoratedComments$in2.followingNode;
+    for (let index = commentIndex + 1; index < decoratedComments.length; index++) {
+      const {
+        comment,
+        followingNode: currentCommentFollowingNode
+      } = decoratedComments[index];
 
-      if (currentCommentFollowingNode !== followingNode || !isAllEmptyAndNoLineBreak(text.slice(end, locStart(_comment3)))) {
+      if (currentCommentFollowingNode !== followingNode || !isAllEmptyAndNoLineBreak(text.slice(end, locStart(comment)))) {
         break;
       }
 
-      end = locEnd(_comment3);
+      end = locEnd(comment);
     }
   }
 
@@ -421,33 +361,35 @@ function isEndOfLineComment(text, options, decoratedComments, commentIndex) {
 }
 
 function breakTies(tiesToBreak, text, options) {
-  var tieCount = tiesToBreak.length;
+  const tieCount = tiesToBreak.length;
 
   if (tieCount === 0) {
     return;
   }
 
-  var _tiesToBreak$ = tiesToBreak[0],
-      precedingNode = _tiesToBreak$.precedingNode,
-      followingNode = _tiesToBreak$.followingNode,
-      enclosingNode = _tiesToBreak$.enclosingNode;
-  var gapRegExp = options.printer.getGapRegex && options.printer.getGapRegex(enclosingNode) || /^[\s(]*$/;
-  var gapEndPos = options.locStart(followingNode); // Iterate backwards through tiesToBreak, examining the gaps
+  const {
+    precedingNode,
+    followingNode,
+    enclosingNode
+  } = tiesToBreak[0];
+  const gapRegExp = options.printer.getGapRegex && options.printer.getGapRegex(enclosingNode) || /^[\s(]*$/;
+  let gapEndPos = options.locStart(followingNode); // Iterate backwards through tiesToBreak, examining the gaps
   // between the tied comments. In order to qualify as leading, a
   // comment must be separated from followingNode by an unbroken series of
   // gaps (or other comments). Gaps should only contain whitespace or open
   // parentheses.
 
-  var indexOfFirstLeadingComment;
+  let indexOfFirstLeadingComment;
 
   for (indexOfFirstLeadingComment = tieCount; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
-    var _tiesToBreak = tiesToBreak[indexOfFirstLeadingComment - 1],
-        comment = _tiesToBreak.comment,
-        currentCommentPrecedingNode = _tiesToBreak.precedingNode,
-        currentCommentFollowingNode = _tiesToBreak.followingNode;
+    const {
+      comment,
+      precedingNode: currentCommentPrecedingNode,
+      followingNode: currentCommentFollowingNode
+    } = tiesToBreak[indexOfFirstLeadingComment - 1];
     assert.strictEqual(currentCommentPrecedingNode, precedingNode);
     assert.strictEqual(currentCommentFollowingNode, followingNode);
-    var gap = text.slice(options.locEnd(comment), gapEndPos);
+    const gap = text.slice(options.locEnd(comment), gapEndPos);
 
     if (gapRegExp.test(gap)) {
       gapEndPos = options.locStart(comment);
@@ -458,34 +400,19 @@ function breakTies(tiesToBreak, text, options) {
     }
   }
 
-  var _iterator4 = _createForOfIteratorHelper(tiesToBreak.entries()),
-      _step4;
-
-  try {
-    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-      var _step4$value = _slicedToArray(_step4.value, 2),
-          i = _step4$value[0],
-          _comment4 = _step4$value[1].comment;
-
-      if (i < indexOfFirstLeadingComment) {
-        addTrailingComment(precedingNode, _comment4);
-      } else {
-        addLeadingComment(followingNode, _comment4);
-      }
+  for (const [i, {
+    comment
+  }] of tiesToBreak.entries()) {
+    if (i < indexOfFirstLeadingComment) {
+      addTrailingComment(precedingNode, comment);
+    } else {
+      addLeadingComment(followingNode, comment);
     }
-  } catch (err) {
-    _iterator4.e(err);
-  } finally {
-    _iterator4.f();
   }
 
-  for (var _i2 = 0, _arr2 = [precedingNode, followingNode]; _i2 < _arr2.length; _i2++) {
-    var node = _arr2[_i2];
-
+  for (const node of [precedingNode, followingNode]) {
     if (node.comments && node.comments.length > 1) {
-      node.comments.sort(function (a, b) {
-        return options.locStart(a) - options.locStart(b);
-      });
+      node.comments.sort((a, b) => options.locStart(a) - options.locStart(b));
     }
   }
 
@@ -493,9 +420,9 @@ function breakTies(tiesToBreak, text, options) {
 }
 
 function findExpressionIndexForComment(quasis, comment, options) {
-  var startPos = options.locStart(comment) - 1;
+  const startPos = options.locStart(comment) - 1;
 
-  for (var i = 1; i < quasis.length; ++i) {
+  for (let i = 1; i < quasis.length; ++i) {
     if (startPos < options.locStart(quasis[i])) {
       return i - 1;
     }
@@ -509,5 +436,5 @@ function findExpressionIndexForComment(quasis, comment, options) {
 }
 
 module.exports = {
-  attach: attach
+  attach
 };