“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.default = void 0;

function _helperPluginUtils() {

const data = require("@babel/helper-plugin-utils");

_helperPluginUtils = function () {
  return data;
};

return data;

}

function _core() {

const data = require("@babel/core");

_core = function () {
  return data;
};

return data;

}

var _default = (0, _helperPluginUtils().declare)((api, options) => {

api.assertVersion(7);
const {
  loose,
  assumeArray
} = options;

if (loose === true && assumeArray === true) {
  throw new Error(`The loose and assumeArray options cannot be used together in @babel/plugin-transform-for-of`);
}

if (assumeArray) {
  return {
    name: "transform-for-of",
    visitor: {
      ForOfStatement(path) {
        const {
          scope
        } = path;
        const {
          left,
          right,
          body
        } = path.node;
        const i = scope.generateUidIdentifier("i");
        let array = scope.maybeGenerateMemoised(right, true);
        const inits = [_core().types.variableDeclarator(i, _core().types.numericLiteral(0))];

        if (array) {
          inits.push(_core().types.variableDeclarator(array, right));
        } else {
          array = right;
        }

        const item = _core().types.memberExpression(_core().types.cloneNode(array), _core().types.cloneNode(i), true);

        let assignment;

        if (_core().types.isVariableDeclaration(left)) {
          assignment = left;
          assignment.declarations[0].init = item;
        } else {
          assignment = _core().types.expressionStatement(_core().types.assignmentExpression("=", left, item));
        }

        const block = _core().types.toBlock(body);

        block.body.unshift(assignment);
        path.replaceWith(_core().types.forStatement(_core().types.variableDeclaration("let", inits), _core().types.binaryExpression("<", _core().types.cloneNode(i), _core().types.memberExpression(_core().types.cloneNode(array), _core().types.identifier("length"))), _core().types.updateExpression("++", _core().types.cloneNode(i)), block));
      }

    }
  };
}

const pushComputedProps = loose ? pushComputedPropsLoose : pushComputedPropsSpec;
const buildForOfArray = (0, _core().template)(`
  for (var KEY = 0, NAME = ARR; KEY < NAME.length; KEY++) BODY;
`);
const buildForOfLoose = (0, _core().template)(`
  for (var LOOP_OBJECT = OBJECT,
           IS_ARRAY = Array.isArray(LOOP_OBJECT),
           INDEX = 0,
           LOOP_OBJECT = IS_ARRAY ? LOOP_OBJECT : LOOP_OBJECT[Symbol.iterator]();;) {
    INTERMEDIATE;
    if (IS_ARRAY) {
      if (INDEX >= LOOP_OBJECT.length) break;
      ID = LOOP_OBJECT[INDEX++];
    } else {
      INDEX = LOOP_OBJECT.next();
      if (INDEX.done) break;
      ID = INDEX.value;
    }
  }
`);
const buildForOf = (0, _core().template)(`
  var ITERATOR_COMPLETION = true;
  var ITERATOR_HAD_ERROR_KEY = false;
  var ITERATOR_ERROR_KEY = undefined;
  try {
    for (
      var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY;
      !(ITERATOR_COMPLETION = (STEP_KEY = ITERATOR_KEY.next()).done);
      ITERATOR_COMPLETION = true
    ) {}
  } catch (err) {
    ITERATOR_HAD_ERROR_KEY = true;
    ITERATOR_ERROR_KEY = err;
  } finally {
    try {
      if (!ITERATOR_COMPLETION && ITERATOR_KEY.return != null) {
        ITERATOR_KEY.return();
      }
    } finally {
      if (ITERATOR_HAD_ERROR_KEY) {
        throw ITERATOR_ERROR_KEY;
      }
    }
  }
`);

function _ForOfStatementArray(path) {
  const {
    node,
    scope
  } = path;
  const right = scope.generateUidIdentifierBasedOnNode(node.right, "arr");
  const iterationKey = scope.generateUidIdentifier("i");
  let loop = buildForOfArray({
    BODY: node.body,
    KEY: iterationKey,
    NAME: right,
    ARR: node.right
  });

  _core().types.inherits(loop, node);

  _core().types.ensureBlock(loop);

  const iterationValue = _core().types.memberExpression(_core().types.cloneNode(right), _core().types.cloneNode(iterationKey), true);

  const left = node.left;

  if (_core().types.isVariableDeclaration(left)) {
    left.declarations[0].init = iterationValue;
    loop.body.body.unshift(left);
  } else {
    loop.body.body.unshift(_core().types.expressionStatement(_core().types.assignmentExpression("=", left, iterationValue)));
  }

  if (path.parentPath.isLabeledStatement()) {
    loop = _core().types.labeledStatement(path.parentPath.node.label, loop);
  }

  return [loop];
}

function replaceWithArray(path) {
  if (path.parentPath.isLabeledStatement()) {
    path.parentPath.replaceWithMultiple(_ForOfStatementArray(path));
  } else {
    path.replaceWithMultiple(_ForOfStatementArray(path));
  }
}

return {
  name: "transform-for-of",
  visitor: {
    ForOfStatement(path, state) {
      const right = path.get("right");

      if (right.isArrayExpression() || right.isGenericType("Array") || _core().types.isArrayTypeAnnotation(right.getTypeAnnotation())) {
        replaceWithArray(path);
        return;
      }

      const {
        node
      } = path;
      const build = pushComputedProps(path, state);
      const declar = build.declar;
      const loop = build.loop;
      const block = loop.body;
      path.ensureBlock();

      if (declar) {
        block.body.push(declar);
      }

      block.body = block.body.concat(node.body.body);

      _core().types.inherits(loop, node);

      _core().types.inherits(loop.body, node.body);

      if (build.replaceParent) {
        path.parentPath.replaceWithMultiple(build.node);
        path.remove();
      } else {
        path.replaceWithMultiple(build.node);
      }
    }

  }
};

function pushComputedPropsLoose(path, file) {
  const {
    node,
    scope,
    parent
  } = path;
  const {
    left
  } = node;
  let declar, id, intermediate;

  if (_core().types.isIdentifier(left) || _core().types.isPattern(left) || _core().types.isMemberExpression(left)) {
    id = left;
    intermediate = null;
  } else if (_core().types.isVariableDeclaration(left)) {
    id = scope.generateUidIdentifier("ref");
    declar = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(left.declarations[0].id, _core().types.identifier(id.name))]);
    intermediate = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(id.name))]);
  } else {
    throw file.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
  }

  const iteratorKey = scope.generateUidIdentifier("iterator");
  const isArrayKey = scope.generateUidIdentifier("isArray");
  const loop = buildForOfLoose({
    LOOP_OBJECT: iteratorKey,
    IS_ARRAY: isArrayKey,
    OBJECT: node.right,
    INDEX: scope.generateUidIdentifier("i"),
    ID: id,
    INTERMEDIATE: intermediate
  });

  const isLabeledParent = _core().types.isLabeledStatement(parent);

  let labeled;

  if (isLabeledParent) {
    labeled = _core().types.labeledStatement(parent.label, loop);
  }

  return {
    replaceParent: isLabeledParent,
    declar: declar,
    node: labeled || loop,
    loop: loop
  };
}

