“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.default = void 0;

var _includes = _interopRequireDefault(require(“lodash/includes”));

var _repeat = _interopRequireDefault(require(“lodash/repeat”));

var _renamer = _interopRequireDefault(require(“./lib/renamer”));

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

var _defaults = _interopRequireDefault(require(“lodash/defaults”));

var _binding = _interopRequireDefault(require(“./binding”));

var _globals = _interopRequireDefault(require(“globals”));

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

var _cache = require(“../cache”);

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 }; }

function gatherNodeParts(node, parts) {

if (t.isModuleDeclaration(node)) {
  if (node.source) {
    gatherNodeParts(node.source, parts);
  } else if (node.specifiers && node.specifiers.length) {
    for (const specifier of node.specifiers) {
      gatherNodeParts(specifier, parts);
    }
  } else if (node.declaration) {
    gatherNodeParts(node.declaration, parts);
  }
} else if (t.isModuleSpecifier(node)) {
  gatherNodeParts(node.local, parts);
} else if (t.isMemberExpression(node)) {
  gatherNodeParts(node.object, parts);
  gatherNodeParts(node.property, parts);
} else if (t.isIdentifier(node)) {
  parts.push(node.name);
} else if (t.isLiteral(node)) {
  parts.push(node.value);
} else if (t.isCallExpression(node)) {
  gatherNodeParts(node.callee, parts);
} else if (t.isObjectExpression(node) || t.isObjectPattern(node)) {
  for (const prop of node.properties) {
    gatherNodeParts(prop.key || prop.argument, parts);
  }
} else if (t.isPrivateName(node)) {
  gatherNodeParts(node.id, parts);
} else if (t.isThisExpression(node)) {
  parts.push("this");
} else if (t.isSuper(node)) {
  parts.push("super");
}

}

const collectorVisitor = {

For(path) {
  for (const key of t.FOR_INIT_KEYS) {
    const declar = path.get(key);

    if (declar.isVar()) {
      const parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
      parentScope.registerBinding("var", declar);
    }
  }
},

Declaration(path) {
  if (path.isBlockScoped()) return;

  if (path.isExportDeclaration() && path.get("declaration").isDeclaration()) {
    return;
  }

  const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
  parent.registerDeclaration(path);
},

ReferencedIdentifier(path, state) {
  state.references.push(path);
},

ForXStatement(path, state) {
  const left = path.get("left");

  if (left.isPattern() || left.isIdentifier()) {
    state.constantViolations.push(path);
  }
},

ExportDeclaration: {
  exit(path) {
    const {
      node,
      scope
    } = path;
    const declar = node.declaration;

    if (t.isClassDeclaration(declar) || t.isFunctionDeclaration(declar)) {
      const id = declar.id;
      if (!id) return;
      const binding = scope.getBinding(id.name);
      if (binding) binding.reference(path);
    } else if (t.isVariableDeclaration(declar)) {
      for (const decl of declar.declarations) {
        for (const name of Object.keys(t.getBindingIdentifiers(decl))) {
          const binding = scope.getBinding(name);
          if (binding) binding.reference(path);
        }
      }
    }
  }

},

LabeledStatement(path) {
  path.scope.getProgramParent().addGlobal(path.node);
  path.scope.getBlockParent().registerDeclaration(path);
},

AssignmentExpression(path, state) {
  state.assignments.push(path);
},

UpdateExpression(path, state) {
  state.constantViolations.push(path);
},

UnaryExpression(path, state) {
  if (path.node.operator === "delete") {
    state.constantViolations.push(path);
  }
},

BlockScoped(path) {
  let scope = path.scope;
  if (scope.path === path) scope = scope.parent;
  scope.getBlockParent().registerDeclaration(path);
},

ClassDeclaration(path) {
  const id = path.node.id;
  if (!id) return;
  const name = id.name;
  path.scope.bindings[name] = path.scope.getBinding(name);
},

Block(path) {
  const paths = path.get("body");

  for (const bodyPath of paths) {
    if (bodyPath.isFunctionDeclaration()) {
      path.scope.getBlockParent().registerDeclaration(bodyPath);
    }
  }
}

}; let uid = 0;

