'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var i18next = require('i18next');
var ramda = require('ramda');
var reactI18next = require('react-i18next');
var initializers_constants = require('./constants.js');
var initializers_utils_customFormatters = require('./utils/customFormatters.js');
var initializers_utils_customPostProcessors = require('./utils/customPostProcessors.js');
var initializers_utils_utils = require('./utils/utils.js');
require('dompurify');
require('../typeof-D4ZZ_FlZ.js');
require('../slicedToArray-BcL7fKuL.js');
require('../unsupportedIterableToArray-BoHMiKNA.js');

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

function _typeof(o) {
  "@babel/helpers - typeof";

  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
    return typeof o;
  } : function (o) {
    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
  }, _typeof(o);
}

function toPrimitive(t, r) {
  if ("object" != _typeof(t) || !t) return t;
  var e = t[Symbol.toPrimitive];
  if (void 0 !== e) {
    var i = e.call(t, r);
    if ("object" != _typeof(i)) return i;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (String )(t);
}

function toPropertyKey(t) {
  var i = toPrimitive(t, "string");
  return "symbol" == _typeof(i) ? i : i + "";
}

function _defineProperties(e, r) {
  for (var t = 0; t < r.length; t++) {
    var o = r[t];
    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey(o.key), o);
  }
}
function _createClass(e, r, t) {
  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
    writable: false
  }), e;
}

var arr = [];
var each = arr.forEach;
var slice = arr.slice;
function defaults(obj) {
  each.call(slice.call(arguments, 1), function (source) {
    if (source) {
      for (var prop in source) {
        if (obj[prop] === undefined) obj[prop] = source[prop];
      }
    }
  });
  return obj;
}

// eslint-disable-next-line no-control-regex
var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
var serializeCookie = function serializeCookie(name, val, options) {
  var opt = options || {};
  opt.path = opt.path || '/';
  var value = encodeURIComponent(val);
  var str = "".concat(name, "=").concat(value);
  if (opt.maxAge > 0) {
    var maxAge = opt.maxAge - 0;
    if (Number.isNaN(maxAge)) throw new Error('maxAge should be a Number');
    str += "; Max-Age=".concat(Math.floor(maxAge));
  }
  if (opt.domain) {
    if (!fieldContentRegExp.test(opt.domain)) {
      throw new TypeError('option domain is invalid');
    }
    str += "; Domain=".concat(opt.domain);
  }
  if (opt.path) {
    if (!fieldContentRegExp.test(opt.path)) {
      throw new TypeError('option path is invalid');
    }
    str += "; Path=".concat(opt.path);
  }
  if (opt.expires) {
    if (typeof opt.expires.toUTCString !== 'function') {
      throw new TypeError('option expires is invalid');
    }
    str += "; Expires=".concat(opt.expires.toUTCString());
  }
  if (opt.httpOnly) str += '; HttpOnly';
  if (opt.secure) str += '; Secure';
  if (opt.sameSite) {
    var sameSite = typeof opt.sameSite === 'string' ? opt.sameSite.toLowerCase() : opt.sameSite;
    switch (sameSite) {
      case true:
        str += '; SameSite=Strict';
        break;
      case 'lax':
        str += '; SameSite=Lax';
        break;
      case 'strict':
        str += '; SameSite=Strict';
        break;
      case 'none':
        str += '; SameSite=None';
        break;
      default:
        throw new TypeError('option sameSite is invalid');
    }
  }
  return str;
};
var cookie = {
  create: function create(name, value, minutes, domain) {
    var cookieOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
      path: '/',
      sameSite: 'strict'
    };
    if (minutes) {
      cookieOptions.expires = new Date();
      cookieOptions.expires.setTime(cookieOptions.expires.getTime() + minutes * 60 * 1000);
    }
    if (domain) cookieOptions.domain = domain;
    document.cookie = serializeCookie(name, encodeURIComponent(value), cookieOptions);
  },
  read: function read(name) {
    var nameEQ = "".concat(name, "=");
    var ca = document.cookie.split(';');
    for (var i = 0; i < ca.length; i++) {
      var c = ca[i];
      while (c.charAt(0) === ' ') c = c.substring(1, c.length);
      if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);
    }
    return null;
  },
  remove: function remove(name) {
    this.create(name, '', -1);
  }
};
var cookie$1 = {
  name: 'cookie',
  lookup: function lookup(options) {
    var found;
    if (options.lookupCookie && typeof document !== 'undefined') {
      var c = cookie.read(options.lookupCookie);
      if (c) found = c;
    }
    return found;
  },
  cacheUserLanguage: function cacheUserLanguage(lng, options) {
    if (options.lookupCookie && typeof document !== 'undefined') {
      cookie.create(options.lookupCookie, lng, options.cookieMinutes, options.cookieDomain, options.cookieOptions);
    }
  }
};

