text: "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  var _base = _interopRequireDefault(require("./base"));
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function last(stack) {
    return stack[stack.length - 1];
  }
  
  class CommentsParser extends _base.default {
    addComment(comment) {
      if (this.filename) comment.loc.filename = this.filename;
      this.state.trailingComments.push(comment);
      this.state.leadingComments.push(comment);
    }
  
    adjustCommentsAfterTrailingComma(node, elements, takeAllComments) {
      if (this.state.leadingComments.length === 0) {
        return;
      }
  
      let lastElement = null;
      let i = elements.length;
  
      while (lastElement === null && i > 0) {
        lastElement = elements[--i];
      }
  
      if (lastElement === null) {
        return;
      }
  
      for (let j = 0; j < this.state.leadingComments.length; j++) {
        if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
          this.state.leadingComments.splice(j, 1);
          j--;
        }
      }
  
      const newTrailingComments = [];
  
      for (let i = 0; i < this.state.leadingComments.length; i++) {
        const leadingComment = this.state.leadingComments[i];
  
        if (leadingComment.end < node.end) {
          newTrailingComments.push(leadingComment);
  
          if (!takeAllComments) {
            this.state.leadingComments.splice(i, 1);
            i--;
          }
        } else {
          if (node.trailingComments === undefined) {
            node.trailingComments = [];
          }
  
          node.trailingComments.push(leadingComment);
        }
      }
  
      if (takeAllComments) this.state.leadingComments = [];
  
      if (newTrailingComments.length > 0) {
        lastElement.trailingComments = newTrailingComments;
      } else if (lastElement.trailingComments !== undefined) {
        lastElement.trailingComments = [];
      }
    }
  
    processComment(node) {
      if (node.type === "Program" && node.body.length > 0) return;
      const stack = this.state.commentStack;
      let firstChild, lastChild, trailingComments, i, j;
  
      if (this.state.trailingComments.length > 0) {
        if (this.state.trailingComments[0].start >= node.end) {
          trailingComments = this.state.trailingComments;
          this.state.trailingComments = [];
        } else {
          this.state.trailingComments.length = 0;
        }
      } else if (stack.length > 0) {
        const lastInStack = last(stack);
  
        if (lastInStack.trailingComments && lastInStack.trailingComments[0].start >= node.end) {
          trailingComments = lastInStack.trailingComments;
          delete lastInStack.trailingComments;
        }
      }
  
      if (stack.length > 0 && last(stack).start >= node.start) {
        firstChild = stack.pop();
      }
  
      while (stack.length > 0 && last(stack).start >= node.start) {
        lastChild = stack.pop();
      }
  
      if (!lastChild && firstChild) lastChild = firstChild;
  
      if (firstChild) {
        switch (node.type) {
          case "ObjectExpression":
            this.adjustCommentsAfterTrailingComma(node, node.properties);
            break;
  
          case "ObjectPattern":
            this.adjustCommentsAfterTrailingComma(node, node.properties, true);
            break;
  
          case "CallExpression":
            this.adjustCommentsAfterTrailingComma(node, node.arguments);
            break;
  
          case "ArrayExpression":
            this.adjustCommentsAfterTrailingComma(node, node.elements);
            break;
  
          case "ArrayPattern":
            this.adjustCommentsAfterTrailingComma(node, node.elements, true);
            break;
        }
      } else if (this.state.commentPreviousNode && (this.state.commentPreviousNode.type === "ImportSpecifier" && node.type !== "ImportSpecifier" || this.state.commentPreviousNode.type === "ExportSpecifier" && node.type !== "ExportSpecifier")) {
        this.adjustCommentsAfterTrailingComma(node, [this.state.commentPreviousNode], true);
      }
  
      if (lastChild) {
        if (lastChild.leadingComments) {
          if (lastChild !== node && lastChild.leadingComments.length > 0 && last(lastChild.leadingComments).end <= node.start) {
            node.leadingComments = lastChild.leadingComments;
            delete lastChild.leadingComments;
          } else {
            for (i = lastChild.leadingComments.length - 2; i >= 0; --i) {
              if (lastChild.leadingComments[i].end <= node.start) {
                node.leadingComments = lastChild.leadingComments.splice(0, i + 1);
                break;
              }
            }
          }
        }
      } else if (this.state.leadingComments.length > 0) {
        if (last(this.state.leadingComments).end <= node.start) {
          if (this.state.commentPreviousNode) {
            for (j = 0; j < this.state.leadingComments.length; j++) {
              if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
                this.state.leadingComments.splice(j, 1);
                j--;
              }
            }
          }
  
          if (this.state.leadingComments.length > 0) {
            node.leadingComments = this.state.leadingComments;
            this.state.leadingComments = [];
          }
        } else {
          for (i = 0; i < this.state.leadingComments.length; i++) {
            if (this.state.leadingComments[i].end > node.start) {
              break;
            }
          }
  
          const leadingComments = this.state.leadingComments.slice(0, i);
  
          if (leadingComments.length) {
            node.leadingComments = leadingComments;
          }
  
          trailingComments = this.state.leadingComments.slice(i);
  
          if (trailingComments.length === 0) {
            trailingComments = null;
          }
        }
      }
  
      this.state.commentPreviousNode = node;
  
      if (trailingComments) {
        if (trailingComments.length && trailingComments[0].start >= node.start && last(trailingComments).end <= node.end) {
          node.innerComments = trailingComments;
        } else {
          node.trailingComments = trailingComments;
        }
      }
  
      stack.push(node);
    }
  
  }
  
  exports.default = CommentsParser;