class Scope {

constructor(path) {
  const {
    node
  } = path;

  const cached = _cache.scope.get(node);

  if (cached && cached.path === path) {
    return cached;
  }

  _cache.scope.set(node, this);

  this.uid = uid++;
  this.block = node;
  this.path = path;
  this.labels = new Map();
}

get parent() {
  const parent = this.path.findParent(p => p.isScope());
  return parent && parent.scope;
}

get parentBlock() {
  return this.path.parent;
}

get hub() {
  return this.path.hub;
}

traverse(node, opts, state) {
  (0, _index.default)(node, opts, this, state, this.path);
}

generateDeclaredUidIdentifier(name) {
  const id = this.generateUidIdentifier(name);
  this.push({
    id
  });
  return t.cloneNode(id);
}

generateUidIdentifier(name) {
  return t.identifier(this.generateUid(name));
}

generateUid(name = "temp") {
  name = t.toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
  let uid;
  let i = 0;

  do {
    uid = this._generateUid(name, i);
    i++;
  } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid));

  const program = this.getProgramParent();
  program.references[uid] = true;
  program.uids[uid] = true;
  return uid;
}

_generateUid(name, i) {
  let id = name;
  if (i > 1) id += i;
  return `_${id}`;
}

generateUidBasedOnNode(parent, defaultName) {
  let node = parent;

  if (t.isAssignmentExpression(parent)) {
    node = parent.left;
  } else if (t.isVariableDeclarator(parent)) {
    node = parent.id;
  } else if (t.isObjectProperty(node) || t.isObjectMethod(node)) {
    node = node.key;
  }

  const parts = [];
  gatherNodeParts(node, parts);
  let id = parts.join("$");
  id = id.replace(/^_/, "") || defaultName || "ref";
  return this.generateUid(id.slice(0, 20));
}

generateUidIdentifierBasedOnNode(parent, defaultName) {
  return t.identifier(this.generateUidBasedOnNode(parent, defaultName));
}

isStatic(node) {
  if (t.isThisExpression(node) || t.isSuper(node)) {
    return true;
  }

  if (t.isIdentifier(node)) {
    const binding = this.getBinding(node.name);

    if (binding) {
      return binding.constant;
    } else {
      return this.hasBinding(node.name);
    }
  }

  return false;
}

maybeGenerateMemoised(node, dontPush) {
  if (this.isStatic(node)) {
    return null;
  } else {
    const id = this.generateUidIdentifierBasedOnNode(node);

    if (!dontPush) {
      this.push({
        id
      });
      return t.cloneNode(id);
    }

    return id;
  }
}

checkBlockScopedCollisions(local, kind, name, id) {
  if (kind === "param") return;
  if (local.kind === "local") return;
  const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && (kind === "let" || kind === "const");

  if (duplicate) {
    throw this.hub.buildError(id, `Duplicate declaration "${name}"`, TypeError);
  }
}

rename(oldName, newName, block) {
  const binding = this.getBinding(oldName);

  if (binding) {
    newName = newName || this.generateUidIdentifier(oldName).name;
    return new _renamer.default(binding, oldName, newName).rename(block);
  }
}

_renameFromMap(map, oldName, newName, value) {
  if (map[oldName]) {
    map[newName] = value;
    map[oldName] = null;
  }
}

dump() {
  const sep = (0, _repeat.default)("-", 60);
  console.log(sep);
  let scope = this;

  do {
    console.log("#", scope.block.type);

    for (const name of Object.keys(scope.bindings)) {
      const binding = scope.bindings[name];
      console.log(" -", name, {
        constant: binding.constant,
        references: binding.references,
        violations: binding.constantViolations.length,
        kind: binding.kind
      });
    }
  } while (scope = scope.parent);

  console.log(sep);
}