var querystring = {
  name: 'querystring',
  lookup: function lookup(options) {
    var found;
    if (typeof window !== 'undefined') {
      var search = window.location.search;
      if (!window.location.search && window.location.hash && window.location.hash.indexOf('?') > -1) {
        search = window.location.hash.substring(window.location.hash.indexOf('?'));
      }
      var query = search.substring(1);
      var params = query.split('&');
      for (var i = 0; i < params.length; i++) {
        var pos = params[i].indexOf('=');
        if (pos > 0) {
          var key = params[i].substring(0, pos);
          if (key === options.lookupQuerystring) {
            found = params[i].substring(pos + 1);
          }
        }
      }
    }
    return found;
  }
};

var hasLocalStorageSupport = null;
var localStorageAvailable = function localStorageAvailable() {
  if (hasLocalStorageSupport !== null) return hasLocalStorageSupport;
  try {
    hasLocalStorageSupport = window !== 'undefined' && window.localStorage !== null;
    var testKey = 'i18next.translate.boo';
    window.localStorage.setItem(testKey, 'foo');
    window.localStorage.removeItem(testKey);
  } catch (e) {
    hasLocalStorageSupport = false;
  }
  return hasLocalStorageSupport;
};
var localStorage = {
  name: 'localStorage',
  lookup: function lookup(options) {
    var found;
    if (options.lookupLocalStorage && localStorageAvailable()) {
      var lng = window.localStorage.getItem(options.lookupLocalStorage);
      if (lng) found = lng;
    }
    return found;
  },
  cacheUserLanguage: function cacheUserLanguage(lng, options) {
    if (options.lookupLocalStorage && localStorageAvailable()) {
      window.localStorage.setItem(options.lookupLocalStorage, lng);
    }
  }
};

var hasSessionStorageSupport = null;
var sessionStorageAvailable = function sessionStorageAvailable() {
  if (hasSessionStorageSupport !== null) return hasSessionStorageSupport;
  try {
    hasSessionStorageSupport = window !== 'undefined' && window.sessionStorage !== null;
    var testKey = 'i18next.translate.boo';
    window.sessionStorage.setItem(testKey, 'foo');
    window.sessionStorage.removeItem(testKey);
  } catch (e) {
    hasSessionStorageSupport = false;
  }
  return hasSessionStorageSupport;
};
var sessionStorage = {
  name: 'sessionStorage',
  lookup: function lookup(options) {
    var found;
    if (options.lookupSessionStorage && sessionStorageAvailable()) {
      var lng = window.sessionStorage.getItem(options.lookupSessionStorage);
      if (lng) found = lng;
    }
    return found;
  },
  cacheUserLanguage: function cacheUserLanguage(lng, options) {
    if (options.lookupSessionStorage && sessionStorageAvailable()) {
      window.sessionStorage.setItem(options.lookupSessionStorage, lng);
    }
  }
};

var navigator$1 = {
  name: 'navigator',
  lookup: function lookup(options) {
    var found = [];
    if (typeof navigator !== 'undefined') {
      if (navigator.languages) {
        // chrome only; not an array, so can't use .push.apply instead of iterating
        for (var i = 0; i < navigator.languages.length; i++) {
          found.push(navigator.languages[i]);
        }
      }
      if (navigator.userLanguage) {
        found.push(navigator.userLanguage);
      }
      if (navigator.language) {
        found.push(navigator.language);
      }
    }
    return found.length > 0 ? found : undefined;
  }
};

