@coana-tech/cli 14.12.193 → 14.12.195

package/repos/coana-tech/jelly-private/dist/bundle/node_modules/@babel/generator/lib/printer.js

@@ -6,11 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _buffer = require("./buffer.js");
 var _index = require("./node/index.js");
-var n = _index;
+var _nodes = require("./nodes.js");
 var _t = require("@babel/types");
 var _tokenMap = require("./token-map.js");
-var generatorFunctions = require("./generators/index.js");
-var _deprecated = require("./generators/deprecated.js");
+var _types2 = require("./generators/types.js");
 const {
   isExpression,
   isFunction,
@@ -26,15 +25,13 @@ const HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\n\r\u2028\u2029]|\*\//;
 function commentIsNewline(c) {
   return c.type === "CommentLine" || HAS_NEWLINE.test(c.value);
 }
-const {
-  needsParens
-} = n;
 class Printer {
   constructor(format, map, tokens = null, originalCode = null) {
     this.tokenContext = _index.TokenContext.normal;
     this._tokens = null;
     this._originalCode = null;
     this._currentNode = null;
+    this._currentTypeId = null;
     this._indent = 0;
     this._indentRepeat = 0;
     this._insideAux = false;
@@ -42,14 +39,11 @@ class Printer {
     this._noLineTerminatorAfterNode = null;
     this._printAuxAfterOnNextUserNode = false;
     this._printedComments = new Set();
-    this._endsWithInteger = false;
-    this._endsWithWord = false;
-    this._endsWithDiv = false;
     this._lastCommentLine = 0;
-    this._endsWithInnerRaw = false;
-    this._indentInnerComments = true;
+    this._innerCommentsState = 0;
+    this._flags = 0;
     this.tokenMap = null;
-    this._boundGetRawIdentifier = this._getRawIdentifier.bind(this);
+    this._boundGetRawIdentifier = null;
     this._printSemicolonBeforeNextNode = -1;
     this._printSemicolonBeforeNextToken = -1;
     this.format = format;
@@ -58,67 +52,66 @@ class Printer {
     this._indentRepeat = format.indent.style.length;
     this._inputMap = (map == null ? void 0 : map._inputMap) || null;
     this._buf = new _buffer.default(map, format.indent.style[0]);
-  }
-  enterForStatementInit() {
-    this.tokenContext |= _index.TokenContext.forInitHead | _index.TokenContext.forInOrInitHeadAccumulate;
-    return () => this.tokenContext = _index.TokenContext.normal;
-  }
-  enterForXStatementInit(isForOf) {
-    if (isForOf) {
-      this.tokenContext |= _index.TokenContext.forOfHead;
-      return null;
-    } else {
-      this.tokenContext |= _index.TokenContext.forInHead | _index.TokenContext.forInOrInitHeadAccumulate;
-      return () => this.tokenContext = _index.TokenContext.normal;
+    const {
+      preserveFormat,
+      compact,
+      concise,
+      retainLines,
+      retainFunctionParens
+    } = format;
+    if (preserveFormat) {
+      this._flags |= 1;
+    }
+    if (compact) {
+      this._flags |= 2;
+    }
+    if (concise) {
+      this._flags |= 4;
+    }
+    if (retainLines) {
+      this._flags |= 8;
+    }
+    if (retainFunctionParens) {
+      this._flags |= 16;
+    }
+    if (format.auxiliaryCommentBefore || format.auxiliaryCommentAfter) {
+      this._flags |= 32;
     }
   }
   enterDelimited() {
-    const oldTokenContext = this.tokenContext;
     const oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
-    if (!(oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) && oldNoLineTerminatorAfterNode === null) {
-      return () => {};
+    if (oldNoLineTerminatorAfterNode !== null) {
+      this._noLineTerminatorAfterNode = null;
     }
-    this._noLineTerminatorAfterNode = null;
-    this.tokenContext = _index.TokenContext.normal;
-    return () => {
-      this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
-      this.tokenContext = oldTokenContext;
-    };
+    return oldNoLineTerminatorAfterNode;
   }
   generate(ast) {
     if (this.format.preserveFormat) {
       this.tokenMap = new _tokenMap.TokenMap(ast, this._tokens, this._originalCode);
+      this._boundGetRawIdentifier = _types2._getRawIdentifier.bind(this);
     }
     this.print(ast);
     this._maybeAddAuxComment();
     return this._buf.get();
   }
-  indent() {
-    const {
-      format
-    } = this;
-    if (format.preserveFormat || format.compact || format.concise) {
+  indent(flags = this._flags) {
+    if (flags & (1 | 2 | 4)) {
       return;
     }
-    this._indent++;
+    this._indent += this._indentRepeat;
   }
-  dedent() {
-    const {
-      format
-    } = this;
-    if (format.preserveFormat || format.compact || format.concise) {
+  dedent(flags = this._flags) {
+    if (flags & (1 | 2 | 4)) {
       return;
     }
-    this._indent--;
+    this._indent -= this._indentRepeat;
   }
   semicolon(force = false) {
-    this._maybeAddAuxComment();
-    if (force) {
-      this._appendChar(59);
-      this._noLineTerminator = false;
-      return;
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
     }
-    if (this.tokenMap) {
+    if (flags & 1) {
       const node = this._currentNode;
       if (node.start != null && node.end != null) {
         if (!this.tokenMap.endMatches(node, ";")) {
@@ -129,7 +122,11 @@ class Printer {
         this._catchUpTo(this._tokens[indexes[indexes.length - 1]].loc.start);
       }
     }
-    this._queue(59);
+    if (force) {
+      this._appendChar(59);
+    } else {
+      this._queue(59);
+    }
     this._noLineTerminator = false;
   }
   rightBrace(node) {
@@ -144,15 +141,14 @@ class Printer {
     this.tokenChar(41);
   }
   space(force = false) {
-    const {
-      format
-    } = this;
-    if (format.compact || format.preserveFormat) return;
+    if (this._flags & (1 | 2)) {
+      return;
+    }
     if (force) {
       this._space();
-    } else if (this._buf.hasContent()) {
-      const lastCp = this.getLastChar();
-      if (lastCp !== 32 && lastCp !== 10) {
+    } else {
+      const lastCp = this.getLastChar(true);
+      if (lastCp !== 0 && lastCp !== 32 && lastCp !== 10) {
         this._space();
       }
     }
@@ -160,13 +156,17 @@ class Printer {
   word(str, noLineTerminatorAfter = false) {
     this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
     this._maybePrintInnerComments(str);
-    this._maybeAddAuxComment();
-    if (this.tokenMap) this._catchUpToCurrentToken(str);
-    if (this._endsWithWord || this._endsWithDiv && str.charCodeAt(0) === 47) {
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) this._catchUpToCurrentToken(str);
+    const lastChar = this.getLastChar();
+    if (lastChar === -2 || lastChar === -3 || lastChar === 47 && str.charCodeAt(0) === 47) {
       this._space();
     }
     this._append(str, false);
-    this._endsWithWord = true;
+    this.setLastChar(-3);
     this._noLineTerminator = noLineTerminatorAfter;
   }
   number(str, number) {
@@ -178,61 +178,68 @@ class Printer {
       return false;
     }
     this.word(str);
-    this._endsWithInteger = Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
+    if (Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46) {
+      this.setLastChar(-2);
+    }
   }
-  token(str, maybeNewline = false, occurrenceCount = 0) {
+  token(str, maybeNewline = false, occurrenceCount = 0, mayNeedSpace = false) {
     this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
     this._maybePrintInnerComments(str, occurrenceCount);
-    this._maybeAddAuxComment();
-    if (this.tokenMap) this._catchUpToCurrentToken(str, occurrenceCount);
-    const lastChar = this.getLastChar();
-    const strFirst = str.charCodeAt(0);
-    if (lastChar === 33 && (str === "--" || strFirst === 61) || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) {
-      this._space();
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) {
+      this._catchUpToCurrentToken(str, occurrenceCount);
+    }
+    if (mayNeedSpace) {
+      const strFirst = str.charCodeAt(0);
+      if ((strFirst === 45 && str === "--" || strFirst === 61) && this.getLastChar() === 33 || strFirst === 43 && this.getLastChar() === 43 || strFirst === 45 && this.getLastChar() === 45 || strFirst === 46 && this.getLastChar() === -2) {
+        this._space();
+      }
     }
     this._append(str, maybeNewline);
     this._noLineTerminator = false;
   }
-  tokenChar(char) {
+  tokenChar(char, occurrenceCount = 0) {
     this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
-    const str = String.fromCharCode(char);
-    this._maybePrintInnerComments(str);
-    this._maybeAddAuxComment();
-    if (this.tokenMap) this._catchUpToCurrentToken(str);
-    const lastChar = this.getLastChar();
-    if (char === 43 && lastChar === 43 || char === 45 && lastChar === 45 || char === 46 && this._endsWithInteger) {
+    this._maybePrintInnerComments(char, occurrenceCount);
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) {
+      this._catchUpToCurrentToken(char, occurrenceCount);
+    }
+    if (char === 43 && this.getLastChar() === 43 || char === 45 && this.getLastChar() === 45 || char === 46 && this.getLastChar() === -2) {
       this._space();
     }
     this._appendChar(char);
     this._noLineTerminator = false;
   }
-  newline(i = 1, force) {
+  newline(i = 1, flags = this._flags) {
     if (i <= 0) return;
-    if (!force) {
-      if (this.format.retainLines || this.format.compact) return;
-      if (this.format.concise) {
-        this.space();
-        return;
-      }
+    if (flags & (8 | 2)) {
+      return;
+    }
+    if (flags & 4) {
+      this.space();
+      return;
     }
     if (i > 2) i = 2;
     i -= this._buf.getNewlineCount();
     for (let j = 0; j < i; j++) {
       this._newline();
     }
-    return;
   }
   endsWith(char) {
-    return this.getLastChar() === char;
-  }
-  getLastChar() {
-    return this._buf.getLastChar();
+    return this.getLastChar(true) === char;
   }
-  endsWithCharAndNewline() {
-    return this._buf.endsWithCharAndNewline();
+  getLastChar(checkQueue) {
+    return this._buf.getLastChar(checkQueue);
   }
-  removeTrailingNewline() {
-    this._buf.removeTrailingNewline();
+  setLastChar(char) {
+    this._buf._last = char;
   }
   exactSource(loc, cb) {
     if (!loc) {
@@ -262,49 +269,40 @@ class Printer {
     this._queue(32);
   }
   _newline() {
-    this._queue(10);
+    if (this._buf._queuedChar === 32) this._buf._queuedChar = 0;
+    this._appendChar(10, true);
   }
   _catchUpToCurrentToken(str, occurrenceCount = 0) {
     const token = this.tokenMap.findMatching(this._currentNode, str, occurrenceCount);
     if (token) this._catchUpTo(token.loc.start);
     if (this._printSemicolonBeforeNextToken !== -1 && this._printSemicolonBeforeNextToken === this._buf.getCurrentLine()) {
-      this._buf.appendChar(59);
-      this._endsWithWord = false;
-      this._endsWithInteger = false;
-      this._endsWithDiv = false;
+      this._appendChar(59, true);
     }
     this._printSemicolonBeforeNextToken = -1;
     this._printSemicolonBeforeNextNode = -1;
   }
   _append(str, maybeNewline) {
-    this._maybeIndent(str.charCodeAt(0));
+    this._maybeIndent();
     this._buf.append(str, maybeNewline);
-    this._endsWithWord = false;
-    this._endsWithInteger = false;
-    this._endsWithDiv = false;
   }
-  _appendChar(char) {
-    this._maybeIndent(char);
+  _appendChar(char, noIndent) {
+    if (!noIndent) {
+      this._maybeIndent();
+    }
     this._buf.appendChar(char);
-    this._endsWithWord = false;
-    this._endsWithInteger = false;
-    this._endsWithDiv = false;
   }
   _queue(char) {
-    this._maybeIndent(char);
     this._buf.queue(char);
-    this._endsWithWord = false;
-    this._endsWithInteger = false;
+    this.setLastChar(-1);
   }
-  _maybeIndent(firstChar) {
-    if (this._indent && firstChar !== 10 && this.endsWith(10)) {
-      this._buf.queueIndentation(this._getIndent());
+  _maybeIndent() {
+    const indent = this._shouldIndent();
+    if (indent > 0) {
+      this._buf._appendChar(-1, indent, false);
     }
   }
-  _shouldIndent(firstChar) {
-    if (this._indent && firstChar !== 10 && this.endsWith(10)) {
-      return true;
-    }
+  _shouldIndent() {
+    return this.endsWith(10) ? this._indent : 0;
   }
   catchUp(line) {
     if (!this.format.retainLines) return;
@@ -314,11 +312,9 @@ class Printer {
     }
   }
   _catchUp(prop, loc) {
-    const {
-      format
-    } = this;
-    if (!format.preserveFormat) {
-      if (format.retainLines && loc != null && loc[prop]) {
+    const flags = this._flags;
+    if ((flags & 1) === 0) {
+      if (flags & 8 && loc != null && loc[prop]) {
         this.catchUp(loc[prop].line);
       }
       return;
@@ -342,64 +338,80 @@ class Printer {
     if (spacesCount > 0) {
       const spaces = this._originalCode ? this._originalCode.slice(index - spacesCount, index).replace(/[^\t\x0B\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]/gu, " ") : " ".repeat(spacesCount);
       this._append(spaces, false);
+      this.setLastChar(32);
     }
   }
-  _getIndent() {
-    return this._indentRepeat * this._indent;
-  }
   printTerminatorless(node) {
     this._noLineTerminator = true;
     this.print(node);
   }
-  print(node, noLineTerminatorAfter = false, trailingCommentsLineOffset) {
-    var _node$extra, _node$leadingComments, _node$leadingComments2;
+  print(node, noLineTerminatorAfter = false, resetTokenContext = false, trailingCommentsLineOffset) {
+    var _node$leadingComments, _node$leadingComments2;
     if (!node) return;
-    this._endsWithInnerRaw = false;
-    const nodeType = node.type;
-    const format = this.format;
-    const oldConcise = format.concise;
+    this._innerCommentsState = 0;
+    const {
+      type,
+      loc,
+      extra
+    } = node;
+    const flags = this._flags;
+    let changedFlags = false;
     if (node._compact) {
-      format.concise = true;
+      this._flags |= 4;
+      changedFlags = true;
     }
-    const printMethod = this[nodeType];
-    if (printMethod === undefined) {
-      throw new ReferenceError(`unknown node of type ${JSON.stringify(nodeType)} with constructor ${JSON.stringify(node.constructor.name)}`);
+    const nodeInfo = _nodes.generatorInfosMap.get(type);
+    if (nodeInfo === undefined) {
+      throw new ReferenceError(`unknown node of type ${JSON.stringify(type)} with constructor ${JSON.stringify(node.constructor.name)}`);
     }
+    const [printMethod, nodeId, needsParens] = nodeInfo;
     const parent = this._currentNode;
+    const parentId = this._currentTypeId;
     this._currentNode = node;
-    if (this.tokenMap) {
+    this._currentTypeId = nodeId;
+    if (flags & 1) {
       this._printSemicolonBeforeNextToken = this._printSemicolonBeforeNextNode;
     }
-    const oldInAux = this._insideAux;
-    this._insideAux = node.loc == null;
-    this._maybeAddAuxComment(this._insideAux && !oldInAux);
-    const parenthesized = (_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized;
-    let shouldPrintParens = parenthesized && format.preserveFormat || parenthesized && format.retainFunctionParens && nodeType === "FunctionExpression" || needsParens(node, parent, this.tokenContext, format.preserveFormat ? this._boundGetRawIdentifier : undefined);
+    let oldInAux;
+    if (flags & 32) {
+      oldInAux = this._insideAux;
+      this._insideAux = loc == null;
+      this._maybeAddAuxComment(this._insideAux && !oldInAux);
+    }
+    let oldTokenContext = 0;
+    if (resetTokenContext) {
+      oldTokenContext = this.tokenContext;
+      if (oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+        this.tokenContext = 0;
+      } else {
+        oldTokenContext = 0;
+      }
+    }
+    const parenthesized = extra != null && extra.parenthesized;
+    let shouldPrintParens = parenthesized && flags & 1 || parenthesized && flags & 16 && nodeId === 71 || parent && ((0, _index.parentNeedsParens)(node, parent, parentId) || needsParens != null && needsParens(node, parent, parentId, this.tokenContext, flags & 1 ? this._boundGetRawIdentifier : undefined));
     if (!shouldPrintParens && parenthesized && (_node$leadingComments = node.leadingComments) != null && _node$leadingComments.length && node.leadingComments[0].type === "CommentBlock") {
-      const parentType = parent == null ? void 0 : parent.type;
-      switch (parentType) {
-        case "ExpressionStatement":
-        case "VariableDeclarator":
-        case "AssignmentExpression":
-        case "ReturnStatement":
+      switch (parentId) {
+        case 65:
+        case 243:
+        case 6:
+        case 143:
           break;
-        case "CallExpression":
-        case "OptionalCallExpression":
-        case "NewExpression":
+        case 17:
+        case 130:
+        case 112:
           if (parent.callee !== node) break;
         default:
           shouldPrintParens = true;
       }
     }
     let indentParenthesized = false;
-    if (!shouldPrintParens && this._noLineTerminator && ((_node$leadingComments2 = node.leadingComments) != null && _node$leadingComments2.some(commentIsNewline) || this.format.retainLines && node.loc && node.loc.start.line > this._buf.getCurrentLine())) {
+    if (!shouldPrintParens && this._noLineTerminator && ((_node$leadingComments2 = node.leadingComments) != null && _node$leadingComments2.some(commentIsNewline) || flags & 8 && loc && loc.start.line > this._buf.getCurrentLine())) {
       shouldPrintParens = true;
       indentParenthesized = true;
     }
     let oldNoLineTerminatorAfterNode;
-    let oldTokenContext;
     if (!shouldPrintParens) {
-      noLineTerminatorAfter || (noLineTerminatorAfter = !!parent && this._noLineTerminatorAfterNode === parent && n.isLastChild(parent, node));
+      noLineTerminatorAfter || (noLineTerminatorAfter = !!parent && this._noLineTerminatorAfterNode === parent && (0, _index.isLastChild)(parent, node));
       if (noLineTerminatorAfter) {
         var _node$trailingComment;
         if ((_node$trailingComment = node.trailingComments) != null && _node$trailingComment.some(commentIsNewline)) {
@@ -413,18 +425,18 @@ class Printer {
     if (shouldPrintParens) {
       this.tokenChar(40);
       if (indentParenthesized) this.indent();
-      this._endsWithInnerRaw = false;
-      if (this.tokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+      this._innerCommentsState = 0;
+      if (!resetTokenContext) {
         oldTokenContext = this.tokenContext;
-        this.tokenContext = _index.TokenContext.normal;
+      }
+      if (oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+        this.tokenContext = 0;
       }
       oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
       this._noLineTerminatorAfterNode = null;
     }
-    this._lastCommentLine = 0;
     this._printLeadingComments(node, parent);
-    const loc = nodeType === "Program" || nodeType === "File" ? null : node.loc;
-    this.exactSource(loc, printMethod.bind(this, node, parent));
+    this.exactSource(nodeId === 139 || nodeId === 66 ? null : loc, printMethod.bind(this, node, parent));
     if (shouldPrintParens) {
       this._printTrailingComments(node, parent);
       if (indentParenthesized) {
@@ -433,20 +445,25 @@ class Printer {
       }
       this.tokenChar(41);
       this._noLineTerminator = noLineTerminatorAfter;
-      if (oldTokenContext) this.tokenContext = oldTokenContext;
     } else if (noLineTerminatorAfter && !this._noLineTerminator) {
       this._noLineTerminator = true;
       this._printTrailingComments(node, parent);
     } else {
       this._printTrailingComments(node, parent, trailingCommentsLineOffset);
     }
+    if (oldTokenContext) this.tokenContext = oldTokenContext;
     this._currentNode = parent;
-    format.concise = oldConcise;
-    this._insideAux = oldInAux;
-    if (oldNoLineTerminatorAfterNode !== undefined) {
+    this._currentTypeId = parentId;
+    if (changedFlags) {
+      this._flags = flags;
+    }
+    if (flags & 32) {
+      this._insideAux = oldInAux;
+    }
+    if (oldNoLineTerminatorAfterNode != null) {
       this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
     }
-    this._endsWithInnerRaw = false;
+    this._innerCommentsState = 0;
   }
   _maybeAddAuxComment(enteredPositionlessNode) {
     if (enteredPositionlessNode) this._printAuxBeforeComment();
@@ -480,46 +497,46 @@ class Printer {
       return extra.raw;
     }
   }
-  printJoin(nodes, statement, indent, separator, printTrailingSeparator, iterator, trailingCommentsLineOffset) {
+  printJoin(nodes, statement, indent, separator, printTrailingSeparator, resetTokenContext, trailingCommentsLineOffset) {
     if (!(nodes != null && nodes.length)) return;
-    if (indent == null && this.format.retainLines) {
+    const flags = this._flags;
+    if (indent == null && flags & 8) {
       var _nodes$0$loc;
       const startLine = (_nodes$0$loc = nodes[0].loc) == null ? void 0 : _nodes$0$loc.start.line;
       if (startLine != null && startLine !== this._buf.getCurrentLine()) {
         indent = true;
       }
     }
-    if (indent) this.indent();
-    const newlineOpts = {
-      nextNodeStartLine: 0
-    };
-    const boundSeparator = separator == null ? void 0 : separator.bind(this);
+    if (indent) this.indent(flags);
     const len = nodes.length;
     for (let i = 0; i < len; i++) {
       const node = nodes[i];
       if (!node) continue;
-      if (statement) this._printNewline(i === 0, newlineOpts);
-      this.print(node, undefined, trailingCommentsLineOffset || 0);
-      iterator == null || iterator(node, i);
-      if (boundSeparator != null) {
-        if (i < len - 1) boundSeparator(i, false);else if (printTrailingSeparator) boundSeparator(i, true);
+      if (statement && i === 0 && this._buf.hasContent()) {
+        this.newline(1, flags);
+      }
+      this.print(node, false, resetTokenContext, trailingCommentsLineOffset || 0);
+      if (separator != null) {
+        if (i < len - 1) separator.call(this, i, false);else if (printTrailingSeparator) separator.call(this, i, true);
       }
       if (statement) {
-        var _node$trailingComment2;
-        if (!((_node$trailingComment2 = node.trailingComments) != null && _node$trailingComment2.length)) {
-          this._lastCommentLine = 0;
-        }
         if (i + 1 === len) {
-          this.newline(1);
+          this.newline(1, flags);
         } else {
-          var _nextNode$loc;
-          const nextNode = nodes[i + 1];
-          newlineOpts.nextNodeStartLine = ((_nextNode$loc = nextNode.loc) == null ? void 0 : _nextNode$loc.start.line) || 0;
-          this._printNewline(true, newlineOpts);
+          const lastCommentLine = this._lastCommentLine;
+          if (lastCommentLine > 0) {
+            var _nodes$loc;
+            const offset = (((_nodes$loc = nodes[i + 1].loc) == null ? void 0 : _nodes$loc.start.line) || 0) - lastCommentLine;
+            if (offset >= 0) {
+              this.newline(offset || 1, flags);
+              continue;
+            }
+          }
+          this.newline(1, flags);
         }
       }
     }
-    if (indent) this.dedent();
+    if (indent) this.dedent(flags);
   }
   printAndIndentOnComments(node) {
     const indent = node.leadingComments && node.leadingComments.length > 0;
@@ -527,12 +544,11 @@ class Printer {
     this.print(node);
     if (indent) this.dedent();
   }
-  printBlock(parent) {
-    const node = parent.body;
-    if (node.type !== "EmptyStatement") {
+  printBlock(body) {
+    if (body.type !== "EmptyStatement") {
       this.space();
     }
-    this.print(node);
+    this.print(body);
   }
   _printTrailingComments(node, parent, lineOffset) {
     const {
@@ -544,6 +560,8 @@ class Printer {
     }
     if (trailingComments != null && trailingComments.length) {
       this._printComments(2, trailingComments, node, parent, lineOffset);
+    } else {
+      this._lastCommentLine = 0;
     }
   }
   _printLeadingComments(node, parent) {
@@ -552,65 +570,48 @@ class Printer {
     this._printComments(0, comments, node, parent);
   }
   _maybePrintInnerComments(nextTokenStr, nextTokenOccurrenceCount) {
-    if (this._endsWithInnerRaw) {
-      var _this$tokenMap;
-      this.printInnerComments((_this$tokenMap = this.tokenMap) == null ? void 0 : _this$tokenMap.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount));
+    var _this$tokenMap;
+    const state = this._innerCommentsState;
+    switch (state & 3) {
+      case 0:
+        this._innerCommentsState = 1 | 4;
+        return;
+      case 1:
+        this.printInnerComments((state & 4) > 0, (_this$tokenMap = this.tokenMap) == null ? void 0 : _this$tokenMap.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount));
     }
-    this._endsWithInnerRaw = true;
-    this._indentInnerComments = true;
   }
-  printInnerComments(nextToken) {
+  printInnerComments(indent = true, nextToken) {
     const node = this._currentNode;
     const comments = node.innerComments;
-    if (!(comments != null && comments.length)) return;
+    if (!(comments != null && comments.length)) {
+      this._innerCommentsState = 2;
+      return;
+    }
     const hasSpace = this.endsWith(32);
-    const indent = this._indentInnerComments;
-    const printedCommentsCount = this._printedComments.size;
     if (indent) this.indent();
-    this._printComments(1, comments, node, undefined, undefined, nextToken);
-    if (hasSpace && printedCommentsCount !== this._printedComments.size) {
-      this.space();
+    switch (this._printComments(1, comments, node, undefined, undefined, nextToken)) {
+      case 2:
+        this._innerCommentsState = 2;
+      case 1:
+        if (hasSpace) this.space();
     }
     if (indent) this.dedent();
   }
   noIndentInnerCommentsHere() {
-    this._indentInnerComments = false;
+    this._innerCommentsState &= ~4;
   }
-  printSequence(nodes, indent, trailingCommentsLineOffset) {
-    this.printJoin(nodes, true, indent != null ? indent : false, undefined, undefined, undefined, trailingCommentsLineOffset);
+  printSequence(nodes, indent, resetTokenContext, trailingCommentsLineOffset) {
+    this.printJoin(nodes, true, indent != null ? indent : false, undefined, undefined, resetTokenContext, trailingCommentsLineOffset);
   }
-  printList(items, printTrailingSeparator, statement, indent, separator, iterator) {
-    this.printJoin(items, statement, indent, separator != null ? separator : commaSeparator, printTrailingSeparator, iterator);
+  printList(items, printTrailingSeparator, statement, indent, separator, resetTokenContext) {
+    this.printJoin(items, statement, indent, separator != null ? separator : commaSeparator, printTrailingSeparator, resetTokenContext);
   }
   shouldPrintTrailingComma(listEnd) {
     if (!this.tokenMap) return null;
-    const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, token => this.tokenMap.matchesOriginal(token, listEnd));
+    const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, token => this.tokenMap.matchesOriginal(token, typeof listEnd === "number" ? String.fromCharCode(listEnd) : listEnd));
     if (listEndIndex <= 0) return null;
     return this.tokenMap.matchesOriginal(this._tokens[listEndIndex - 1], ",");
   }
-  _printNewline(newLine, opts) {
-    const format = this.format;
-    if (format.retainLines || format.compact) return;
-    if (format.concise) {
-      this.space();
-      return;
-    }
-    if (!newLine) {
-      return;
-    }
-    const startLine = opts.nextNodeStartLine;
-    const lastCommentLine = this._lastCommentLine;
-    if (startLine > 0 && lastCommentLine > 0) {
-      const offset = startLine - lastCommentLine;
-      if (offset >= 0) {
-        this.newline(offset || 1);
-        return;
-      }
-    }
-    if (this._buf.hasContent()) {
-      this.newline(1);
-    }
-  }
   _shouldPrintComment(comment, nextToken) {
     if (comment.ignore) return 0;
     if (this._printedComments.has(comment)) return 0;
@@ -632,13 +633,19 @@ class Printer {
   _printComment(comment, skipNewLines) {
     const noLineTerminator = this._noLineTerminator;
     const isBlockComment = comment.type === "CommentBlock";
-    const printNewLines = isBlockComment && skipNewLines !== 1 && !this._noLineTerminator;
+    const printNewLines = isBlockComment && skipNewLines !== 1 && !noLineTerminator;
     if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) {
       this.newline(1);
     }
-    const lastCharCode = this.getLastChar();
-    if (lastCharCode !== 91 && lastCharCode !== 123 && lastCharCode !== 40) {
-      this.space();
+    switch (this.getLastChar(true)) {
+      case 47:
+        this._space();
+      case 91:
+      case 123:
+      case 40:
+        break;
+      default:
+        this.space();
     }
     let val;
     if (isBlockComment) {
@@ -650,12 +657,12 @@ class Printer {
           const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
           val = val.replace(newlineRegex, "\n");
         }
-        if (this.format.concise) {
+        if (this._flags & 4) {
           val = val.replace(/\n(?!$)/g, `\n`);
         } else {
           let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
-          if (this._shouldIndent(47) || this.format.retainLines) {
-            indentSize += this._getIndent();
+          if (this._shouldIndent() || this.format.retainLines) {
+            indentSize += this._indent;
           }
           val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`);
         }
@@ -665,24 +672,10 @@ class Printer {
     } else {
       val = `/*${comment.value}*/`;
     }
-    if (this._endsWithDiv) this._space();
-    if (this.tokenMap) {
-      const {
-        _printSemicolonBeforeNextToken,
-        _printSemicolonBeforeNextNode
-      } = this;
-      this._printSemicolonBeforeNextToken = -1;
-      this._printSemicolonBeforeNextNode = -1;
-      this.source("start", comment.loc);
-      this._append(val, isBlockComment);
-      this._printSemicolonBeforeNextNode = _printSemicolonBeforeNextNode;
-      this._printSemicolonBeforeNextToken = _printSemicolonBeforeNextToken;
-    } else {
-      this.source("start", comment.loc);
-      this._append(val, isBlockComment);
-    }
+    this.source("start", comment.loc);
+    this._append(val, isBlockComment);
     if (!isBlockComment && !noLineTerminator) {
-      this.newline(1, true);
+      this._newline();
     }
     if (printNewLines && skipNewLines !== 3) {
       this.newline(1);
@@ -696,13 +689,15 @@ class Printer {
     const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
     let lastLine = 0;
     let leadingCommentNewline = 0;
-    const maybeNewline = this._noLineTerminator ? function () {} : this.newline.bind(this);
+    const {
+      _noLineTerminator,
+      _flags
+    } = this;
     for (let i = 0; i < len; i++) {
       const comment = comments[i];
       const shouldPrint = this._shouldPrintComment(comment, nextToken);
       if (shouldPrint === 2) {
-        hasLoc = false;
-        break;
+        return i === 0 ? 0 : 1;
       }
       if (hasLoc && comment.loc && shouldPrint === 1) {
         const commentStartLine = comment.loc.start.line;
@@ -717,25 +712,37 @@ class Printer {
             offset = commentStartLine - lastLine;
           }
           lastLine = commentEndLine;
-          maybeNewline(offset);
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
           this._printComment(comment, 1);
           if (i + 1 === len) {
-            maybeNewline(Math.max(nodeStartLine - lastLine, leadingCommentNewline));
+            const count = Math.max(nodeStartLine - lastLine, leadingCommentNewline);
+            if (count > 0 && !_noLineTerminator) {
+              this.newline(count, _flags);
+            }
             lastLine = nodeStartLine;
           }
         } else if (type === 1) {
           const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine);
           lastLine = commentEndLine;
-          maybeNewline(offset);
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
           this._printComment(comment, 1);
           if (i + 1 === len) {
-            maybeNewline(Math.min(1, nodeEndLine - lastLine));
+            const count = Math.min(1, nodeEndLine - lastLine);
+            if (count > 0 && !_noLineTerminator) {
+              this.newline(count, _flags);
+            }
             lastLine = nodeEndLine;
           }
         } else {
           const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
           lastLine = commentEndLine;
-          maybeNewline(offset);
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
           this._printComment(comment, 1);
         }
       } else {
@@ -747,9 +754,7 @@ class Printer {
           const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
           const shouldSkipNewline = singleLine && !isStatement(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumMember(node);
           if (type === 0) {
-            this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent, {
-              body: node
-            }) ? 1 : 0);
+            this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent) && parent.body === node ? 1 : 0);
           } else if (shouldSkipNewline && type === 2) {
             this._printComment(comment, 1);
           } else {
@@ -765,15 +770,12 @@ class Printer {
     if (type === 2 && hasLoc && lastLine) {
       this._lastCommentLine = lastLine;
     }
+    return 2;
   }
 }
-Object.assign(Printer.prototype, generatorFunctions);
-{
-  (0, _deprecated.addDeprecatedGenerators)(Printer);
-}
 var _default = exports.default = Printer;
 function commaSeparator(occurrenceCount, last) {
-  this.token(",", false, occurrenceCount);
+  this.tokenChar(44, occurrenceCount);
   if (!last) this.space();
 }