“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.replaceWithMultiple = replaceWithMultiple; exports.replaceWithSourceString = replaceWithSourceString; exports.replaceWith = replaceWith; exports._replaceWith = _replaceWith; exports.replaceExpressionWithStatements = replaceExpressionWithStatements; exports.replaceInline = replaceInline;

var _codeFrame = require(“@babel/code-frame”);

var _index = _interopRequireDefault(require(“../index”));

var _index2 = _interopRequireDefault(require(“./index”));

var _parser = require(“@babel/parser”);

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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const hoistVariablesVisitor = {

Function(path) {
  path.skip();
},

VariableDeclaration(path) {
  if (path.node.kind !== "var") return;
  const bindings = path.getBindingIdentifiers();

  for (const key of Object.keys(bindings)) {
    path.scope.push({
      id: bindings[key]
    });
  }

  const exprs = [];

  for (const declar of path.node.declarations) {
    if (declar.init) {
      exprs.push(t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init)));
    }
  }

  path.replaceWithMultiple(exprs);
}

};

function replaceWithMultiple(nodes) {

this.resync();
nodes = this._verifyNodeList(nodes);
t.inheritLeadingComments(nodes[0], this.node);
t.inheritTrailingComments(nodes[nodes.length - 1], this.node);
this.node = this.container[this.key] = null;
const paths = this.insertAfter(nodes);

if (this.node) {
  this.requeue();
} else {
  this.remove();
}

return paths;

}

function replaceWithSourceString(replacement) {

this.resync();

try {
  replacement = `(${replacement})`;
  replacement = (0, _parser.parse)(replacement);
} catch (err) {
  const loc = err.loc;

  if (loc) {
    err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, {
      start: {
        line: loc.line,
        column: loc.column + 1
      }
    });
    err.code = "BABEL_REPLACE_SOURCE_ERROR";
  }

  throw err;
}

replacement = replacement.program.body[0].expression;

_index.default.removeProperties(replacement);

return this.replaceWith(replacement);

}

function replaceWith(replacement) {

this.resync();

if (this.removed) {
  throw new Error("You can't replace this node, we've already removed it");
}

if (replacement instanceof _index2.default) {
  replacement = replacement.node;
}

if (!replacement) {
  throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
}

if (this.node === replacement) {
  return [this];
}

if (this.isProgram() && !t.isProgram(replacement)) {
  throw new Error("You can only replace a Program root node with another Program node");
}

if (Array.isArray(replacement)) {
  throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`");
}

if (typeof replacement === "string") {
  throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
}

let nodePath = "";

if (this.isNodeType("Statement") && t.isExpression(replacement)) {
  if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
    replacement = t.expressionStatement(replacement);
    nodePath = "expression";
  }
}

if (this.isNodeType("Expression") && t.isStatement(replacement)) {
  if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
    return this.replaceExpressionWithStatements([replacement]);
  }
}

const oldNode = this.node;

if (oldNode) {
  t.inheritsComments(replacement, oldNode);
  t.removeComments(oldNode);
}

this._replaceWith(replacement);

this.type = replacement.type;
this.setScope();
this.requeue();
return [nodePath ? this.get(nodePath) : this];

}

function _replaceWith(node) {

if (!this.container) {
  throw new ReferenceError("Container is falsy");
}

if (this.inList) {
  t.validate(this.parent, this.key, [node]);
} else {
  t.validate(this.parent, this.key, node);
}

this.debug(`Replace with ${node && node.type}`);
this.node = this.container[this.key] = node;

}

function replaceExpressionWithStatements(nodes) {

this.resync();
const toSequenceExpression = t.toSequenceExpression(nodes, this.scope);

if (toSequenceExpression) {
  return this.replaceWith(toSequenceExpression)[0].get("expressions");
}

const functionParent = this.getFunctionParent();
const isParentAsync = functionParent && functionParent.is("async");
const container = t.arrowFunctionExpression([], t.blockStatement(nodes));
this.replaceWith(t.callExpression(container, []));
this.traverse(hoistVariablesVisitor);
const completionRecords = this.get("callee").getCompletionRecords();

for (const path of completionRecords) {
  if (!path.isExpressionStatement()) continue;
  const loop = path.findParent(path => path.isLoop());

  if (loop) {
    let uid = loop.getData("expressionReplacementReturnUid");

    if (!uid) {
      const callee = this.get("callee");
      uid = callee.scope.generateDeclaredUidIdentifier("ret");
      callee.get("body").pushContainer("body", t.returnStatement(t.cloneNode(uid)));
      loop.setData("expressionReplacementReturnUid", uid);
    } else {
      uid = t.identifier(uid.name);
    }

    path.get("expression").replaceWith(t.assignmentExpression("=", t.cloneNode(uid), path.node.expression));
  } else {
    path.replaceWith(t.returnStatement(path.node.expression));
  }
}

const callee = this.get("callee");
callee.arrowFunctionToExpression();

if (isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t.FUNCTION_TYPES)) {
  callee.set("async", true);
  this.replaceWith(t.awaitExpression(this.node));
}

return callee.get("body.body");

}

function replaceInline(nodes) {

this.resync();

if (Array.isArray(nodes)) {
  if (Array.isArray(this.container)) {
    nodes = this._verifyNodeList(nodes);

    const paths = this._containerInsertAfter(nodes);

    this.remove();
    return paths;
  } else {
    return this.replaceWithMultiple(nodes);
  }
} else {
  return this.replaceWith(nodes);
}

}