i18next / i18next / 19837025733

export const isString = (obj) => typeof obj === 'string';

// http://lea.verou.me/2016/12/resolve-promises-externally-with-this-one-weird-trick/

export const defer = () => {

  let res;

  let rej;

  const promise = new Promise((resolve, reject) => {

    res = resolve;

    rej = reject;

  });

  promise.resolve = res;

  promise.reject = rej;

  return promise;

};

export const makeString = (object) => {

  if (object == null) return '';

  /* eslint prefer-template: 0 */

  return '' + object;

};

export const copy = (a, s, t) => {

  a.forEach((m) => {

    if (s[m]) t[m] = s[m];

  });

};

// We extract out the RegExp definition to improve performance with React Native Android, which has poor RegExp

// initialization performance

const lastOfPathSeparatorRegExp = /###/g;

const cleanKey = (key) =>

const canNotTraverseDeeper = (object) => !object || isString(object);

const getLastOfPath = (object, path, Empty) => {

  const stack = !isString(path) ? path : path.split('.');

  let stackIndex = 0;

  // iterate through the stack, but leave the last item

  while (stackIndex < stack.length - 1) {

    if (canNotTraverseDeeper(object)) return {};

    const key = cleanKey(stack[stackIndex]);

    if (!object[key] && Empty) object[key] = new Empty();

    // prevent prototype pollution

    if (Object.prototype.hasOwnProperty.call(object, key)) {

      object = object[key];

    } else {

      object = {};

    }

    ++stackIndex;

  }

  if (canNotTraverseDeeper(object)) return {};

  return {

    obj: object,

    k: cleanKey(stack[stackIndex]),

  };

};

export const setPath = (object, path, newValue) => {

  const { obj, k } = getLastOfPath(object, path, Object);

  if (obj !== undefined || path.length === 1) {

    obj[k] = newValue;

    return;

  }

  let e = path[path.length - 1];

  let p = path.slice(0, path.length - 1);

  let last = getLastOfPath(object, p, Object);

  while (last.obj === undefined && p.length) {

    e = `${p[p.length - 1]}.${e}`;

    p = p.slice(0, p.length - 1);

    last = getLastOfPath(object, p, Object);

  }

  last.obj[`${last.k}.${e}`] = newValue;

};

export const pushPath = (object, path, newValue, concat) => {

  const { obj, k } = getLastOfPath(object, path, Object);

  obj[k] = obj[k] || [];

  if (!concat) obj[k].push(newValue);

};

export const getPath = (object, path) => {

  const { obj, k } = getLastOfPath(object, path);

  if (!obj) return undefined;

  if (!Object.prototype.hasOwnProperty.call(obj, k)) return undefined;

  return obj[k];

};

export const getPathWithDefaults = (data, defaultData, key) => {

  const value = getPath(data, key);

  if (value !== undefined) {

    return value;

  }

  // Fallback to default values

  return getPath(defaultData, key);

};

export const deepExtend = (target, source, overwrite) => {

  /* eslint no-restricted-syntax: 0 */

  for (const prop in source) {

    if (prop !== '__proto__' && prop !== 'constructor') {

      if (prop in target) {

        // If we reached a leaf string in target or source then replace with source or skip depending on the 'overwrite' switch

        if (

          isString(target[prop]) ||

          target[prop] instanceof String ||

          isString(source[prop]) ||

          source[prop] instanceof String

        ) {

          if (overwrite) target[prop] = source[prop];

        } else {

          deepExtend(target[prop], source[prop], overwrite);

        }

      } else {

        target[prop] = source[prop];

      }

    }

  }

  return target;

};

export const regexEscape = (str) =>

  /* eslint no-useless-escape: 0 */

  str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');

/* eslint-disable */

var _entityMap = {

  '&': '&',

  '<': '&lt;',

  '>': '>',

  '"': '"',

  "'": ''',

  '/': '/',

};

/* eslint-enable */

export const escape = (data) => {

  if (isString(data)) {

    return data.replace(/[&<>"'\/]/g, (s) => _entityMap[s]);

/**

 * This is a reusable regular expression cache class. Given a certain maximum number of regular expressions we're

 * allowed to store in the cache, it provides a way to avoid recreating regular expression objects over and over.

 * When it needs to evict something, it evicts the oldest one.

 */

class RegExpCache {

  constructor(capacity) {

    this.capacity = capacity;

    this.regExpMap = new Map();

    // Since our capacity tends to be fairly small, `.shift()` will be fairly quick despite being O(n). We just use a

    // normal array to keep it simple.

    this.regExpQueue = [];

  }

  getRegExp(pattern) {

    const regExpFromCache = this.regExpMap.get(pattern);

    if (regExpFromCache !== undefined) {

      return regExpFromCache;

    }

    const regExpNew = new RegExp(pattern);

    this.regExpMap.set(pattern, regExpNew);

    this.regExpQueue.push(pattern);

    return regExpNew;

  }

}

const chars = [' ', ',', '?', '!', ';'];

// We cache RegExps to improve performance with React Native Android, which has poor RegExp initialization performance.

// Capacity of 20 should be plenty, as nsSeparator/keySeparator don't tend to vary much across calls.

const looksLikeObjectPathRegExpCache = new RegExpCache(20);

export const looksLikeObjectPath = (key, nsSeparator, keySeparator) => {

  nsSeparator = nsSeparator || '';

  keySeparator = keySeparator || '';

  const possibleChars = chars.filter(

    (c) => nsSeparator.indexOf(c) < 0 && keySeparator.indexOf(c) < 0,

  );

  const r = looksLikeObjectPathRegExpCache.getRegExp(

    `(${possibleChars.map((c) => (c === '?' ? '\\?' : c)).join('|')})`,

  );

  let matched = !r.test(key);

  if (!matched) {

    const ki = key.indexOf(keySeparator);

    if (ki > 0 && !r.test(key.substring(0, ki))) {

      matched = true;

    }

  }

  return matched;

};

/**

 * Given

 *

 * 1. a top level object obj, and

 * 2. a path to a deeply nested string or object within it

 *

 * Find and return that deeply nested string or object. The caveat is that the keys of objects within the nesting chain

 * may contain period characters. Therefore, we need to DFS and explore all possible keys at each step until we find the

 * deeply nested string or object.

 */

export const deepFind = (obj, path, keySeparator = '.') => {

  if (!obj) return undefined;

  if (obj[path]) {

    if (!Object.prototype.hasOwnProperty.call(obj, path)) return undefined;

    return obj[path];

  }

  const tokens = path.split(keySeparator);

  let current = obj;

  for (let i = 0; i < tokens.length; ) {

    if (!current || typeof current !== 'object') {

      return undefined;

    }

    let next;

    let nextPath = '';

    for (let j = i; j < tokens.length; ++j) {

      if (j !== i) {

        nextPath += keySeparator;

      }

      nextPath += tokens[j];

      next = current[nextPath];

      if (next !== undefined) {

        if (['string', 'number', 'boolean'].indexOf(typeof next) > -1 && j < tokens.length - 1) {

          continue;

        }

        i += j - i + 1;

        break;

      }

    }

    current = next;

  }

  return current;

};

export const getCleanedCode = (code) => code?.replace('_', '-');