toArray(node, i) {
  if (t.isIdentifier(node)) {
    const binding = this.getBinding(node.name);

    if (binding && binding.constant && binding.path.isGenericType("Array")) {
      return node;
    }
  }

  if (t.isArrayExpression(node)) {
    return node;
  }

  if (t.isIdentifier(node, {
    name: "arguments"
  })) {
    return t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier("Array"), t.identifier("prototype")), t.identifier("slice")), t.identifier("call")), [node]);
  }

  let helperName;
  const args = [node];

  if (i === true) {
    helperName = "toConsumableArray";
  } else if (i) {
    args.push(t.numericLiteral(i));
    helperName = "slicedToArray";
  } else {
    helperName = "toArray";
  }

  return t.callExpression(this.hub.addHelper(helperName), args);
}

hasLabel(name) {
  return !!this.getLabel(name);
}

getLabel(name) {
  return this.labels.get(name);
}

registerLabel(path) {
  this.labels.set(path.node.label.name, path);
}

registerDeclaration(path) {
  if (path.isLabeledStatement()) {
    this.registerLabel(path);
  } else if (path.isFunctionDeclaration()) {
    this.registerBinding("hoisted", path.get("id"), path);
  } else if (path.isVariableDeclaration()) {
    const declarations = path.get("declarations");

    for (const declar of declarations) {
      this.registerBinding(path.node.kind, declar);
    }
  } else if (path.isClassDeclaration()) {
    this.registerBinding("let", path);
  } else if (path.isImportDeclaration()) {
    const specifiers = path.get("specifiers");

    for (const specifier of specifiers) {
      this.registerBinding("module", specifier);
    }
  } else if (path.isExportDeclaration()) {
    const declar = path.get("declaration");

    if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) {
      this.registerDeclaration(declar);
    }
  } else {
    this.registerBinding("unknown", path);
  }
}

buildUndefinedNode() {
  return t.unaryExpression("void", t.numericLiteral(0), true);
}

registerConstantViolation(path) {
  const ids = path.getBindingIdentifiers();

  for (const name of Object.keys(ids)) {
    const binding = this.getBinding(name);
    if (binding) binding.reassign(path);
  }
}

registerBinding(kind, path, bindingPath = path) {
  if (!kind) throw new ReferenceError("no `kind`");

  if (path.isVariableDeclaration()) {
    const declarators = path.get("declarations");

    for (const declar of declarators) {
      this.registerBinding(kind, declar);
    }

    return;
  }

  const parent = this.getProgramParent();
  const ids = path.getOuterBindingIdentifiers(true);

  for (const name of Object.keys(ids)) {
    for (const id of ids[name]) {
      const local = this.getOwnBinding(name);

      if (local) {
        if (local.identifier === id) continue;
        this.checkBlockScopedCollisions(local, kind, name, id);
      }

      parent.references[name] = true;

      if (local) {
        this.registerConstantViolation(bindingPath);
      } else {
        this.bindings[name] = new _binding.default({
          identifier: id,
          scope: this,
          path: bindingPath,
          kind: kind
        });
      }
    }
  }
}

addGlobal(node) {
  this.globals[node.name] = node;
}

hasUid(name) {
  let scope = this;

  do {
    if (scope.uids[name]) return true;
  } while (scope = scope.parent);

  return false;
}

hasGlobal(name) {
  let scope = this;

  do {
    if (scope.globals[name]) return true;
  } while (scope = scope.parent);

  return false;
}

hasReference(name) {
  let scope = this;

  do {
    if (scope.references[name]) return true;
  } while (scope = scope.parent);

  return false;
}

