“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.WithStatement = WithStatement; exports.IfStatement = IfStatement; exports.ForStatement = ForStatement; exports.WhileStatement = WhileStatement; exports.DoWhileStatement = DoWhileStatement; exports.LabeledStatement = LabeledStatement; exports.TryStatement = TryStatement; exports.CatchClause = CatchClause; exports.SwitchStatement = SwitchStatement; exports.SwitchCase = SwitchCase; exports.DebuggerStatement = DebuggerStatement; exports.VariableDeclaration = VariableDeclaration; exports.VariableDeclarator = VariableDeclarator; exports.ThrowStatement = exports.BreakStatement = exports.ReturnStatement = exports.ContinueStatement = exports.ForOfStatement = exports.ForInStatement = void 0;

var t = _interopRequireWildcard(require(“@babel/types”));

function _getRequireWildcardCache() { if (typeof WeakMap !== “function”) return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function WithStatement(node) {

this.word("with");
this.space();
this.token("(");
this.print(node.object, node);
this.token(")");
this.printBlock(node);

}

function IfStatement(node) {

this.word("if");
this.space();
this.token("(");
this.print(node.test, node);
this.token(")");
this.space();
const needsBlock = node.alternate && t.isIfStatement(getLastStatement(node.consequent));

if (needsBlock) {
  this.token("{");
  this.newline();
  this.indent();
}

this.printAndIndentOnComments(node.consequent, node);

if (needsBlock) {
  this.dedent();
  this.newline();
  this.token("}");
}

if (node.alternate) {
  if (this.endsWith("}")) this.space();
  this.word("else");
  this.space();
  this.printAndIndentOnComments(node.alternate, node);
}

}

function getLastStatement(statement) {

if (!t.isStatement(statement.body)) return statement;
return getLastStatement(statement.body);

}

function ForStatement(node) {

this.word("for");
this.space();
this.token("(");
this.inForStatementInitCounter++;
this.print(node.init, node);
this.inForStatementInitCounter--;
this.token(";");

if (node.test) {
  this.space();
  this.print(node.test, node);
}

this.token(";");

if (node.update) {
  this.space();
  this.print(node.update, node);
}

this.token(")");
this.printBlock(node);

}

function WhileStatement(node) {

this.word("while");
this.space();
this.token("(");
this.print(node.test, node);
this.token(")");
this.printBlock(node);

}

const buildForXStatement = function (op) {

return function (node) {
  this.word("for");
  this.space();

  if (op === "of" && node.await) {
    this.word("await");
    this.space();
  }

  this.token("(");
  this.print(node.left, node);
  this.space();
  this.word(op);
  this.space();
  this.print(node.right, node);
  this.token(")");
  this.printBlock(node);
};

};

const ForInStatement = buildForXStatement(“in”); exports.ForInStatement = ForInStatement; const ForOfStatement = buildForXStatement(“of”); exports.ForOfStatement = ForOfStatement;

function DoWhileStatement(node) {

this.word("do");
this.space();
this.print(node.body, node);
this.space();
this.word("while");
this.space();
this.token("(");
this.print(node.test, node);
this.token(")");
this.semicolon();

}

function buildLabelStatement(prefix, key = “label”) {

return function (node) {
  this.word(prefix);
  const label = node[key];

  if (label) {
    this.space();
    const isLabel = key == "label";
    const terminatorState = this.startTerminatorless(isLabel);
    this.print(label, node);
    this.endTerminatorless(terminatorState);
  }

  this.semicolon();
};

}

const ContinueStatement = buildLabelStatement(“continue”); exports.ContinueStatement = ContinueStatement; const ReturnStatement = buildLabelStatement(“return”, “argument”); exports.ReturnStatement = ReturnStatement; const BreakStatement = buildLabelStatement(“break”); exports.BreakStatement = BreakStatement; const ThrowStatement = buildLabelStatement(“throw”, “argument”); exports.ThrowStatement = ThrowStatement;

function LabeledStatement(node) {

this.print(node.label, node);
this.token(":");
this.space();
this.print(node.body, node);

}

function TryStatement(node) {

this.word("try");
this.space();
this.print(node.block, node);
this.space();

if (node.handlers) {
  this.print(node.handlers[0], node);
} else {
  this.print(node.handler, node);
}

if (node.finalizer) {
  this.space();
  this.word("finally");
  this.space();
  this.print(node.finalizer, node);
}

}

function CatchClause(node) {

this.word("catch");
this.space();

if (node.param) {
  this.token("(");
  this.print(node.param, node);
  this.token(")");
  this.space();
}

this.print(node.body, node);

}

function SwitchStatement(node) {

this.word("switch");
this.space();
this.token("(");
this.print(node.discriminant, node);
this.token(")");
this.space();
this.token("{");
this.printSequence(node.cases, node, {
  indent: true,

  addNewlines(leading, cas) {
    if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
  }

});
this.token("}");

}

function SwitchCase(node) {

if (node.test) {
  this.word("case");
  this.space();
  this.print(node.test, node);
  this.token(":");
} else {
  this.word("default");
  this.token(":");
}

if (node.consequent.length) {
  this.newline();
  this.printSequence(node.consequent, node, {
    indent: true
  });
}

}

function DebuggerStatement() {

this.word("debugger");
this.semicolon();

}

function variableDeclarationIndent() {

this.token(",");
this.newline();
if (this.endsWith("\n")) for (let i = 0; i < 4; i++) this.space(true);

}

function constDeclarationIndent() {

this.token(",");
this.newline();
if (this.endsWith("\n")) for (let i = 0; i < 6; i++) this.space(true);

}

function VariableDeclaration(node, parent) {

if (node.declare) {
  this.word("declare");
  this.space();
}

this.word(node.kind);
this.space();
let hasInits = false;

if (!t.isFor(parent)) {
  for (const declar of node.declarations) {
    if (declar.init) {
      hasInits = true;
    }
  }
}

let separator;

if (hasInits) {
  separator = node.kind === "const" ? constDeclarationIndent : variableDeclarationIndent;
}

this.printList(node.declarations, node, {
  separator
});

if (t.isFor(parent)) {
  if (parent.left === node || parent.init === node) return;
}

this.semicolon();

}

function VariableDeclarator(node) {

this.print(node.id, node);
if (node.definite) this.token("!");
this.print(node.id.typeAnnotation, node);

if (node.init) {
  this.space();
  this.token("=");
  this.space();
  this.print(node.init, node);
}

}