“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.UnaryExpression = UnaryExpression; exports.DoExpression = DoExpression; exports.ParenthesizedExpression = ParenthesizedExpression; exports.UpdateExpression = UpdateExpression; exports.ConditionalExpression = ConditionalExpression; exports.NewExpression = NewExpression; exports.SequenceExpression = SequenceExpression; exports.ThisExpression = ThisExpression; exports.Super = Super; exports.Decorator = Decorator; exports.OptionalMemberExpression = OptionalMemberExpression; exports.OptionalCallExpression = OptionalCallExpression; exports.CallExpression = CallExpression; exports.Import = Import; exports.EmptyStatement = EmptyStatement; exports.ExpressionStatement = ExpressionStatement; exports.AssignmentPattern = AssignmentPattern; exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression; exports.BindExpression = BindExpression; exports.MemberExpression = MemberExpression; exports.MetaProperty = MetaProperty; exports.PrivateName = PrivateName; exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier; exports.AwaitExpression = exports.YieldExpression = void 0;

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

var n = _interopRequireWildcard(require(“../node”));

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 UnaryExpression(node) {

if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof" || node.operator === "throw") {
  this.word(node.operator);
  this.space();
} else {
  this.token(node.operator);
}

this.print(node.argument, node);

}

function DoExpression(node) {

this.word("do");
this.space();
this.print(node.body, node);

}

function ParenthesizedExpression(node) {

this.token("(");
this.print(node.expression, node);
this.token(")");

}

function UpdateExpression(node) {

if (node.prefix) {
  this.token(node.operator);
  this.print(node.argument, node);
} else {
  this.startTerminatorless(true);
  this.print(node.argument, node);
  this.endTerminatorless();
  this.token(node.operator);
}

}

function ConditionalExpression(node) {

this.print(node.test, node);
this.space();
this.token("?");
this.space();
this.print(node.consequent, node);
this.space();
this.token(":");
this.space();
this.print(node.alternate, node);

}

function NewExpression(node, parent) {

this.word("new");
this.space();
this.print(node.callee, node);

if (this.format.minified && node.arguments.length === 0 && !node.optional && !t.isCallExpression(parent, {
  callee: node
}) && !t.isMemberExpression(parent) && !t.isNewExpression(parent)) {
  return;
}

this.print(node.typeArguments, node);
this.print(node.typeParameters, node);

if (node.optional) {
  this.token("?.");
}

this.token("(");
this.printList(node.arguments, node);
this.token(")");

}

function SequenceExpression(node) {

this.printList(node.expressions, node);

}

function ThisExpression() {

this.word("this");

}

function Super() {

this.word("super");

}

function Decorator(node) {

this.token("@");
this.print(node.expression, node);
this.newline();

}

function OptionalMemberExpression(node) {

this.print(node.object, node);

if (!node.computed && t.isMemberExpression(node.property)) {
  throw new TypeError("Got a MemberExpression for MemberExpression property");
}

let computed = node.computed;

if (t.isLiteral(node.property) && typeof node.property.value === "number") {
  computed = true;
}

if (node.optional) {
  this.token("?.");
}

if (computed) {
  this.token("[");
  this.print(node.property, node);
  this.token("]");
} else {
  if (!node.optional) {
    this.token(".");
  }

  this.print(node.property, node);
}

}

function OptionalCallExpression(node) {

this.print(node.callee, node);
this.print(node.typeArguments, node);
this.print(node.typeParameters, node);

if (node.optional) {
  this.token("?.");
}

this.token("(");
this.printList(node.arguments, node);
this.token(")");

}

function CallExpression(node) {

this.print(node.callee, node);
this.print(node.typeArguments, node);
this.print(node.typeParameters, node);
this.token("(");
this.printList(node.arguments, node);
this.token(")");

}

function Import() {

this.word("import");

}

function buildYieldAwait(keyword) {

return function (node) {
  this.word(keyword);

  if (node.delegate) {
    this.token("*");
  }

  if (node.argument) {
    this.space();
    const terminatorState = this.startTerminatorless();
    this.print(node.argument, node);
    this.endTerminatorless(terminatorState);
  }
};

}

const YieldExpression = buildYieldAwait(“yield”); exports.YieldExpression = YieldExpression; const AwaitExpression = buildYieldAwait(“await”); exports.AwaitExpression = AwaitExpression;

function EmptyStatement() {

this.semicolon(true);

}

function ExpressionStatement(node) {

this.print(node.expression, node);
this.semicolon();

}

function AssignmentPattern(node) {

this.print(node.left, node);
if (node.left.optional) this.token("?");
this.print(node.left.typeAnnotation, node);
this.space();
this.token("=");
this.space();
this.print(node.right, node);

}

function AssignmentExpression(node, parent) {

const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent);

if (parens) {
  this.token("(");
}

this.print(node.left, node);
this.space();

if (node.operator === "in" || node.operator === "instanceof") {
  this.word(node.operator);
} else {
  this.token(node.operator);
}

this.space();
this.print(node.right, node);

if (parens) {
  this.token(")");
}

}

function BindExpression(node) {

this.print(node.object, node);
this.token("::");
this.print(node.callee, node);

}

function MemberExpression(node) {

this.print(node.object, node);

if (!node.computed && t.isMemberExpression(node.property)) {
  throw new TypeError("Got a MemberExpression for MemberExpression property");
}

let computed = node.computed;

if (t.isLiteral(node.property) && typeof node.property.value === "number") {
  computed = true;
}

if (computed) {
  this.token("[");
  this.print(node.property, node);
  this.token("]");
} else {
  this.token(".");
  this.print(node.property, node);
}

}

function MetaProperty(node) {

this.print(node.meta, node);
this.token(".");
this.print(node.property, node);

}

function PrivateName(node) {

this.token("#");
this.print(node.id, node);

}

function V8IntrinsicIdentifier(node) {

this.token("%");
this.word(node.name);

}