isPure(node, constantsOnly) {
  if (t.isIdentifier(node)) {
    const binding = this.getBinding(node.name);
    if (!binding) return false;
    if (constantsOnly) return binding.constant;
    return true;
  } else if (t.isClass(node)) {
    if (node.superClass && !this.isPure(node.superClass, constantsOnly)) {
      return false;
    }

    return this.isPure(node.body, constantsOnly);
  } else if (t.isClassBody(node)) {
    for (const method of node.body) {
      if (!this.isPure(method, constantsOnly)) return false;
    }

    return true;
  } else if (t.isBinary(node)) {
    return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly);
  } else if (t.isArrayExpression(node)) {
    for (const elem of node.elements) {
      if (!this.isPure(elem, constantsOnly)) return false;
    }

    return true;
  } else if (t.isObjectExpression(node)) {
    for (const prop of node.properties) {
      if (!this.isPure(prop, constantsOnly)) return false;
    }

    return true;
  } else if (t.isClassMethod(node)) {
    if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
    if (node.kind === "get" || node.kind === "set") return false;
    return true;
  } else if (t.isProperty(node)) {
    if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
    return this.isPure(node.value, constantsOnly);
  } else if (t.isUnaryExpression(node)) {
    return this.isPure(node.argument, constantsOnly);
  } else if (t.isTaggedTemplateExpression(node)) {
    return t.matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
  } else if (t.isTemplateLiteral(node)) {
    for (const expression of node.expressions) {
      if (!this.isPure(expression, constantsOnly)) return false;
    }

    return true;
  } else {
    return t.isPureish(node);
  }
}

setData(key, val) {
  return this.data[key] = val;
}

getData(key) {
  let scope = this;

  do {
    const data = scope.data[key];
    if (data != null) return data;
  } while (scope = scope.parent);
}

removeData(key) {
  let scope = this;

  do {
    const data = scope.data[key];
    if (data != null) scope.data[key] = null;
  } while (scope = scope.parent);
}

init() {
  if (!this.references) this.crawl();
}

crawl() {
  const path = this.path;
  this.references = Object.create(null);
  this.bindings = Object.create(null);
  this.globals = Object.create(null);
  this.uids = Object.create(null);
  this.data = Object.create(null);

  if (path.isLoop()) {
    for (const key of t.FOR_INIT_KEYS) {
      const node = path.get(key);
      if (node.isBlockScoped()) this.registerBinding(node.node.kind, node);
    }
  }

  if (path.isFunctionExpression() && path.has("id")) {
    if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {
      this.registerBinding("local", path.get("id"), path);
    }
  }

  if (path.isClassExpression() && path.has("id")) {
    if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {
      this.registerBinding("local", path);
    }
  }

  if (path.isFunction()) {
    const params = path.get("params");

    for (const param of params) {
      this.registerBinding("param", param);
    }
  }

  if (path.isCatchClause()) {
    this.registerBinding("let", path);
  }

  const parent = this.getProgramParent();
  if (parent.crawling) return;
  const state = {
    references: [],
    constantViolations: [],
    assignments: []
  };
  this.crawling = true;
  path.traverse(collectorVisitor, state);
  this.crawling = false;

  for (const path of state.assignments) {
    const ids = path.getBindingIdentifiers();
    let programParent;

    for (const name of Object.keys(ids)) {
      if (path.scope.getBinding(name)) continue;
      programParent = programParent || path.scope.getProgramParent();
      programParent.addGlobal(ids[name]);
    }

    path.scope.registerConstantViolation(path);
  }

  for (const ref of state.references) {
    const binding = ref.scope.getBinding(ref.node.name);

    if (binding) {
      binding.reference(ref);
    } else {
      ref.scope.getProgramParent().addGlobal(ref.node);
    }
  }

  for (const path of state.constantViolations) {
    path.scope.registerConstantViolation(path);
  }
}

