"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _fs = _interopRequireDefault(require("fs"));

var acorn = _interopRequireWildcard(require("acorn"));

var _acornJsx = _interopRequireDefault(require("acorn-jsx"));

var _acornStage = _interopRequireDefault(require("acorn-stage3"));

var _chalk = _interopRequireDefault(require("chalk"));

var _cloneDeep = _interopRequireDefault(require("clone-deep"));

var _deepmerge = _interopRequireDefault(require("deepmerge"));

var _ensureArray = _interopRequireDefault(require("ensure-array"));

var _esprima = require("esprima");

var _lodash = _interopRequireDefault(require("lodash"));

var _parse = _interopRequireDefault(require("parse5"));

var _sortobject = _interopRequireDefault(require("sortobject"));

var _i18next = _interopRequireDefault(require("i18next"));

var _acornJsxWalk = _interopRequireDefault(require("./acorn-jsx-walk"));

var _flattenObjectKeys = _interopRequireDefault(require("./flatten-object-keys"));

var _omitEmptyObject = _interopRequireDefault(require("./omit-empty-object"));

var _nodesToString = _interopRequireDefault(require("./nodes-to-string"));

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; 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[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

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

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var defaults = {
  debug: false,
  // verbose logging
  sort: false,
  // sort keys in alphabetical order
  attr: {
    // HTML attributes to parse
    list: ['data-i18n'],
    extensions: ['.html', '.htm']
  },
  func: {
    // function names to parse
    list: ['i18next.t', 'i18n.t'],
    extensions: ['.js', '.jsx']
  },
  trans: {
    // Trans component (https://github.com/i18next/react-i18next)
    component: 'Trans',
    i18nKey: 'i18nKey',
    defaultsKey: 'defaults',
    extensions: ['.js', '.jsx'],
    fallbackKey: false,
    acorn: {
      ecmaVersion: 10,
      // defaults to 10
      sourceType: 'module' // defaults to 'module'
      // Check out https://github.com/acornjs/acorn/tree/master/acorn#interface for additional options

    }
  },
  lngs: ['en'],
  // array of supported languages
  fallbackLng: 'en',
  // language to lookup key if not found while calling `parser.get(key, { lng: '' })`
  ns: [],
  // string or array of namespaces
  defaultLng: 'en',
  // default language used for checking default values
  defaultNs: 'translation',
  // default namespace used if not passed to translation function
  defaultValue: '',
  // default value used if not passed to `parser.set`
  // resource
  resource: {
    // The path where resources get loaded from. Relative to current working directory.
    loadPath: 'i18n/{{lng}}/{{ns}}.json',
    // The path to store resources. Relative to the path specified by `gulp.dest(path)`.
    savePath: 'i18n/{{lng}}/{{ns}}.json',
    // Specify the number of space characters to use as white space to insert into the output JSON string for readability purpose.
    jsonIndent: 2,
    // Normalize line endings to '\r\n', '\r', '\n', or 'auto' for the current operating system. Defaults to '\n'.
    // Aliases: 'CRLF', 'CR', 'LF', 'crlf', 'cr', 'lf'
    lineEnding: '\n'
  },
  keySeparator: '.',
  // char to separate keys
  nsSeparator: ':',
  // char to split namespace from key
  // Context Form
  context: true,
  // whether to add context form key
  contextFallback: true,
  // whether to add a fallback key as well as the context form key
  contextSeparator: '_',
  // char to split context from key
  contextDefaultValues: [],
  // list of values for dynamic values
  // Plural Form
  plural: true,
  // whether to add plural form key
  pluralFallback: true,
  // whether to add a fallback key as well as the plural form key
  pluralSeparator: '_',
  // char to split plural from key
  // interpolation options
  interpolation: {
    prefix: '{{',
    // prefix for interpolation
    suffix: '}}' // suffix for interpolation

  }
}; // http://codereview.stackexchange.com/questions/45991/balanced-parentheses

var matchBalancedParentheses = function matchBalancedParentheses() {
  var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  var parentheses = '[]{}()';
  var stack = [];
  var bracePosition;
  var start = -1;
  var i = 0;
  str = '' + str; // ensure string

  for (i = 0; i < str.length; ++i) {
    if (start >= 0 && stack.length === 0) {
      return str.substring(start, i);
    }

    bracePosition = parentheses.indexOf(str[i]);

    if (bracePosition < 0) {
      continue;
    }

    if (bracePosition % 2 === 0) {
      if (start < 0) {
        start = i; // remember the start position
      }

      stack.push(bracePosition + 1); // push next expected brace position

      continue;
    }

    if (stack.pop() !== bracePosition) {
      return str.substring(start, i);
    }
  }

  return str.substring(start, i);
};

var normalizeOptions = function normalizeOptions(options) {
  // Attribute
  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'attr.list'))) {
    _lodash["default"].set(options, 'attr.list', defaults.attr.list);
  }

  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'attr.extensions'))) {
    _lodash["default"].set(options, 'attr.extensions', defaults.attr.extensions);
  } // Function


  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'func.list'))) {
    _lodash["default"].set(options, 'func.list', defaults.func.list);
  }

  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'func.extensions'))) {
    _lodash["default"].set(options, 'func.extensions', defaults.func.extensions);
  } // Trans


  if (_lodash["default"].get(options, 'trans')) {
    if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'trans.component'))) {
      _lodash["default"].set(options, 'trans.component', defaults.trans.component);
    }

    if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'trans.i18nKey'))) {
      _lodash["default"].set(options, 'trans.i18nKey', defaults.trans.i18nKey);
    }

    if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'trans.defaultsKey'))) {
      _lodash["default"].set(options, 'trans.defaultsKey', defaults.trans.defaultsKey);
    }

    if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'trans.extensions'))) {
      _lodash["default"].set(options, 'trans.extensions', defaults.trans.extensions);
    }

    if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'trans.fallbackKey'))) {
      _lodash["default"].set(options, 'trans.fallbackKey', defaults.trans.fallbackKey);
    }

    if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'trans.acorn'))) {
      _lodash["default"].set(options, 'trans.acorn', defaults.trans.acorn);
    }
  } // Resource


  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'resource.loadPath'))) {
    _lodash["default"].set(options, 'resource.loadPath', defaults.resource.loadPath);
  }

  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'resource.savePath'))) {
    _lodash["default"].set(options, 'resource.savePath', defaults.resource.savePath);
  }

  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'resource.jsonIndent'))) {
    _lodash["default"].set(options, 'resource.jsonIndent', defaults.resource.jsonIndent);
  }

  if (_lodash["default"].isUndefined(_lodash["default"].get(options, 'resource.lineEnding'))) {
    _lodash["default"].set(options, 'resource.lineEnding', defaults.resource.lineEnding);
  } // Accept both nsseparator or nsSeparator


  if (!_lodash["default"].isUndefined(options.nsseparator)) {
    options.nsSeparator = options.nsseparator;
    delete options.nsseparator;
  } // Allowed only string or false


  if (!_lodash["default"].isString(options.nsSeparator)) {
    options.nsSeparator = false;
  } // Accept both keyseparator or keySeparator


  if (!_lodash["default"].isUndefined(options.keyseparator)) {
    options.keySeparator = options.keyseparator;
    delete options.keyseparator;
  } // Allowed only string or false


  if (!_lodash["default"].isString(options.keySeparator)) {
    options.keySeparator = false;
  }

  if (!_lodash["default"].isArray(options.ns)) {
    options.ns = [options.ns];
  }

  options.ns = _lodash["default"].union(_lodash["default"].flatten(options.ns.concat(options.defaultNs)));
  return options;
}; // Get an array of plural suffixes for a given language.
// @param {string} lng The language.
// @param {string} pluralSeparator pluralSeparator, default '_'.
// @return {array} An array of plural suffixes.


