SGH / COMPONENTS

  (function () { 'use strict';
  
    function L10nError(message, id, lang) {
      this.name = 'L10nError';
      this.message = message;
      this.id = id;
      this.lang = lang;
    }
    L10nError.prototype = Object.create(Error.prototype);
    L10nError.prototype.constructor = L10nError;
  
    function load(type, url) {
      return new Promise(function(resolve, reject) {
        const xhr = new XMLHttpRequest();
  
        if (xhr.overrideMimeType) {
          xhr.overrideMimeType(type);
        }
  
        xhr.open('GET', url, true);
  
        if (type === 'application/json') {
          xhr.responseType = 'json';
        }
  
        xhr.addEventListener('load', function io_onload(e) {
          if (e.target.status === 200 || e.target.status === 0) {
            // Sinon.JS's FakeXHR doesn't have the response property
            resolve(e.target.response || e.target.responseText);
          } else {
            reject(new L10nError('Not found: ' + url));
          }
        });
        xhr.addEventListener('error', reject);
        xhr.addEventListener('timeout', reject);
  
        // the app: protocol throws on 404, see https://bugzil.la/827243
        try {
          xhr.send(null);
        } catch (e) {
          if (e.name === 'NS_ERROR_FILE_NOT_FOUND') {
            // the app: protocol throws on 404, see https://bugzil.la/827243
            reject(new L10nError('Not found: ' + url));
          } else {
            throw e;
          }
        }
      });
    }
  
    const io = {
      extra: function(code, ver, path, type) {
        return navigator.mozApps.getLocalizationResource(
          code, ver, path, type);
      },
      app: function(code, ver, path, type) {
        switch (type) {
          case 'text':
            return load('text/plain', path);
          case 'json':
            return load('application/json', path);
          default:
            throw new L10nError('Unknown file type: ' + type);
        }
      },
    };
  

    function fetchResource(res, { code, src, ver }) {
      const url = res.replace('{locale}', code);

      const type = res.endsWith('.json') ? 'json' : 'text';

      return io[src](code, ver, url, type);

    }
  
    function emit(listeners, ...args) {
      const type = args.shift();
  
      if (listeners['*']) {
        listeners['*'].slice().forEach(
          listener => listener.apply(this, args));
      }
  
      if (listeners[type]) {
        listeners[type].slice().forEach(
          listener => listener.apply(this, args));
      }
    }
  
    function addEventListener(listeners, type, listener) {
      if (!(type in listeners)) {
        listeners[type] = [];
      }
      listeners[type].push(listener);
    }
  
    function removeEventListener(listeners, type, listener) {
      const typeListeners = listeners[type];
      const pos = typeListeners.indexOf(listener);
      if (pos === -1) {
        return;
      }
  
      typeListeners.splice(pos, 1);
    }
  
    class Client {
      constructor(remote) {
        this.id = this;
        this.remote = remote;
  
        const listeners = {};
        this.on = (...args) => addEventListener(listeners, ...args);
        this.emit = (...args) => emit(listeners, ...args);
      }
  
      method(name, ...args) {
        return this.remote[name](...args);
      }
    }
  
    function broadcast(type, data) {
      Array.from(this.ctxs.keys()).forEach(
        client => client.emit(type, data));
    }
  

    const observerConfig = {
      attributes: true,
      characterData: false,
      childList: true,
      subtree: true,
      attributeFilter: ['data-l10n-id', 'data-l10n-args']
    };
  
    const observers = new WeakMap();
  
    function initMutationObserver(view) {
      observers.set(view, {
        roots: new Set(),
        observer: new MutationObserver(
          mutations => translateMutations(view, mutations)),
      });
    }
  
    function translateRoots(view) {
      return Promise.all(
        [...observers.get(view).roots].map(
          root => translateFragment(view, root)));
    }
  
    function observe(view, root) {
      const obs = observers.get(view);
      if (obs) {
        obs.roots.add(root);
        obs.observer.observe(root, observerConfig);
      }
    }
  
    function disconnect(view, root, allRoots) {
      const obs = observers.get(view);
      if (obs) {
        obs.observer.disconnect();
        if (allRoots) {
          return;
        }
        obs.roots.delete(root);
        obs.roots.forEach(
          other => obs.observer.observe(other, observerConfig));
      }
    }
  
    function reconnect(view) {
      const obs = observers.get(view);
      if (obs) {
        obs.roots.forEach(
          root => obs.observer.observe(root, observerConfig));
      }
    }
  

    // match the opening angle bracket (<) in HTML tags, and HTML entities like
    // &amp;, &#0038;, &#x0026;.
    const reOverlay = /<|&#?\w+;/;
  
    const allowed = {
      elements: [
        'a', 'em', 'strong', 'small', 's', 'cite', 'q', 'dfn', 'abbr', 'data',
        'time', 'code', 'var', 'samp', 'kbd', 'sub', 'sup', 'i', 'b', 'u',
        'mark', 'ruby', 'rt', 'rp', 'bdi', 'bdo', 'span', 'br', 'wbr'
      ],
      attributes: {
        global: [ 'title', 'aria-label', 'aria-valuetext', 'aria-moz-hint' ],
        a: [ 'download' ],
        area: [ 'download', 'alt' ],
        // value is special-cased in isAttrAllowed
        input: [ 'alt', 'placeholder' ],
        menuitem: [ 'label' ],
        menu: [ 'label' ],
        optgroup: [ 'label' ],
        option: [ 'label' ],
        track: [ 'label' ],
        img: [ 'alt' ],
        textarea: [ 'placeholder' ],
        th: [ 'abbr']
      }
    };
  
    function overlayElement(element, translation) {
      const value = translation.value;
  
      if (typeof value === 'string') {
        if (!reOverlay.test(value)) {
          element.textContent = value;
        } else {
          // start with an inert template element and move its children into
          // `element` but such that `element`'s own children are not replaced
          const tmpl = element.ownerDocument.createElement('template');
          tmpl.innerHTML = value;
          // overlay the node with the DocumentFragment
          overlay(element, tmpl.content);
        }
      }
  
      for (let key in translation.attrs) {
        const attrName = camelCaseToDashed(key);
        if (isAttrAllowed({ name: attrName }, element)) {
          element.setAttribute(attrName, translation.attrs[key]);
        }
      }
    }
  
    // The goal of overlay is to move the children of `translationElement`
    // into `sourceElement` such that `sourceElement`'s own children are not
    // replaced, but onle have their text nodes and their attributes modified.
    //
    // We want to make it possible for localizers to apply text-level semantics to
    // the translations and make use of HTML entities. At the same time, we
    // don't trust translations so we need to filter unsafe elements and
    // attribtues out and we don't want to break the Web by replacing elements to
    // which third-party code might have created references (e.g. two-way
    // bindings in MVC frameworks).
    function overlay(sourceElement, translationElement) {
      const result = translationElement.ownerDocument.createDocumentFragment();
      let k, attr;
  
      // take one node from translationElement at a time and check it against
      // the allowed list or try to match it with a corresponding element
      // in the source
      let childElement;
      while ((childElement = translationElement.childNodes[0])) {
        translationElement.removeChild(childElement);
  
        if (childElement.nodeType === childElement.TEXT_NODE) {
          result.appendChild(childElement);
          continue;
        }
  
        const index = getIndexOfType(childElement);
        const sourceChild = getNthElementOfType(sourceElement, childElement, index);
        if (sourceChild) {
          // there is a corresponding element in the source, let's use it
          overlay(sourceChild, childElement);
          result.appendChild(sourceChild);
          continue;
        }
  
        if (isElementAllowed(childElement)) {
          const sanitizedChild = childElement.ownerDocument.createElement(
            childElement.nodeName);
          overlay(sanitizedChild, childElement);
          result.appendChild(sanitizedChild);
          continue;
        }
  
        // otherwise just take this child's textContent
        result.appendChild(
          translationElement.ownerDocument.createTextNode(
            childElement.textContent));
      }
  
      // clear `sourceElement` and append `result` which by this time contains
      // `sourceElement`'s original children, overlayed with translation
      sourceElement.textContent = '';
      sourceElement.appendChild(result);
  
      // if we're overlaying a nested element, translate the allowed
      // attributes; top-level attributes are handled in `translateElement`
      // XXX attributes previously set here for another language should be
      // cleared if a new language doesn't use them; https://bugzil.la/922577
      if (translationElement.attributes) {
        for (k = 0, attr; (attr = translationElement.attributes[k]); k++) {
          if (isAttrAllowed(attr, sourceElement)) {
            sourceElement.setAttribute(attr.name, attr.value);
          }
        }
      }
    }
  
    // XXX the allowed list should be amendable; https://bugzil.la/922573
    function isElementAllowed(element) {
      return allowed.elements.indexOf(element.tagName.toLowerCase()) !== -1;
    }
  
    function isAttrAllowed(attr, element) {
      const attrName = attr.name.toLowerCase();
      const tagName = element.tagName.toLowerCase();
      // is it a globally safe attribute?
      if (allowed.attributes.global.indexOf(attrName) !== -1) {
        return true;
      }
      // are there no allowed attributes for this element?
      if (!allowed.attributes[tagName]) {
        return false;
      }
      // is it allowed on this element?
      // XXX the allowed list should be amendable; https://bugzil.la/922573
      if (allowed.attributes[tagName].indexOf(attrName) !== -1) {
        return true;
      }
      // special case for value on inputs with type button, reset, submit
      if (tagName === 'input' && attrName === 'value') {
        const type = element.type.toLowerCase();
        if (type === 'submit' || type === 'button' || type === 'reset') {
          return true;
        }
      }
      return false;
    }
  
    // Get n-th immediate child of context that is of the same type as element.
    // XXX Use querySelector(':scope > ELEMENT:nth-of-type(index)'), when:
    // 1) :scope is widely supported in more browsers and 2) it works with
    // DocumentFragments.
    function getNthElementOfType(context, element, index) {
      /* jshint boss:true */
      let nthOfType = 0;
      for (let i = 0, child; child = context.children[i]; i++) {
        if (child.nodeType === child.ELEMENT_NODE &&
            child.tagName === element.tagName) {
          if (nthOfType === index) {
            return child;
          }
          nthOfType++;
        }
      }
      return null;
    }
  
    // Get the index of the element among siblings of the same type.
    function getIndexOfType(element) {
      let index = 0;
      let child;
      while ((child = element.previousElementSibling)) {
        if (child.tagName === element.tagName) {
          index++;
        }
      }
      return index;
    }
  
    function camelCaseToDashed(string) {
      // XXX workaround for https://bugzil.la/1141934
      if (string === 'ariaValueText') {
        return 'aria-valuetext';
      }
  
      return string
        .replace(/[A-Z]/g, function (match) {
          return '-' + match.toLowerCase();
        })
        .replace(/^-/, '');
    }
  
    const reHtml = /[&<>]/g;
    const htmlEntities = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
    };
  

    function setAttributes(element, id, args) {
      element.setAttribute('data-l10n-id', id);
      if (args) {
        element.setAttribute('data-l10n-args', JSON.stringify(args));
      }
    }
  
    function getAttributes(element) {
      return {
        id: element.getAttribute('data-l10n-id'),
        args: JSON.parse(element.getAttribute('data-l10n-args'))
      };
    }
  
    function getTranslatables(element) {
      const nodes = Array.from(element.querySelectorAll('[data-l10n-id]'));
  
      if (typeof element.hasAttribute === 'function' &&
          element.hasAttribute('data-l10n-id')) {
        nodes.push(element);
      }
  
      return nodes;
    }
  

    function translateMutations(view, mutations) {

      const targets = new Set();
  
      for (let mutation of mutations) {
        switch (mutation.type) {
          case 'attributes':
            targets.add(mutation.target);
            break;
          case 'childList':
            for (let addedNode of mutation.addedNodes) {
              if (addedNode.nodeType === addedNode.ELEMENT_NODE) {
                if (addedNode.childElementCount) {
                  getTranslatables(addedNode).forEach(targets.add.bind(targets));
                } else {
                  if (addedNode.hasAttribute('data-l10n-id')) {
                    targets.add(addedNode);
                  }
                }
              }
            }
            break;
        }
      }
  
      if (targets.size === 0) {
        return;
      }
  

      translateElements(view, Array.from(targets));

    }
  

    function translateFragment(view, frag) {
      return translateElements(view, getTranslatables(frag));

    }
  

    function getElementsTranslation(view, elems) {

      const keys = elems.map(elem => {
        const id = elem.getAttribute('data-l10n-id');
        const args = elem.getAttribute('data-l10n-args');
        return args ? [
          id,
          JSON.parse(args.replace(reHtml, match => htmlEntities[match]))
        ] : id;
      });
  

      return view.formatEntities(...keys);

    }
  

    function translateElements(view, elements) {
      return getElementsTranslation(view, elements).then(

        translations => applyTranslations(view, elements, translations));
    }
  
    function applyTranslations(view, elems, translations) {

      disconnect(view, null, true);

      for (let i = 0; i < elems.length; i++) {
        overlayElement(elems[i], translations[i]);
      }

      reconnect(view);

    }
  
    // Polyfill NodeList.prototype[Symbol.iterator] for Chrome.
    // See https://code.google.com/p/chromium/issues/detail?id=401699
    if (typeof NodeList === 'function' && !NodeList.prototype[Symbol.iterator]) {
      NodeList.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
    }
  
    // A document.ready shim
    // https://github.com/whatwg/html/issues/127
    function documentReady() {
      if (document.readyState !== 'loading') {
        return Promise.resolve();
      }
  
      return new Promise(resolve => {
        document.addEventListener('readystatechange', function onrsc() {
          document.removeEventListener('readystatechange', onrsc);
          resolve();
        });
      });
    }
  
    // Intl.Locale
    function getDirection(code) {
      const tag = code.split('-')[0];
      return ['ar', 'he', 'fa', 'ps', 'ur'].indexOf(tag) >= 0 ?
        'rtl' : 'ltr';
    }
  

    // Opera and Safari don't support it yet
    if (navigator.languages === undefined) {
      navigator.languages = [navigator.language];
    }
  
    function getResourceLinks(head) {
      return Array.prototype.map.call(
        head.querySelectorAll('link[rel="localization"]'),
        el => el.getAttribute('href'));
    }
  
    function getMeta(head) {
      let availableLangs = Object.create(null);
      let defaultLang = null;
      let appVersion = null;
  
      // XXX take last found instead of first?
      const metas = Array.from(head.querySelectorAll(
        'meta[name="availableLanguages"],' +
        'meta[name="defaultLanguage"],' +
        'meta[name="appVersion"]'));
      for (let meta of metas) {
        const name = meta.getAttribute('name');
        const content = meta.getAttribute('content').trim();
        switch (name) {
          case 'availableLanguages':
            availableLangs = getLangRevisionMap(
              availableLangs, content);
            break;
          case 'defaultLanguage':
            const [lang, rev] = getLangRevisionTuple(content);
            defaultLang = lang;
            if (!(lang in availableLangs)) {
              availableLangs[lang] = rev;
            }
            break;
          case 'appVersion':
            appVersion = content;
        }
      }
  
      return {
        defaultLang,
        availableLangs,
        appVersion
      };
    }

    function getLangRevisionMap(seq, str) {
      return str.split(',').reduce((seq, cur) => {
        const [lang, rev] = getLangRevisionTuple(cur);
        seq[lang] = rev;
        return seq;
      }, seq);
    }
  
    function getLangRevisionTuple(str) {
      const [lang, rev]  = str.trim().split(':');
      // if revision is missing, use NaN
      return [lang, parseInt(rev)];
    }
  
    const viewProps = new WeakMap();

  
    class View {
      constructor(client, doc) {

        this.pseudo = {
          'fr-x-psaccent': createPseudo(this, 'fr-x-psaccent'),
          'ar-x-psbidi': createPseudo(this, 'ar-x-psbidi')
        };
  

        const initialized = documentReady().then(() => init(this, client));
        this._interactive = initialized.then(() => client);
        this.ready = initialized.then(langs => translateView(this, langs));
        initMutationObserver(this);

        viewProps.set(this, {
          doc: doc,
          ready: false
        });

        client.on('languageschangerequest',
          requestedLangs => this.requestLanguages(requestedLangs));

      }
  

      requestLanguages(requestedLangs, isGlobal) {
        const method = isGlobal ?
          client => client.method('requestLanguages', requestedLangs) :
          client => changeLanguages(this, client, requestedLangs);
        return this._interactive.then(method);

      }
  

      handleEvent() {
        return this.requestLanguages(navigator.languages);
      }
  
      formatEntities(...keys) {

        return this._interactive.then(

          client => client.method('formatEntities', client.id, keys));

      }
  
      formatValue(id, args) {
        return this._interactive.then(
          client => client.method('formatValues', client.id, [[id, args]])).then(
          values => values[0]);
      }
  
      formatValues(...keys) {
        return this._interactive.then(
          client => client.method('formatValues', client.id, keys));
      }
  
      translateFragment(frag) {

        return translateFragment(this, frag);
      }
  
      observeRoot(root) {
        observe(this, root);
      }
  
      disconnectRoot(root) {
        disconnect(this, root);

      }
    }
  
    View.prototype.setAttributes = setAttributes;
    View.prototype.getAttributes = getAttributes;
  
    function createPseudo(view, code) {
      return {
        getName: () => view._interactive.then(
          client => client.method('getName', code)),
        processString: str => view._interactive.then(
          client => client.method('processString', code, str)),
      };
    }
  
    function init(view, client) {

      const doc = viewProps.get(view).doc;
      const resources = getResourceLinks(doc.head);
      const meta = getMeta(doc.head);
      view.observeRoot(doc.documentElement);
      return getAdditionalLanguages().then(
        additionalLangs => client.method(
          'registerView', client.id, resources, meta, additionalLangs,
          navigator.languages));
    }
  
    function changeLanguages(view, client, requestedLangs) {
      const doc = viewProps.get(view).doc;
      const meta = getMeta(doc.head);
      return getAdditionalLanguages()
        .then(additionalLangs => client.method(
          'changeLanguages', client.id, meta, additionalLangs, requestedLangs
        ))
        .then(({langs, haveChanged}) => haveChanged ?
          translateView(view, langs) : undefined
        );

    }
  

    function getAdditionalLanguages() {
      if (navigator.mozApps && navigator.mozApps.getAdditionalLanguages) {
        return navigator.mozApps.getAdditionalLanguages()
          .catch(() => Object.create(null));
      }
  
      return Promise.resolve(Object.create(null));

    }
  

    function translateView(view, langs) {
      const props = viewProps.get(view);
      const html = props.doc.documentElement;

      if (props.ready) {
        return translateRoots(view).then(

          () => setAllAndEmit(html, langs));
      }
  
      const translated =
        // has the document been already pre-translated?
        langs[0].code === html.getAttribute('lang') ?
          Promise.resolve() :

          translateRoots(view).then(

            () => setLangDir(html, langs));
  
      return translated.then(() => {
        setLangs(html, langs);

        props.ready = true;

      });
    }
  
    function setLangs(html, langs) {
      const codes = langs.map(lang => lang.code);
      html.setAttribute('langs', codes.join(' '));
    }
  
    function setLangDir(html, langs) {
      const code = langs[0].code;
      html.setAttribute('lang', code);
      html.setAttribute('dir', getDirection(code));
    }
  
    function setAllAndEmit(html, langs) {
      setLangDir(html, langs);
      setLangs(html, langs);
      html.parentNode.dispatchEvent(new CustomEvent('DOMRetranslated', {
        bubbles: false,
        cancelable: false,
      }));
    }
  

    const KNOWN_MACROS = ['plural'];
    const MAX_PLACEABLE_LENGTH = 2500;

    // Unicode bidi isolation characters
    const FSI = '\u2068';
    const PDI = '\u2069';

    const resolutionChain = new WeakSet();

    function format(ctx, lang, args, entity) {
      if (typeof entity === 'string') {
        return [{}, entity];
      }

      if (resolutionChain.has(entity)) {
        throw new L10nError('Cyclic reference detected');
      }

      resolutionChain.add(entity);

      let rv;
      // if format fails, we want the exception to bubble up and stop the whole
      // resolving process;  however, we still need to remove the entity from the
      // resolution chain
      try {
        rv = resolveValue(
          {}, ctx, lang, args, entity.value, entity.index);
      } finally {
        resolutionChain.delete(entity);
      }
      return rv;
    }

    function resolveIdentifier(ctx, lang, args, id) {
      if (KNOWN_MACROS.indexOf(id) > -1) {
        return [{}, ctx._getMacro(lang, id)];
      }

      if (args && args.hasOwnProperty(id)) {
        if (typeof args[id] === 'string' || (typeof args[id] === 'number' &&
            !isNaN(args[id]))) {
          return [{}, args[id]];

        } else {

          throw new L10nError('Arg must be a string or a number: ' + id);

        }

      }

      // XXX: special case for Node.js where still:
      // '__proto__' in Object.create(null) => true
      if (id === '__proto__') {
        throw new L10nError('Illegal id: ' + id);
      }

      const entity = ctx._getEntity(lang, id);

      if (entity) {
        return format(ctx, lang, args, entity);
      }

      throw new L10nError('Unknown reference: ' + id);
    }

    function subPlaceable(locals, ctx, lang, args, id) {
      let newLocals, value;

      try {
        [newLocals, value] = resolveIdentifier(ctx, lang, args, id);
      } catch (err) {
        return [{ error: err }, FSI + '{{ ' + id + ' }}' + PDI];
      }

      if (typeof value === 'number') {
        const formatter = ctx._getNumberFormatter(lang);
        return [newLocals, formatter.format(value)];
      }

      if (typeof value === 'string') {
        // prevent Billion Laughs attacks
        if (value.length >= MAX_PLACEABLE_LENGTH) {
          throw new L10nError('Too many characters in placeable (' +
                              value.length + ', max allowed is ' +
                              MAX_PLACEABLE_LENGTH + ')');

        }

        return [newLocals, FSI + value + PDI];
      }

      return [{}, FSI + '{{ ' + id + ' }}' + PDI];
    }

    function interpolate(locals, ctx, lang, args, arr) {
      return arr.reduce(function([localsSeq, valueSeq], cur) {
        if (typeof cur === 'string') {
          return [localsSeq, valueSeq + cur];
        } else {
          const [, value] = subPlaceable(locals, ctx, lang, args, cur.name);
          // wrap the substitution in bidi isolate characters
          return [localsSeq, valueSeq + value];

        }

      }, [locals, '']);
    }

    function resolveSelector(ctx, lang, args, expr, index) {
      //XXX: Dehardcode!!!
      let selectorName;
      if (index[0].type === 'call' && index[0].expr.type === 'prop' &&
          index[0].expr.expr.name === 'cldr') {
        selectorName = 'plural';
      } else {
        selectorName = index[0].name;
      }
      const selector = resolveIdentifier(ctx, lang, args, selectorName)[1];

      if (typeof selector !== 'function') {
        // selector is a simple reference to an entity or args
        return selector;
      }

      const argValue = index[0].args ?
        resolveIdentifier(ctx, lang, args, index[0].args[0].name)[1] : undefined;

      if (selectorName === 'plural') {
        // special cases for zero, one, two if they are defined on the hash
        if (argValue === 0 && 'zero' in expr) {
          return 'zero';

        }

        if (argValue === 1 && 'one' in expr) {
          return 'one';

        }

        if (argValue === 2 && 'two' in expr) {
          return 'two';

        }

      }

      return selector(argValue);
    }

    function resolveValue(locals, ctx, lang, args, expr, index) {
      if (!expr) {
        return [locals, expr];
      }

      if (typeof expr === 'string' ||
          typeof expr === 'boolean' ||
          typeof expr === 'number') {
        return [locals, expr];
      }

      if (Array.isArray(expr)) {
        return interpolate(locals, ctx, lang, args, expr);
      }

      // otherwise, it's a dict
      if (index) {
        // try to use the index in order to select the right dict member
        const selector = resolveSelector(ctx, lang, args, expr, index);
        if (selector in expr) {
          return resolveValue(locals, ctx, lang, args, expr[selector]);

        }

      }

      // if there was no index or no selector was found, try the default
      // XXX 'other' is an artifact from Gaia
      const defaultKey = expr.__default || 'other';
      if (defaultKey in expr) {
        return resolveValue(locals, ctx, lang, args, expr[defaultKey]);
      }

      throw new L10nError('Unresolvable value');
    }

    const locales2rules = {
      'af': 3,
      'ak': 4,
      'am': 4,
      'ar': 1,
      'asa': 3,
      'az': 0,
      'be': 11,
      'bem': 3,
      'bez': 3,
      'bg': 3,
      'bh': 4,
      'bm': 0,
      'bn': 3,
      'bo': 0,
      'br': 20,
      'brx': 3,
      'bs': 11,
      'ca': 3,
      'cgg': 3,
      'chr': 3,
      'cs': 12,
      'cy': 17,
      'da': 3,
      'de': 3,
      'dv': 3,
      'dz': 0,
      'ee': 3,
      'el': 3,
      'en': 3,
      'eo': 3,
      'es': 3,
      'et': 3,
      'eu': 3,
      'fa': 0,
      'ff': 5,
      'fi': 3,
      'fil': 4,
      'fo': 3,
      'fr': 5,
      'fur': 3,
      'fy': 3,
      'ga': 8,
      'gd': 24,
      'gl': 3,
      'gsw': 3,
      'gu': 3,
      'guw': 4,
      'gv': 23,
      'ha': 3,
      'haw': 3,
      'he': 2,
      'hi': 4,
      'hr': 11,
      'hu': 0,
      'id': 0,
      'ig': 0,
      'ii': 0,
      'is': 3,
      'it': 3,
      'iu': 7,
      'ja': 0,
      'jmc': 3,
      'jv': 0,
      'ka': 0,
      'kab': 5,
      'kaj': 3,
      'kcg': 3,
      'kde': 0,
      'kea': 0,
      'kk': 3,
      'kl': 3,
      'km': 0,
      'kn': 0,
      'ko': 0,
      'ksb': 3,
      'ksh': 21,
      'ku': 3,
      'kw': 7,
      'lag': 18,
      'lb': 3,
      'lg': 3,
      'ln': 4,
      'lo': 0,
      'lt': 10,
      'lv': 6,
      'mas': 3,
      'mg': 4,
      'mk': 16,
      'ml': 3,
      'mn': 3,
      'mo': 9,
      'mr': 3,
      'ms': 0,
      'mt': 15,
      'my': 0,
      'nah': 3,
      'naq': 7,
      'nb': 3,
      'nd': 3,
      'ne': 3,
      'nl': 3,
      'nn': 3,
      'no': 3,
      'nr': 3,
      'nso': 4,
      'ny': 3,
      'nyn': 3,
      'om': 3,
      'or': 3,
      'pa': 3,
      'pap': 3,
      'pl': 13,
      'ps': 3,
      'pt': 3,
      'rm': 3,
      'ro': 9,
      'rof': 3,
      'ru': 11,
      'rwk': 3,
      'sah': 0,
      'saq': 3,
      'se': 7,
      'seh': 3,
      'ses': 0,
      'sg': 0,
      'sh': 11,
      'shi': 19,
      'sk': 12,
      'sl': 14,
      'sma': 7,
      'smi': 7,
      'smj': 7,
      'smn': 7,
      'sms': 7,
      'sn': 3,
      'so': 3,
      'sq': 3,
      'sr': 11,
      'ss': 3,
      'ssy': 3,
      'st': 3,
      'sv': 3,
      'sw': 3,
      'syr': 3,
      'ta': 3,
      'te': 3,
      'teo': 3,
      'th': 0,
      'ti': 4,
      'tig': 3,
      'tk': 3,
      'tl': 4,
      'tn': 3,
      'to': 0,
      'tr': 0,
      'ts': 3,
      'tzm': 22,
      'uk': 11,
      'ur': 3,
      've': 3,
      'vi': 0,
      'vun': 3,
      'wa': 4,
      'wae': 3,
      'wo': 0,
      'xh': 3,
      'xog': 3,
      'yo': 0,
      'zh': 0,
      'zu': 3
    };

    // utility functions for plural rules methods
    function isIn(n, list) {
      return list.indexOf(n) !== -1;
    }
    function isBetween(n, start, end) {
      return typeof n === typeof start && start <= n && n <= end;
    }

    // list of all plural rules methods:
    // map an integer to the plural form name to use
    const pluralRules = {
      '0': function() {
        return 'other';

      },

      '1': function(n) {
        if ((isBetween((n % 100), 3, 10))) {
          return 'few';

        }

        if (n === 0) {
          return 'zero';

        }

        if ((isBetween((n % 100), 11, 99))) {
          return 'many';
        }
        if (n === 2) {
          return 'two';
        }
        if (n === 1) {
          return 'one';
        }
        return 'other';

      },

      '2': function(n) {
        if (n !== 0 && (n % 10) === 0) {
          return 'many';

        }

        if (n === 2) {
          return 'two';
        }
        if (n === 1) {
          return 'one';
        }
        return 'other';