push(opts) {
  let path = this.path;

  if (!path.isBlockStatement() && !path.isProgram()) {
    path = this.getBlockParent().path;
  }

  if (path.isSwitchStatement()) {
    path = (this.getFunctionParent() || this.getProgramParent()).path;
  }

  if (path.isLoop() || path.isCatchClause() || path.isFunction()) {
    path.ensureBlock();
    path = path.get("body");
  }

  const unique = opts.unique;
  const kind = opts.kind || "var";
  const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist;
  const dataKey = `declaration:${kind}:${blockHoist}`;
  let declarPath = !unique && path.getData(dataKey);

  if (!declarPath) {
    const declar = t.variableDeclaration(kind, []);
    declar._blockHoist = blockHoist;
    [declarPath] = path.unshiftContainer("body", [declar]);
    if (!unique) path.setData(dataKey, declarPath);
  }

  const declarator = t.variableDeclarator(opts.id, opts.init);
  declarPath.node.declarations.push(declarator);
  this.registerBinding(kind, declarPath.get("declarations").pop());
}

getProgramParent() {
  let scope = this;

  do {
    if (scope.path.isProgram()) {
      return scope;
    }
  } while (scope = scope.parent);

  throw new Error("Couldn't find a Program");
}

getFunctionParent() {
  let scope = this;

  do {
    if (scope.path.isFunctionParent()) {
      return scope;
    }
  } while (scope = scope.parent);

  return null;
}

getBlockParent() {
  let scope = this;

  do {
    if (scope.path.isBlockParent()) {
      return scope;
    }
  } while (scope = scope.parent);

  throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
}

getAllBindings() {
  const ids = Object.create(null);
  let scope = this;

  do {
    (0, _defaults.default)(ids, scope.bindings);
    scope = scope.parent;
  } while (scope);

  return ids;
}

getAllBindingsOfKind() {
  const ids = Object.create(null);

  for (const kind of arguments) {
    let scope = this;

    do {
      for (const name of Object.keys(scope.bindings)) {
        const binding = scope.bindings[name];
        if (binding.kind === kind) ids[name] = binding;
      }

      scope = scope.parent;
    } while (scope);
  }

  return ids;
}

bindingIdentifierEquals(name, node) {
  return this.getBindingIdentifier(name) === node;
}

getBinding(name) {
  let scope = this;

  do {
    const binding = scope.getOwnBinding(name);
    if (binding) return binding;
  } while (scope = scope.parent);
}

getOwnBinding(name) {
  return this.bindings[name];
}

getBindingIdentifier(name) {
  const info = this.getBinding(name);
  return info && info.identifier;
}

getOwnBindingIdentifier(name) {
  const binding = this.bindings[name];
  return binding && binding.identifier;
}

hasOwnBinding(name) {
  return !!this.getOwnBinding(name);
}

hasBinding(name, noGlobals) {
  if (!name) return false;
  if (this.hasOwnBinding(name)) return true;
  if (this.parentHasBinding(name, noGlobals)) return true;
  if (this.hasUid(name)) return true;
  if (!noGlobals && (0, _includes.default)(Scope.globals, name)) return true;
  if (!noGlobals && (0, _includes.default)(Scope.contextVariables, name)) return true;
  return false;
}

parentHasBinding(name, noGlobals) {
  return this.parent && this.parent.hasBinding(name, noGlobals);
}

moveBindingTo(name, scope) {
  const info = this.getBinding(name);

  if (info) {
    info.scope.removeOwnBinding(name);
    info.scope = scope;
    scope.bindings[name] = info;
  }
}

removeOwnBinding(name) {
  delete this.bindings[name];
}

removeBinding(name) {
  const info = this.getBinding(name);

  if (info) {
    info.scope.removeOwnBinding(name);
  }

  let scope = this;

  do {
    if (scope.uids[name]) {
      scope.uids[name] = false;
    }
  } while (scope = scope.parent);
}

}

exports.default = Scope; Scope.globals = Object.keys(_globals.default.builtin); Scope.contextVariables = [“arguments”, “undefined”, “Infinity”, “NaN”];