var getPluralSuffixes = function getPluralSuffixes(lng) {
  var pluralSeparator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '_';

  var rule = _i18next["default"].services.pluralResolver.getRule(lng);

  if (!(rule && rule.numbers)) {
    return []; // Return an empty array if lng is not supported
  }

  if (rule.numbers.length === 1) {
    return ["".concat(pluralSeparator, "0")];
  }

  if (rule.numbers.length === 2) {
    return ['', "".concat(pluralSeparator, "plural")];
  }

  var suffixes = rule.numbers.reduce(function (acc, n, i) {
    return acc.concat("".concat(pluralSeparator).concat(i));
  }, []);
  return suffixes;
};
/**
* Creates a new parser
* @constructor
*/


var Parser = /*#__PURE__*/function () {
  // The resStore stores all translation keys including unused ones
  // The resScan only stores translation keys parsed from code
  // The all plurals suffixes for each of target languages.
  function Parser(options) {
    var _this = this;

    _classCallCheck(this, Parser);

    _defineProperty(this, "options", _objectSpread({}, defaults));

    _defineProperty(this, "resStore", {});

    _defineProperty(this, "resScan", {});

    _defineProperty(this, "pluralSuffixes", {});

    this.options = normalizeOptions(_objectSpread({}, this.options, {}, options));
    var lngs = this.options.lngs;
    var namespaces = this.options.ns;
    lngs.forEach(function (lng) {
      _this.resStore[lng] = _this.resStore[lng] || {};
      _this.resScan[lng] = _this.resScan[lng] || {};
      _this.pluralSuffixes[lng] = (0, _ensureArray["default"])(getPluralSuffixes(lng, _this.options.pluralSeparator));

      if (_this.pluralSuffixes[lng].length === 0) {
        _this.log("No plural rule found for: ".concat(lng));
      }

      namespaces.forEach(function (ns) {
        var resPath = _this.formatResourceLoadPath(lng, ns);

        _this.resStore[lng][ns] = {};
        _this.resScan[lng][ns] = {};

        try {
          if (_fs["default"].existsSync(resPath)) {
            _this.resStore[lng][ns] = JSON.parse(_fs["default"].readFileSync(resPath, 'utf-8'));
          }
        } catch (err) {
          _this.error("Unable to load resource file ".concat(_chalk["default"].yellow(JSON.stringify(resPath)), ": lng=").concat(lng, ", ns=").concat(ns));

          _this.error(err);
        }
      });
    });
    this.log("options=".concat(JSON.stringify(this.options, null, 2)));
  }

  _createClass(Parser, [{
    key: "log",
    value: function log() {
      var debug = this.options.debug;

      if (debug) {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        console.log.apply(this, [_chalk["default"].cyan('i18next-scanner:')].concat(args));
      }
    }
  }, {
    key: "error",
    value: function error() {
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

      console.error.apply(this, [_chalk["default"].red('i18next-scanner:')].concat(args));
    }
  }, {
    key: "formatResourceLoadPath",
    value: function formatResourceLoadPath(lng, ns) {
      var options = this.options;
      var regex = {
        lng: new RegExp(_lodash["default"].escapeRegExp(options.interpolation.prefix + 'lng' + options.interpolation.suffix), 'g'),
        ns: new RegExp(_lodash["default"].escapeRegExp(options.interpolation.prefix + 'ns' + options.interpolation.suffix), 'g')
      };
      return options.resource.loadPath.replace(regex.lng, lng).replace(regex.ns, ns);
    }
  }, {
    key: "formatResourceSavePath",
    value: function formatResourceSavePath(lng, ns) {
      var options = this.options;
      var regex = {
        lng: new RegExp(_lodash["default"].escapeRegExp(options.interpolation.prefix + 'lng' + options.interpolation.suffix), 'g'),
        ns: new RegExp(_lodash["default"].escapeRegExp(options.interpolation.prefix + 'ns' + options.interpolation.suffix), 'g')
      };
      return options.resource.savePath.replace(regex.lng, lng).replace(regex.ns, ns);
    }
  }, {
    key: "fixStringAfterRegExp",
    value: function fixStringAfterRegExp(strToFix) {
      var fixedString = _lodash["default"].trim(strToFix); // Remove leading and trailing whitespace


      var firstChar = fixedString[0]; // Ignore key with embedded expressions in string literals

      if (firstChar === '`' && fixedString.match(/\${.*?}/)) {
        return null;
      }

      if (_lodash["default"].includes(['\'', '"', '`'], firstChar)) {
        // Remove first and last character
        fixedString = fixedString.slice(1, -1);
      } // restore multiline strings


      fixedString = fixedString.replace(/(\\\n|\\\r\n)/g, ''); // JavaScript character escape sequences
      // https://mathiasbynens.be/notes/javascript-escapes
      // Single character escape sequences
      // Note: IE < 9 treats '\v' as 'v' instead of a vertical tab ('\x0B'). If cross-browser compatibility is a concern, use \x0B instead of \v.
      // Another thing to note is that the \v and \0 escapes are not allowed in JSON strings.

      fixedString = fixedString.replace(/(\\b|\\f|\\n|\\r|\\t|\\v|\\0|\\\\|\\"|\\')/g, function (match) {
        return eval("\"".concat(match, "\""));
      }); // * Octal escapes have been deprecated in ES5.
      // * Hexadecimal escape sequences: \\x[a-fA-F0-9]{2}
      // * Unicode escape sequences: \\u[a-fA-F0-9]{4}

      fixedString = fixedString.replace(/(\\x[a-fA-F0-9]{2}|\\u[a-fA-F0-9]{4})/g, function (match) {
        return eval("\"".concat(match, "\""));
      });
      return fixedString;
    } // i18next.t('ns:foo.bar') // matched
    // i18next.t("ns:foo.bar") // matched
    // i18next.t('ns:foo.bar') // matched
    // i18next.t("ns:foo.bar", { count: 1 }); // matched
    // i18next.t("ns:foo.bar" + str); // not matched

  }, {
    key: "parseFuncFromString",
    value: function parseFuncFromString(content) {
      var _this2 = this;

      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var customHandler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

      if (_lodash["default"].isFunction(opts)) {
        customHandler = opts;
        opts = {};
      }

      var funcs = opts.list !== undefined ? (0, _ensureArray["default"])(opts.list) : (0, _ensureArray["default"])(this.options.func.list);

      if (funcs.length === 0) {
        return this;
      }

      var matchFuncs = funcs.map(function (func) {
        return '(?:' + func + ')';
      }).join('|').replace(/\./g, '\\.'); // `\s` matches a single whitespace character, which includes spaces, tabs, form feeds, line feeds and other unicode spaces.

      var matchSpecialCharacters = '[\\r\\n\\s]*';
      var stringGroup = matchSpecialCharacters + '(' + // backtick (``)
      '`(?:[^`\\\\]|\\\\(?:.|$))*`' + '|' + // double quotes ("")
      '"(?:[^"\\\\]|\\\\(?:.|$))*"' + '|' + // single quote ('')
      '\'(?:[^\'\\\\]|\\\\(?:.|$))*\'' + ')' + matchSpecialCharacters;
      var pattern = '(?:(?:^\\s*)|[^a-zA-Z0-9_])' + '(?:' + matchFuncs + ')' + '\\(' + stringGroup + '(?:[\\,]' + stringGroup + ')?' + '[\\,\\)]';
      var re = new RegExp(pattern, 'gim');
      var r;

      var _loop = function _loop() {
        var options = {};
        var full = r[0];

        var key = _this2.fixStringAfterRegExp(r[1], true);

        if (!key) {
          return "continue";
        }

        if (r[2] !== undefined) {
          var defaultValue = _this2.fixStringAfterRegExp(r[2], false);

          if (!defaultValue) {
            return "continue";
          }

          options.defaultValue = defaultValue;
        }

        var endsWithComma = full[full.length - 1] === ',';

        if (endsWithComma) {
          var _opts = _objectSpread({}, opts),
              propsFilter = _opts.propsFilter;

          var code = matchBalancedParentheses(content.substr(re.lastIndex));

          if (typeof propsFilter === 'function') {
            code = propsFilter(code);
          }

          try {
            var syntax = code.trim() !== '' ? (0, _esprima.parse)('(' + code + ')') : {};
            var props = _lodash["default"].get(syntax, 'body[0].expression.properties') || []; // http://i18next.com/docs/options/

            var supportedOptions = ['defaultValue', 'defaultValue_plural', 'count', 'context', 'ns', 'keySeparator', 'nsSeparator'];
            props.forEach(function (prop) {
              if (_lodash["default"].includes(supportedOptions, prop.key.name)) {
                if (prop.value.type === 'Literal') {
                  options[prop.key.name] = prop.value.value;
                } else if (prop.value.type === 'TemplateLiteral') {
                  options[prop.key.name] = prop.value.quasis.map(function (element) {
                    return element.value.cooked;
                  }).join('');
                } else {
                  // Unable to get value of the property
                  options[prop.key.name] = '';
                }
              }
            });
          } catch (err) {
            _this2.error("Unable to parse code \"".concat(code, "\""));

            _this2.error(err);
          }
        }

        if (customHandler) {
          customHandler(key, options);
          return "continue";
        }

        _this2.set(key, options);
      };

      while (r = re.exec(content)) {
        var _ret = _loop();

        if (_ret === "continue") continue;
      }

      return this;
    } // Parses translation keys from `Trans` components in JSX
    // <Trans i18nKey="some.key">Default text</Trans>

  }, {
    key: "parseTransFromString",
    value: function parseTransFromString(content) {
      var _this3 = this;

      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var customHandler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

      if (_lodash["default"].isFunction(opts)) {
        customHandler = opts;
        opts = {};
      }

      var _opts2 = _objectSpread({}, opts),
          _opts2$transformOptio = _opts2.transformOptions,
          transformOptions = _opts2$transformOptio === void 0 ? {} : _opts2$transformOptio,
          _opts2$component = _opts2.component,
          component = _opts2$component === void 0 ? this.options.trans.component : _opts2$component,
          _opts2$i18nKey = _opts2.i18nKey,
          i18nKey = _opts2$i18nKey === void 0 ? this.options.trans.i18nKey : _opts2$i18nKey,
          _opts2$defaultsKey = _opts2.defaultsKey,
          defaultsKey = _opts2$defaultsKey === void 0 ? this.options.trans.defaultsKey : _opts2$defaultsKey,
          fallbackKey = _opts2.fallbackKey,
          _opts2$acorn = _opts2.acorn,
          acornOptions = _opts2$acorn === void 0 ? this.options.trans.acorn : _opts2$acorn;

      var parseJSXElement = function parseJSXElement(node) {
        if (!node) {
          return;
        }

        (0, _ensureArray["default"])(node.openingElement.attributes).forEach(function (attribute) {
          var value = attribute.value;

          if (!(value && value.type === 'JSXExpressionContainer')) {
            return;
          }

          var expression = value.expression;

          if (!(expression && expression.type === 'JSXElement')) {
            return;
          }

          parseJSXElement(expression);
        });
        (0, _ensureArray["default"])(node.children).forEach(function (childNode) {
          if (childNode.type === 'JSXElement') {
            parseJSXElement(childNode);
          }
        });

        if (node.openingElement.name.name !== component) {
          return;
        }

        var attr = (0, _ensureArray["default"])(node.openingElement.attributes).reduce(function (acc, attribute) {
          if (attribute.type !== 'JSXAttribute' || attribute.name.type !== 'JSXIdentifier') {
            return acc;
          }

          var name = attribute.name.name;

          if (attribute.value.type === 'Literal') {
            acc[name] = attribute.value.value;
          } else if (attribute.value.type === 'JSXExpressionContainer') {
            var expression = attribute.value.expression; // Identifier

            if (expression.type === 'Identifier') {
              acc[name] = expression.name;
            } // Literal


            if (expression.type === 'Literal') {
              acc[name] = expression.value;
            } // Object Expression


            if (expression.type === 'ObjectExpression') {
              var properties = (0, _ensureArray["default"])(expression.properties);
              acc[name] = properties.reduce(function (obj, property) {
                if (property.value.type === 'Literal') {
                  obj[property.key.name] = property.value.value;
                } else if (property.value.type === 'TemplateLiteral') {
                  obj[property.key.name] = property.value.quasis.map(function (element) {
                    return element.value.cooked;
                  }).join('');
                } else {
                  // Unable to get value of the property
                  obj[property.key.name] = '';
                }

                return obj;
              }, {});
            } // Template Literal


            if (expression.type === 'TemplateLiteral') {
              acc[name] = expression.quasis.map(function (element) {
                return element.value.cooked;
              }).join('');
            }
          }

          return acc;
        }, {});

        var transKey = _lodash["default"].trim(attr[i18nKey]);

        var defaultsString = attr[defaultsKey] || '';

        if (typeof defaultsString !== 'string') {
          _this3.log("defaults value must be a static string, saw ".concat(_chalk["default"].yellow(defaultsString)));
        } // https://www.i18next.com/translation-function/essentials#overview-options


        var tOptions = attr.tOptions;

        var options = _objectSpread({}, tOptions, {
          defaultValue: defaultsString || (0, _nodesToString["default"])(node.children),
          fallbackKey: fallbackKey || _this3.options.trans.fallbackKey
        });

        if (Object.prototype.hasOwnProperty.call(attr, 'count')) {
          options.count = Number(attr.count) || 0;
        }

        if (Object.prototype.hasOwnProperty.call(attr, 'ns')) {
          if (typeof options.ns !== 'string') {
            _this3.log("The ns attribute must be a string, saw ".concat(_chalk["default"].yellow(attr.ns)));
          }

          options.ns = attr.ns;
        }

        if (customHandler) {
          customHandler(transKey, options);
          return;
        }

        _this3.set(transKey, options);
      };

      try {
        var ast = acorn.Parser.extend(_acornStage["default"], (0, _acornJsx["default"])()).parse(content, _objectSpread({}, defaults.trans.acorn, {}, acornOptions));
        (0, _acornJsxWalk["default"])(ast, {
          JSXElement: parseJSXElement
        });
      } catch (err) {
        if (transformOptions.filepath) {
          this.error("Unable to parse ".concat(_chalk["default"].blue(component), " component from ").concat(_chalk["default"].yellow(JSON.stringify(transformOptions.filepath))));
          console.error('    ' + err);
        } else {
          this.error("Unable to parse ".concat(_chalk["default"].blue(component), " component:"));
          console.error(content);
          console.error('    ' + err);
        }
      }

      return this;
    } // Parses translation keys from `data-i18n` attribute in HTML
    // <div data-i18n="[attr]ns:foo.bar;[attr]ns:foo.baz">
    // </div>

  }, {
    key: "parseAttrFromString",
    value: function parseAttrFromString(content) {
      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var customHandler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
      var setter = this.set.bind(this);

      if (_lodash["default"].isFunction(opts)) {
        setter = opts;
        opts = {};
      } else if (_lodash["default"].isFunction(customHandler)) {
        setter = customHandler;
      }

      var attrs = opts.list !== undefined ? (0, _ensureArray["default"])(opts.list) : (0, _ensureArray["default"])(this.options.attr.list);

      if (attrs.length === 0) {
        return this;
      }

      var ast = _parse["default"].parse(content);

      var parseAttributeValue = function parseAttributeValue(key) {
        key = _lodash["default"].trim(key);

        if (key.length === 0) {
          return;
        }

        if (key.indexOf('[') === 0) {
          var parts = key.split(']');
          key = parts[1];
        }

        if (key.indexOf(';') === key.length - 1) {
          key = key.substr(0, key.length - 2);
        }

        setter(key);
      };

      var walk = function walk(nodes) {
        nodes.forEach(function (node) {
          if (node.attrs) {
            node.attrs.forEach(function (attr) {
              if (attrs.indexOf(attr.name) !== -1) {
                var values = attr.value.split(';');
                values.forEach(parseAttributeValue);
              }
            });
          }

          if (node.childNodes) {
            walk(node.childNodes);
          }

          if (node.content && node.content.childNodes) {
            walk(node.content.childNodes);
          }
        });
      };

      walk(ast.childNodes);
      return this;
    } // Get the value of a translation key or the whole resource store containing translation information
    // @param {string} [key] The translation key
    // @param {object} [opts] The opts object
    // @param {boolean} [opts.sort] True to sort object by key
    // @param {boolean} [opts.lng] The language to use
    // @return {object}

  }, {
    key: "get",
    value: function get(key) {
      var _this4 = this;

      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      if (_lodash["default"].isPlainObject(key)) {
        opts = key;
        key = undefined;
      }

      var resStore = {};

      if (this.options.removeUnusedKeys) {
        // Merge two objects `resStore` and `resScan` deeply, returning a new merged object with the elements from both `resStore` and `resScan`.
        var resMerged = (0, _deepmerge["default"])(this.resStore, this.resScan);
        Object.keys(this.resStore).forEach(function (lng) {
          Object.keys(_this4.resStore[lng]).forEach(function (ns) {
            var resStoreKeys = (0, _flattenObjectKeys["default"])(_lodash["default"].get(_this4.resStore, [lng, ns], {}));
            var resScanKeys = (0, _flattenObjectKeys["default"])(_lodash["default"].get(_this4.resScan, [lng, ns], {}));

            var unusedKeys = _lodash["default"].differenceWith(resStoreKeys, resScanKeys, _lodash["default"].isEqual);

            for (var i = 0; i < unusedKeys.length; ++i) {
              _lodash["default"].unset(resMerged[lng][ns], unusedKeys[i]);

              _this4.log("Removed an unused translation key { ".concat(_chalk["default"].red(JSON.stringify(unusedKeys[i])), " from ").concat(_chalk["default"].red(JSON.stringify(_this4.formatResourceLoadPath(lng, ns)))));
            } // Omit empty object


            resMerged[lng][ns] = (0, _omitEmptyObject["default"])(resMerged[lng][ns]);
          });
        });
        resStore = resMerged;
      } else {
        resStore = (0, _cloneDeep["default"])(this.resStore);
      }

      if (opts.sort) {
        Object.keys(resStore).forEach(function (lng) {
          var namespaces = resStore[lng];
          Object.keys(namespaces).forEach(function (ns) {
            // Deeply sort an object by its keys without mangling any arrays inside of it
            resStore[lng][ns] = (0, _sortobject["default"])(namespaces[ns]);
          });
        });
      }

      if (!_lodash["default"].isUndefined(key)) {
        var ns = this.options.defaultNs; // http://i18next.com/translate/keyBasedFallback/
        // Set nsSeparator and keySeparator to false if you prefer
        // having keys as the fallback for translation.
        // i18next.init({
        //   nsSeparator: false,
        //   keySeparator: false
        // })

        if (_lodash["default"].isString(this.options.nsSeparator) && key.indexOf(this.options.nsSeparator) > -1) {
          var parts = key.split(this.options.nsSeparator);
          ns = parts[0];
          key = parts[1];
        }

        var keys = _lodash["default"].isString(this.options.keySeparator) ? key.split(this.options.keySeparator) : [key];
        var lng = opts.lng ? opts.lng : this.options.fallbackLng;
        var namespaces = resStore[lng] || {};
        var value = namespaces[ns];
        var x = 0;

        while (keys[x]) {
          value = value && value[keys[x]];
          x++;
        }

        return value;
      }

      return resStore;
    } // Set translation key with an optional defaultValue to i18n resource store
    // @param {string} key The translation key
    // @param {object} [options] The options object
    // @param {boolean|function} [options.fallbackKey] When the key is missing, pass `true` to return `options.defaultValue` as key, or pass a function to return user-defined key.
    // @param {string} [options.defaultValue] defaultValue to return if translation not found
    // @param {number} [options.count] count value used for plurals
    // @param {string} [options.context] used for contexts (eg. male)
    // @param {string} [options.ns] namespace for the translation
    // @param {string|boolean} [options.nsSeparator] The value used to override this.options.nsSeparator
    // @param {string|boolean} [options.keySeparator] The value used to override this.options.keySeparator

  }, {
    key: "set",
    value: function set(key) {
      var _this5 = this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      // Backward compatibility
      if (_lodash["default"].isString(options)) {
        var _defaultValue = options;
        options = {
          defaultValue: _defaultValue
        };
      }

      var nsSeparator = options.nsSeparator !== undefined ? options.nsSeparator : this.options.nsSeparator;
      var keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
      var ns = options.ns || this.options.defaultNs;
      console.assert(_lodash["default"].isString(ns) && !!ns.length, 'ns is not a valid string', ns); // http://i18next.com/translate/keyBasedFallback/
      // Set nsSeparator and keySeparator to false if you prefer
      // having keys as the fallback for translation.
      // i18next.init({
      //   nsSeparator: false,
      //   keySeparator: false
      // })

      if (_lodash["default"].isString(nsSeparator) && key.indexOf(nsSeparator) > -1) {
        var parts = key.split(nsSeparator);
        ns = parts[0];
        key = parts[1];
      }

      var keys = [];

      if (key) {
        keys = _lodash["default"].isString(keySeparator) ? key.split(keySeparator) : [key];
      } else {
        // fallback key
        if (options.fallbackKey === true) {
          key = options.defaultValue;
        }

        if (typeof options.fallbackKey === 'function') {
          key = options.fallbackKey(ns, options.defaultValue);
        }

        if (!key) {
          // Ignore empty key
          return;
        }

        keys = [key];
      }

      var _this$options = this.options,
          lngs = _this$options.lngs,
          context = _this$options.context,
          contextFallback = _this$options.contextFallback,
          contextSeparator = _this$options.contextSeparator,
          contextDefaultValues = _this$options.contextDefaultValues,
          plural = _this$options.plural,
          pluralFallback = _this$options.pluralFallback,
          pluralSeparator = _this$options.pluralSeparator,
          defaultLng = _this$options.defaultLng,
          defaultValue = _this$options.defaultValue;
      lngs.forEach(function (lng) {
        var resLoad = _this5.resStore[lng] && _this5.resStore[lng][ns];
        var resScan = _this5.resScan[lng] && _this5.resScan[lng][ns];

        if (!_lodash["default"].isPlainObject(resLoad)) {
          // Skip undefined namespace
          _this5.error("".concat(_chalk["default"].yellow(JSON.stringify(ns)), " does not exist in the namespaces (").concat(_chalk["default"].yellow(JSON.stringify(_this5.options.ns)), "): key=").concat(_chalk["default"].yellow(JSON.stringify(key)), ", options=").concat(_chalk["default"].yellow(JSON.stringify(options))));

          return;
        }

        Object.keys(keys).forEach(function (index) {
          var key = keys[index];

          if (index < keys.length - 1) {
            resLoad[key] = resLoad[key] || {};
            resLoad = resLoad[key];
            resScan[key] = resScan[key] || {};
            resScan = resScan[key];
            return; // continue
          } // Context & Plural
          // http://i18next.com/translate/context/
          // http://i18next.com/translate/pluralSimple/
          //
          // Format:
          // "<key>[[{{contextSeparator}}<context>]{{pluralSeparator}}<plural>]"
          //
          // Example:
          // {
          //   "translation": {
          //     "friend": "A friend",
          //     "friend_male": "A boyfriend",
          //     "friend_female": "A girlfriend",
          //     "friend_male_plural": "{{count}} boyfriends",
          //     "friend_female_plural": "{{count}} girlfriends"
          //   }
          // }


          var resKeys = []; // http://i18next.com/translate/context/

          var containsContext = function () {
            if (!context) {
              return false;
            }

            if (_lodash["default"].isUndefined(options.context)) {
              return false;
            }

            return _lodash["default"].isFunction(context) ? context(lng, ns, key, options) : !!context;
          }(); // http://i18next.com/translate/pluralSimple/


          var containsPlural = function () {
            if (!plural) {
              return false;
            }

            if (_lodash["default"].isUndefined(options.count)) {
              return false;
            }

            return _lodash["default"].isFunction(plural) ? plural(lng, ns, key, options) : !!plural;
          }();

          var contextValues = function () {
            if (options.context !== '') {
              return [options.context];
            }

            if ((0, _ensureArray["default"])(contextDefaultValues).length > 0) {
              return (0, _ensureArray["default"])(contextDefaultValues);
            }

            return [];
          }();

          if (containsPlural) {
            var suffixes = pluralFallback ? _this5.pluralSuffixes[lng] : _this5.pluralSuffixes[lng].slice(1);
            suffixes.forEach(function (pluralSuffix) {
              resKeys.push("".concat(key).concat(pluralSuffix));
            });

            if (containsContext && containsPlural) {
              suffixes.forEach(function (pluralSuffix) {
                contextValues.forEach(function (contextValue) {
                  resKeys.push("".concat(key).concat(contextSeparator).concat(contextValue).concat(pluralSuffix));
                });
              });
            }
          } else {
            if (!containsContext || containsContext && contextFallback) {
              resKeys.push(key);
            }

            if (containsContext) {
              contextValues.forEach(function (contextValue) {
                resKeys.push("".concat(key).concat(contextSeparator).concat(contextValue));
              });
            }
          }

          resKeys.forEach(function (resKey) {
            if (resLoad[resKey] === undefined) {
              if (options.defaultValue_plural !== undefined && resKey.endsWith("".concat(pluralSeparator, "plural"))) {
                resLoad[resKey] = options.defaultValue_plural;
              } else {
                // Fallback to `defaultValue`
                resLoad[resKey] = _lodash["default"].isFunction(defaultValue) ? defaultValue(lng, ns, key, options) : options.defaultValue || defaultValue;
              }

              _this5.log("Added a new translation key { ".concat(_chalk["default"].yellow(JSON.stringify(resKey)), ": ").concat(_chalk["default"].yellow(JSON.stringify(resLoad[resKey])), " } to ").concat(_chalk["default"].yellow(JSON.stringify(_this5.formatResourceLoadPath(lng, ns)))));
            } else if (options.defaultValue && (!options.defaultValue_plural || !resKey.endsWith("".concat(pluralSeparator, "plural")))) {
              if (!resLoad[resKey]) {
                // Use `options.defaultValue` if specified
                resLoad[resKey] = options.defaultValue;
              } else if (resLoad[resKey] !== options.defaultValue && lng === defaultLng) {
                // A default value has provided but it's different with the expected default
                _this5.log("The translation key ".concat(_chalk["default"].yellow(JSON.stringify(resKey)), " has a different default value, you may need to check the translation key of default language (").concat(defaultLng, ")"));
              }
            } else if (options.defaultValue_plural && resKey.endsWith("".concat(pluralSeparator, "plural"))) {
              if (!resLoad[resKey]) {
                // Use `options.defaultValue_plural` if specified
                resLoad[resKey] = options.defaultValue_plural;
              } else if (resLoad[resKey] !== options.defaultValue_plural && lng === defaultLng) {
                // A default value has provided but it's different with the expected default
                _this5.log("The translation key ".concat(_chalk["default"].yellow(JSON.stringify(resKey)), " has a different default value, you may need to check the translation key of default language (").concat(defaultLng, ")"));
              }
            }

            resScan[resKey] = resLoad[resKey];
          });
        });
      });
    } // Returns a JSON string containing translation information
    // @param {object} [options] The options object
    // @param {boolean} [options.sort] True to sort object by key
    // @param {function|string[]|number[]} [options.replacer] The same as the JSON.stringify()
    // @param {string|number} [options.space] The same as the JSON.stringify() method
    // @return {string}

  }, {
    key: "toJSON",
    value: function toJSON() {
      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var replacer = options.replacer,
          space = options.space,
          others = _objectWithoutProperties(options, ["replacer", "space"]);

      return JSON.stringify(this.get(others), replacer, space);
    }
  }]);

  return Parser;
}();

_i18next["default"].init();

var _default = Parser;
exports["default"] = _default;