function pushComputedPropsSpec(path, file) {
  const {
    node,
    scope,
    parent
  } = path;
  const left = node.left;
  let declar;
  const stepKey = scope.generateUid("step");

  const stepValue = _core().types.memberExpression(_core().types.identifier(stepKey), _core().types.identifier("value"));

  if (_core().types.isIdentifier(left) || _core().types.isPattern(left) || _core().types.isMemberExpression(left)) {
    declar = _core().types.expressionStatement(_core().types.assignmentExpression("=", left, stepValue));
  } else if (_core().types.isVariableDeclaration(left)) {
    declar = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(left.declarations[0].id, stepValue)]);
  } else {
    throw file.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
  }

  const template = buildForOf({
    ITERATOR_HAD_ERROR_KEY: scope.generateUidIdentifier("didIteratorError"),
    ITERATOR_COMPLETION: scope.generateUidIdentifier("iteratorNormalCompletion"),
    ITERATOR_ERROR_KEY: scope.generateUidIdentifier("iteratorError"),
    ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
    STEP_KEY: _core().types.identifier(stepKey),
    OBJECT: node.right
  });

  const isLabeledParent = _core().types.isLabeledStatement(parent);

  const tryBody = template[3].block.body;
  const loop = tryBody[0];

  if (isLabeledParent) {
    tryBody[0] = _core().types.labeledStatement(parent.label, loop);
  }

  return {
    replaceParent: isLabeledParent,
    declar: declar,
    loop: loop,
    node: template
  };
}

});

exports.default = _default;