“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.default = gatherSequenceExpressions;

var _getBindingIdentifiers = _interopRequireDefault(require(“../retrievers/getBindingIdentifiers”));

var _generated = require(“../validators/generated”);

var _generated2 = require(“../builders/generated”);

var _cloneNode = _interopRequireDefault(require(“../clone/cloneNode”));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function gatherSequenceExpressions(nodes, scope, declars) {

const exprs = [];
let ensureLastUndefined = true;

for (const node of nodes) {
  ensureLastUndefined = false;

  if ((0, _generated.isExpression)(node)) {
    exprs.push(node);
  } else if ((0, _generated.isExpressionStatement)(node)) {
    exprs.push(node.expression);
  } else if ((0, _generated.isVariableDeclaration)(node)) {
    if (node.kind !== "var") return;

    for (const declar of node.declarations) {
      const bindings = (0, _getBindingIdentifiers.default)(declar);

      for (const key of Object.keys(bindings)) {
        declars.push({
          kind: node.kind,
          id: (0, _cloneNode.default)(bindings[key])
        });
      }

      if (declar.init) {
        exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
      }
    }

    ensureLastUndefined = true;
  } else if ((0, _generated.isIfStatement)(node)) {
    const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
    const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
    if (!consequent || !alternate) return;
    exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
  } else if ((0, _generated.isBlockStatement)(node)) {
    const body = gatherSequenceExpressions(node.body, scope, declars);
    if (!body) return;
    exprs.push(body);
  } else if ((0, _generated.isEmptyStatement)(node)) {
    ensureLastUndefined = true;
  } else {
    return;
  }
}

if (ensureLastUndefined) {
  exprs.push(scope.buildUndefinedNode());
}

if (exprs.length === 1) {
  return exprs[0];
} else {
  return (0, _generated2.sequenceExpression)(exprs);
}

}