var htmlTag = {
  name: 'htmlTag',
  lookup: function lookup(options) {
    var found;
    var htmlTag = options.htmlTag || (typeof document !== 'undefined' ? document.documentElement : null);
    if (htmlTag && typeof htmlTag.getAttribute === 'function') {
      found = htmlTag.getAttribute('lang');
    }
    return found;
  }
};

var path = {
  name: 'path',
  lookup: function lookup(options) {
    var found;
    if (typeof window !== 'undefined') {
      var language = window.location.pathname.match(/\/([a-zA-Z-]*)/g);
      if (language instanceof Array) {
        if (typeof options.lookupFromPathIndex === 'number') {
          if (typeof language[options.lookupFromPathIndex] !== 'string') {
            return undefined;
          }
          found = language[options.lookupFromPathIndex].replace('/', '');
        } else {
          found = language[0].replace('/', '');
        }
      }
    }
    return found;
  }
};

var subdomain = {
  name: 'subdomain',
  lookup: function lookup(options) {
    // If given get the subdomain index else 1
    var lookupFromSubdomainIndex = typeof options.lookupFromSubdomainIndex === 'number' ? options.lookupFromSubdomainIndex + 1 : 1;
    // get all matches if window.location. is existing
    // first item of match is the match itself and the second is the first group macht which sould be the first subdomain match
    // is the hostname no public domain get the or option of localhost
    var language = typeof window !== 'undefined' && window.location && window.location.hostname && window.location.hostname.match(/^(\w{2,5})\.(([a-z0-9-]{1,63}\.[a-z]{2,6})|localhost)/i);

    // if there is no match (null) return undefined
    if (!language) return undefined;
    // return the given group match
    return language[lookupFromSubdomainIndex];
  }
};

// some environments, throws when accessing document.cookie
var canCookies = false;
try {
  // eslint-disable-next-line no-unused-expressions
  document.cookie;
  canCookies = true;
  // eslint-disable-next-line no-empty
} catch (e) {}
var order = ['querystring', 'cookie', 'localStorage', 'sessionStorage', 'navigator', 'htmlTag'];
if (!canCookies) order.splice(1, 1);
function getDefaults() {
  return {
    order: order,
    lookupQuerystring: 'lng',
    lookupCookie: 'i18next',
    lookupLocalStorage: 'i18nextLng',
    lookupSessionStorage: 'i18nextLng',
    // cache user language
    caches: ['localStorage'],
    excludeCacheFor: ['cimode'],
    // cookieMinutes: 10,
    // cookieDomain: 'myDomain'

    convertDetectedLanguage: function convertDetectedLanguage(l) {
      return l;
    }
  };
}
var Browser = /*#__PURE__*/function () {
  function Browser(services) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    _classCallCheck(this, Browser);
    this.type = 'languageDetector';
    this.detectors = {};
    this.init(services, options);
  }
  return _createClass(Browser, [{
    key: "init",
    value: function init(services) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var i18nOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
      this.services = services || {
        languageUtils: {}
      }; // this way the language detector can be used without i18next
      this.options = defaults(options, this.options || {}, getDefaults());
      if (typeof this.options.convertDetectedLanguage === 'string' && this.options.convertDetectedLanguage.indexOf('15897') > -1) {
        this.options.convertDetectedLanguage = function (l) {
          return l.replace('-', '_');
        };
      }

      // backwards compatibility
      if (this.options.lookupFromUrlIndex) this.options.lookupFromPathIndex = this.options.lookupFromUrlIndex;
      this.i18nOptions = i18nOptions;
      this.addDetector(cookie$1);
      this.addDetector(querystring);
      this.addDetector(localStorage);
      this.addDetector(sessionStorage);
      this.addDetector(navigator$1);
      this.addDetector(htmlTag);
      this.addDetector(path);
      this.addDetector(subdomain);
    }
  }, {
    key: "addDetector",
    value: function addDetector(detector) {
      this.detectors[detector.name] = detector;
      return this;
    }
  }, {
    key: "detect",
    value: function detect(detectionOrder) {
      var _this = this;
      if (!detectionOrder) detectionOrder = this.options.order;
      var detected = [];
      detectionOrder.forEach(function (detectorName) {
        if (_this.detectors[detectorName]) {
          var lookup = _this.detectors[detectorName].lookup(_this.options);
          if (lookup && typeof lookup === 'string') lookup = [lookup];
          if (lookup) detected = detected.concat(lookup);
        }
      });
      detected = detected.map(function (d) {
        return _this.options.convertDetectedLanguage(d);
      });
      if (this.services.languageUtils.getBestMatchFromCodes) return detected; // new i18next v19.5.0
      return detected.length > 0 ? detected[0] : null; // a little backward compatibility
    }
  }, {
    key: "cacheUserLanguage",
    value: function cacheUserLanguage(lng, caches) {
      var _this2 = this;
      if (!caches) caches = this.options.caches;
      if (!caches) return;
      if (this.options.excludeCacheFor && this.options.excludeCacheFor.indexOf(lng) > -1) return;
      caches.forEach(function (cacheName) {
        if (_this2.detectors[cacheName]) _this2.detectors[cacheName].cacheUserLanguage(lng, _this2.options);
      });
    }
  }]);
}();
Browser.type = 'languageDetector';

