“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.default = parseAndBuildMetadata;

function t() {

const data = _interopRequireWildcard(require("@babel/types"));

t = function () {
  return data;
};

return data;

}

function _parser() {

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

_parser = function () {
  return data;
};

return data;

}

function _codeFrame() {

const data = require("@babel/code-frame");

_codeFrame = function () {
  return data;
};

return data;

}

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } } newObj.default = obj; return newObj; } }

const PATTERN = /^[_$A-Z0-9]+$/;

function parseAndBuildMetadata(formatter, code, opts) {

const ast = parseWithCodeFrame(code, opts.parser);
const {
  placeholderWhitelist,
  placeholderPattern,
  preserveComments,
  syntacticPlaceholders
} = opts;
t().removePropertiesDeep(ast, {
  preserveComments
});
formatter.validate(ast);
const syntactic = {
  placeholders: [],
  placeholderNames: new Set()
};
const legacy = {
  placeholders: [],
  placeholderNames: new Set()
};
const isLegacyRef = {
  value: undefined
};
t().traverse(ast, placeholderVisitorHandler, {
  syntactic,
  legacy,
  isLegacyRef,
  placeholderWhitelist,
  placeholderPattern,
  syntacticPlaceholders
});
return Object.assign({
  ast
}, isLegacyRef.value ? legacy : syntactic);

}

function placeholderVisitorHandler(node, ancestors, state) {

let name;

if (t().isPlaceholder(node)) {
  if (state.syntacticPlaceholders === false) {
    throw new Error("%%foo%%-style placeholders can't be used when " + "'.syntacticPlaceholders' is false.");
  } else {
    name = node.name.name;
    state.isLegacyRef.value = false;
  }
} else if (state.isLegacyRef.value === false || state.syntacticPlaceholders) {
  return;
} else if (t().isIdentifier(node) || t().isJSXIdentifier(node)) {
  name = node.name;
  state.isLegacyRef.value = true;
} else if (t().isStringLiteral(node)) {
  name = node.value;
  state.isLegacyRef.value = true;
} else {
  return;
}

if (!state.isLegacyRef.value && (state.placeholderPattern != null || state.placeholderWhitelist != null)) {
  throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'");
}

if (state.isLegacyRef.value && (state.placeholderPattern === false || !(state.placeholderPattern || PATTERN).test(name)) && (!state.placeholderWhitelist || !state.placeholderWhitelist.has(name))) {
  return;
}

ancestors = ancestors.slice();
const {
  node: parent,
  key
} = ancestors[ancestors.length - 1];
let type;

if (t().isStringLiteral(node) || t().isPlaceholder(node, {
  expectedNode: "StringLiteral"
})) {
  type = "string";
} else if (t().isNewExpression(parent) && key === "arguments" || t().isCallExpression(parent) && key === "arguments" || t().isFunction(parent) && key === "params") {
  type = "param";
} else if (t().isExpressionStatement(parent) && !t().isPlaceholder(node)) {
  type = "statement";
  ancestors = ancestors.slice(0, -1);
} else if (t().isStatement(node) && t().isPlaceholder(node)) {
  type = "statement";
} else {
  type = "other";
}

const {
  placeholders,
  placeholderNames
} = state.isLegacyRef.value ? state.legacy : state.syntactic;
placeholders.push({
  name,
  type,
  resolve: ast => resolveAncestors(ast, ancestors),
  isDuplicate: placeholderNames.has(name)
});
placeholderNames.add(name);

}

function resolveAncestors(ast, ancestors) {

let parent = ast;

for (let i = 0; i < ancestors.length - 1; i++) {
  const {
    key,
    index
  } = ancestors[i];

  if (index === undefined) {
    parent = parent[key];
  } else {
    parent = parent[key][index];
  }
}

const {
  key,
  index
} = ancestors[ancestors.length - 1];
return {
  parent,
  key,
  index
};

}

function parseWithCodeFrame(code, parserOpts) {

parserOpts = Object.assign({
  allowReturnOutsideFunction: true,
  allowSuperOutsideMethod: true,
  sourceType: "module"
}, parserOpts, {
  plugins: (parserOpts.plugins || []).concat("placeholders")
});

try {
  return (0, _parser().parse)(code, parserOpts);
} catch (err) {
  const loc = err.loc;

  if (loc) {
    err.message += "\n" + (0, _codeFrame().codeFrameColumns)(code, {
      start: loc
    });
    err.code = "BABEL_TEMPLATE_PARSE_ERROR";
  }

  throw err;
}

}