text: "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 _ensureArray3 = _interopRequireDefault(require("ensure-array"));
  
  var _esprima = require("esprima");
  
  var _lodash = _interopRequireDefault(require("lodash"));
  
  var _acornOptionalChaining = _interopRequireDefault(require("acorn-optional-chaining"));
  
  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
    contextList: {
      'default': {
        list: [],
        fallback: true,
        separator: true
      }
    },
    // all valid 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(_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, _ensureArray3["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(/\${.*?}/)) {
          if (fixedString.endsWith('}`')) {
            fixedString = fixedString.replace(/\$\{(.+?)\}/g, "");
          } else {
            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, _ensureArray3["default"])(opts.list) : (0, _ensureArray3["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', 'contextList', '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, _ensureArray3["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, _ensureArray3["default"])(node.children).forEach(function (childNode) {
            if (childNode.type === 'JSXElement') {
              parseJSXElement(childNode);
            }
          });
  
          if (node.openingElement.name.name !== component) {
            return;
          }
  
          var attr = (0, _ensureArray3["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, _ensureArray3["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(_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"], _acornOptionalChaining["default"], (0, _acornJsx["default"])()).parse(content, _objectSpread(_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, _ensureArray3["default"])(opts.list) : (0, _ensureArray3["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 {object} [options.contextList] used for informing 18next-scanner of all correct contexts
      // @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,
            contextList = _this$options.contextList,
            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 _validContextList$sep, _validContextList$fal;
  
            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 () {
              var _ensureArray, _contextList$options$;
  
              if (((_ensureArray = (0, _ensureArray3["default"])(contextList === null || contextList === void 0 ? void 0 : (_contextList$options$ = contextList[options.contextList]) === null || _contextList$options$ === void 0 ? void 0 : _contextList$options$.list)) === null || _ensureArray === void 0 ? void 0 : _ensureArray.length) > 0) {
                return true;
              }
  
              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 () {
              var _ensureArray2, _contextList$options$2;
  
              if (((_ensureArray2 = (0, _ensureArray3["default"])(contextList === null || contextList === void 0 ? void 0 : (_contextList$options$2 = contextList[options.contextList]) === null || _contextList$options$2 === void 0 ? void 0 : _contextList$options$2.list)) === null || _ensureArray2 === void 0 ? void 0 : _ensureArray2.length) > 0) {
                var _contextList$options$3;
  
                return (0, _ensureArray3["default"])((_contextList$options$3 = contextList[options.contextList]) === null || _contextList$options$3 === void 0 ? void 0 : _contextList$options$3.list);
              }
  
              if (options.context !== '') {
                return [options.context];
              }
  
              if ((0, _ensureArray3["default"])(contextDefaultValues).length > 0) {
                return (0, _ensureArray3["default"])(contextDefaultValues);
              }
  
              return [];
            }();
  
            var validContextList = contextList === null || contextList === void 0 ? void 0 : contextList[options.contextList];
            var contextListSeparator = ((_validContextList$sep = validContextList === null || validContextList === void 0 ? void 0 : validContextList.separator) !== null && _validContextList$sep !== void 0 ? _validContextList$sep : contextSeparator) ? contextSeparator : '';
            var contextListFallback = (_validContextList$fal = validContextList === null || validContextList === void 0 ? void 0 : validContextList.fallback) !== null && _validContextList$fal !== void 0 ? _validContextList$fal : contextFallback;
  
            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(contextListSeparator).concat(contextValue).concat(pluralSuffix));
                  });
                });
              }
            } else {
              if (!containsContext || containsContext && contextListFallback) {
                resKeys.push(key);
              }
  
              if (containsContext) {
                contextValues.forEach(function (contextValue) {
                  resKeys.push("".concat(key).concat(contextListSeparator).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;