var generic = {
	error: "Something went wrong. Please try again later."
};
var authentication = {
	notLoggedIn: "Could not authenticate, please login to continue!",
	couldNotAuth: "Could not authenticate with the provided {{parameter}}.",
	incorrectPassword: "Current password is incorrect. Please try again.",
	incorrectEmailPassword: "Incorrect email or password. Please try again."
};
var authorization = {
	unauthorized: "You are not authorized to perform this action."
};
var resource = {
	add_one: "{{entity}} has been added successfully.",
	add_other: "{{entity}} have been added successfully.",
	save: "{{entity}} has been saved successfully.",
	save_one: "{{entity}} has been saved successfully.",
	save_other: "{{entity}} have been saved successfully.",
	update: "{{entity}} has been updated successfully.",
	update_one: "{{entity}} has been updated successfully.",
	update_other: "{{entity}} have been updated successfully.",
	delete_one: "{{entity}} has been deleted successfully.",
	delete_other: "{{entity}} have been deleted successfully.",
	clone: "{{entity}} has been cloned successfully.",
	notFound: "{{entity}} does not exist.",
	remove_one: "{{entity}} has been removed successfully.",
	remove_other: "{{entity}} have been removed successfully.",
	sent: "{{entity}} sent successfully.",
	merged: "{{entity}} have been successfully merged.",
	disconnected: "{{entity}} has been successfully disconnected."
};
var otp = {
	sent: "OTP has been sent successfully.",
	invalid: "Invalid OTP",
	verified: "OTP has been verified successfully."
};
var upload = {
	error: "An error occurred while uploading the file"
};
var image = {
	profile: {
		removalFailed: "Failed to remove profile picture",
		removalSuccess: "Profile picture successfully removed"
	},
	contentTypeInvalid: "Other than jpg, png, svg are not supported",
	sizeOutOfRange: "Should not be more than {{maxSize, number}} MB"
};
var userRole = {
	deactivateActiveAdmin: "You cannot deactivate active admin from the workspace!"
};
var activeRecord = {
	error: {
		blankName: "Name can't be blank",
		blankDescription: "Description can't be blank",
		blankValue: "Value can't be blank",
		prefixType: "Prefix type {{value}} is not valid",
		minimumEntryLimit: "Minimum entry limit must be less than or equal to {{maximumEntryLimit, number}}",
		maximumEntryLimit: "Maximum entry limit must be greater than or equal to {{minimumEntryLimit, number}}"
	}
};
var sessions = {
	expiry: "Your session has expired. Please login again."
};
var payment = {
	error: {
		incomplete: "Your payment could not be completed"
	}
};
var invitations = {
	deleted_one: "Invitation has been deleted successfully",
	deleted_other: "{{count, number}} Invitations have been deleted successfully",
	sent_one: "Invitation has been sent successfully",
	sent_other: "{{count, number}} Invitations have been sent successfully",
	notFound: "{{email}} was not invited to test this website."
};
var github = {
	error: {
		webhookPermissionDenied: "Permission denied. Ensure you have permission to create webhooks for the repository.",
		primaryNonDeletable: "Primary Github account cannot be deleted."
	}
};
var neetoCommons = {
	fallbackComponent: {
		somethingWentWrong: "Sorry, something went wrong.",
		description: "Please try <reloading>reloading</reloading> the page.<br> If the problem persists, <contactus>contact us</contactus>."
	},
	toastr: {
		success: {
			copiedToClipboard: "Copied to clipboard!"
		},
		error: {
			noInternetConnection: "No Internet Connection.",
			networkError: "Network error. Please check your connection and try again."
		}
	},
	notice: {
		errorOccurred: "Some error occurred."
	},
	validators: {
		isRequired: "{{what}} is required.",
		mustNotContainCapitalLetters: "{{what}} must not contain capital letters.",
		mustNotContainSpaces: "{{what}} must not contain spaces.",
		mustNotContainSpecialCharactersExceptHyphen: "{{what}} must not contain any special characters, except '-'",
		mustNotStartOrEndWithSpecialCharacters: "{{what}} must not start or end with special characters."
	},
	copyToClipboard: {
		failed: "Failed to copy to clipboard"
	}
};
var commonsEn = {
	generic: generic,
	authentication: authentication,
	authorization: authorization,
	resource: resource,
	otp: otp,
	upload: upload,
	image: image,
	userRole: userRole,
	activeRecord: activeRecord,
	sessions: sessions,
	payment: payment,
	invitations: invitations,
	github: github,
	neetoCommons: neetoCommons
};

// eslint-disable-next-line import/no-mutable-exports
exports.taxonomies = {};
var initializeI18n = function initializeI18n(hostTranslations) {
  var _window$globalProps, _window$globalProps2;
  document.documentElement.removeAttribute("lang");
  var userLanguage = (_window$globalProps = window.globalProps) === null || _window$globalProps === void 0 || (_window$globalProps = _window$globalProps.user) === null || _window$globalProps === void 0 ? void 0 : _window$globalProps.language;
  if (userLanguage) document.documentElement.setAttribute("lang", userLanguage);
  var packageTranslations = preval.require("../../../configs/scripts/getPkgTranslations.js");
  var commonsTranslations = {
    en: {
      translation: commonsEn
    }
  };
  var resources = [hostTranslations, commonsTranslations, packageTranslations].reduce(ramda.mergeDeepLeft);
  var defaultTaxonomyKeys = Object.keys(resources.en.translation.taxonomyDefaultLabels || {});
  var defaultTaxonomies = Object.fromEntries(defaultTaxonomyKeys.map(function (key) {
    return [key, {
      singular: null,
      plural: null
    }];
  }));
  var hostTaxonomies = ((_window$globalProps2 = window.globalProps) === null || _window$globalProps2 === void 0 ? void 0 : _window$globalProps2.taxonomies) || {};
  exports.taxonomies = initializers_utils_utils.replaceNullValuesWithGetter(ramda.mergeDeepLeft(hostTaxonomies, defaultTaxonomies));
  i18next.use(Browser).use(reactI18next.initReactI18next).use(initializers_utils_customPostProcessors.sentenceCaseProcessor).init({
    resources: resources,
    fallbackLng: "en",
    interpolation: {
      defaultVariables: {
        taxonomies: exports.taxonomies
      },
      escapeValue: false,
      skipOnVariables: false,
      alwaysFormat: true,
      format: function format(value, _format, lng, options) {
        var newValue = value;
        if (initializers_constants.LIST_FORMATS.includes(_format)) {
          newValue = initializers_utils_customFormatters.listFormatter({
            value: newValue,
            format: _format,
            lng: lng,
            options: options
          });
          return newValue;
        }
        return initializers_utils_customFormatters.lowerCaseDynamicTextFormatter(newValue, _format);
      }
    },
    postProcess: [initializers_utils_customPostProcessors.sentenceCaseProcessor.name],
    detection: {
      order: ["querystring", "htmlTag", "navigator", "cookie"],
      caches: ["cookie"],
      lookupQuerystring: "lang",
      lookupCookie: "lang"
    }
  });
  if (!userLanguage) {
    document.documentElement.setAttribute("lang", i18next.resolvedLanguage || "en");
  }
};

exports.default = initializeI18n;
//# sourceMappingURL=i18n.js.map
