WebCompDev / COMPONENTS

  'use strict';
  
  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
  
  (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) {
        var 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) {
            resolve(e.target.response || e.target.responseText);
          } else {
            reject(new L10nError('Not found: ' + url));
          }
        });
        xhr.addEventListener('error', reject);
        xhr.addEventListener('timeout', reject);
  
        try {
          xhr.send(null);
        } catch (e) {
          if (e.name === 'NS_ERROR_FILE_NOT_FOUND') {
            reject(new L10nError('Not found: ' + url));
          } else {
            throw e;
          }
        }
      });
    }
  
    var 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, _ref4) {
      var code = _ref4.code;
      var src = _ref4.src;
      var ver = _ref4.ver;
  
      var url = res.replace('{locale}', code);

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

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

    }
  
    function emit(listeners) {
      var _this = this;
  
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
  
      var type = args.shift();
  
      if (listeners['*']) {
        listeners['*'].slice().forEach(function (listener) {
          return listener.apply(_this, args);
        });
      }
  
      if (listeners[type]) {
        listeners[type].slice().forEach(function (listener) {
          return listener.apply(_this, args);
        });
      }
    }
  
    function addEventListener(listeners, type, listener) {
      if (!(type in listeners)) {
        listeners[type] = [];
      }
      listeners[type].push(listener);
    }
  
    function removeEventListener(listeners, type, listener) {
      var typeListeners = listeners[type];
      var pos = typeListeners.indexOf(listener);
      if (pos === -1) {
        return;
      }
  
      typeListeners.splice(pos, 1);
    }
  
    var Client = (function () {
      function Client(remote) {
        _classCallCheck(this, Client);
  
        this.id = this;
        this.remote = remote;
  
        var listeners = {};
        this.on = function () {
          for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
          }
  
          return addEventListener.apply(undefined, [listeners].concat(args));
        };
        this.emit = function () {
          for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
            args[_key3] = arguments[_key3];
          }
  
          return emit.apply(undefined, [listeners].concat(args));
        };
      }
  
      Client.prototype.method = function method(name) {
        var _remote;
  
        for (var _len4 = arguments.length, args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
          args[_key4 - 1] = arguments[_key4];
        }
  
        return (_remote = this.remote)[name].apply(_remote, args);
      };
  
      return Client;
    })();
  
    function broadcast(type, data) {
      Array.from(this.ctxs.keys()).forEach(function (client) {
        return client.emit(type, data);
      });
    }
  

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

    var reOverlay = /<|&#?\w+;/;
  
    var 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'],
  
        input: ['alt', 'placeholder'],
        menuitem: ['label'],
        menu: ['label'],
        optgroup: ['label'],
        option: ['label'],
        track: ['label'],
        img: ['alt'],
        textarea: ['placeholder'],
        th: ['abbr']
      }
    };
  
    function overlayElement(element, translation) {
      var value = translation.value;
  
      if (typeof value === 'string') {
        if (!reOverlay.test(value)) {
          element.textContent = value;
        } else {
          var tmpl = element.ownerDocument.createElement('template');
          tmpl.innerHTML = value;
  
          overlay(element, tmpl.content);
        }
      }
  
      for (var key in translation.attrs) {
        var attrName = camelCaseToDashed(key);
        if (isAttrAllowed({ name: attrName }, element)) {
          element.setAttribute(attrName, translation.attrs[key]);
        }
      }
    }
  
    function overlay(sourceElement, translationElement) {
      var result = translationElement.ownerDocument.createDocumentFragment();
      var k = undefined,
          attr = undefined;
  
      var childElement = undefined;
      while (childElement = translationElement.childNodes[0]) {
        translationElement.removeChild(childElement);
  
        if (childElement.nodeType === childElement.TEXT_NODE) {
          result.appendChild(childElement);
          continue;
        }
  
        var index = getIndexOfType(childElement);
        var sourceChild = getNthElementOfType(sourceElement, childElement, index);
        if (sourceChild) {
          overlay(sourceChild, childElement);
          result.appendChild(sourceChild);
          continue;
        }
  
        if (isElementAllowed(childElement)) {
          var sanitizedChild = childElement.ownerDocument.createElement(childElement.nodeName);
          overlay(sanitizedChild, childElement);
          result.appendChild(sanitizedChild);
          continue;
        }
  
        result.appendChild(translationElement.ownerDocument.createTextNode(childElement.textContent));
      }
  
      sourceElement.textContent = '';
      sourceElement.appendChild(result);
  
      if (translationElement.attributes) {
        for (k = 0, attr; attr = translationElement.attributes[k]; k++) {
          if (isAttrAllowed(attr, sourceElement)) {
            sourceElement.setAttribute(attr.name, attr.value);
          }
        }
      }
    }
  
    function isElementAllowed(element) {
      return allowed.elements.indexOf(element.tagName.toLowerCase()) !== -1;
    }
  
    function isAttrAllowed(attr, element) {
      var attrName = attr.name.toLowerCase();
      var tagName = element.tagName.toLowerCase();
  
      if (allowed.attributes.global.indexOf(attrName) !== -1) {
        return true;
      }
  
      if (!allowed.attributes[tagName]) {
        return false;
      }
  
      if (allowed.attributes[tagName].indexOf(attrName) !== -1) {
        return true;
      }
  
      if (tagName === 'input' && attrName === 'value') {
        var type = element.type.toLowerCase();
        if (type === 'submit' || type === 'button' || type === 'reset') {
          return true;
        }
      }
      return false;
    }
  
    function getNthElementOfType(context, element, index) {
      var nthOfType = 0;
      for (var i = 0, child = undefined; child = context.children[i]; i++) {
        if (child.nodeType === child.ELEMENT_NODE && child.tagName === element.tagName) {
          if (nthOfType === index) {
            return child;
          }
          nthOfType++;
        }
      }
      return null;
    }
  
    function getIndexOfType(element) {
      var index = 0;
      var child = undefined;
      while (child = element.previousElementSibling) {
        if (child.tagName === element.tagName) {
          index++;
        }
      }
      return index;
    }
  
    function camelCaseToDashed(string) {
      if (string === 'ariaValueText') {
        return 'aria-valuetext';
      }
  
      return string.replace(/[A-Z]/g, function (match) {
        return '-' + match.toLowerCase();
      }).replace(/^-/, '');
    }
  
    var reHtml = /[&<>]/g;
    var 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) {
      var 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) {

      var targets = new Set();
  
      for (var _iterator = mutations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
        var _ref;
  
        if (_isArray) {
          if (_i >= _iterator.length) break;
          _ref = _iterator[_i++];
        } else {
          _i = _iterator.next();
          if (_i.done) break;
          _ref = _i.value;
        }
  
        var mutation = _ref;
  
        switch (mutation.type) {
          case 'attributes':
            targets.add(mutation.target);
            break;
          case 'childList':
            for (var _iterator2 = mutation.addedNodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
              var _ref2;
  
              if (_isArray2) {
                if (_i2 >= _iterator2.length) break;
                _ref2 = _iterator2[_i2++];
              } else {
                _i2 = _iterator2.next();
                if (_i2.done) break;
                _ref2 = _i2.value;
              }
  
              var addedNode = _ref2;
  
              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) {

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

      return view.formatEntities.apply(view, keys);

    }
  

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

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

      disconnect(view, null, true);

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

      reconnect(view);

    }
  
    if (typeof NodeList === 'function' && !NodeList.prototype[Symbol.iterator]) {
      NodeList.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
    }
  
    function documentReady() {
      if (document.readyState !== 'loading') {
        return Promise.resolve();
      }
  
      return new Promise(function (resolve) {
        document.addEventListener('readystatechange', function onrsc() {
          document.removeEventListener('readystatechange', onrsc);
          resolve();
        });
      });
    }
  
    function getDirection(code) {
      var tag = code.split('-')[0];
      return ['ar', 'he', 'fa', 'ps', 'ur'].indexOf(tag) >= 0 ? 'rtl' : 'ltr';
    }
  

    if (navigator.languages === undefined) {
      navigator.languages = [navigator.language];
    }
  
    function getResourceLinks(head) {
      return Array.prototype.map.call(head.querySelectorAll('link[rel="localization"]'), function (el) {
        return el.getAttribute('href');
      });
    }
  
    function getMeta(head) {
      var availableLangs = Object.create(null);
      var defaultLang = null;
      var appVersion = null;
  
      var metas = Array.from(head.querySelectorAll('meta[name="availableLanguages"],' + 'meta[name="defaultLanguage"],' + 'meta[name="appVersion"]'));
      for (var _iterator3 = metas, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
        var _ref3;
  
        if (_isArray3) {
          if (_i3 >= _iterator3.length) break;
          _ref3 = _iterator3[_i3++];
        } else {
          _i3 = _iterator3.next();
          if (_i3.done) break;
          _ref3 = _i3.value;
        }
  
        var meta = _ref3;
  
        var _name = meta.getAttribute('name');
        var content = meta.getAttribute('content').trim();
        switch (_name) {
          case 'availableLanguages':
            availableLangs = getLangRevisionMap(availableLangs, content);
            break;
          case 'defaultLanguage':
            var _getLangRevisionTuple = getLangRevisionTuple(content),
                lang = _getLangRevisionTuple[0],
                rev = _getLangRevisionTuple[1];
  
            defaultLang = lang;
            if (!(lang in availableLangs)) {
              availableLangs[lang] = rev;
            }
            break;
          case 'appVersion':
            appVersion = content;
        }
      }
  
      return {
        defaultLang: defaultLang,
        availableLangs: availableLangs,
        appVersion: appVersion
      };
    }

    function getLangRevisionMap(seq, str) {
      return str.split(',').reduce(function (seq, cur) {
        var _getLangRevisionTuple2 = getLangRevisionTuple(cur);
  
        var lang = _getLangRevisionTuple2[0];
        var rev = _getLangRevisionTuple2[1];
  
        seq[lang] = rev;
        return seq;
      }, seq);
    }
  
    function getLangRevisionTuple(str) {
      var _str$trim$split = str.trim().split(':');
  
      var lang = _str$trim$split[0];
      var rev = _str$trim$split[1];
  
      return [lang, parseInt(rev)];
    }
  
    var viewProps = new WeakMap();

  
    var View = (function () {
      function View(client, doc) {
        var _this2 = this;
  
        _classCallCheck(this, View);
  

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

        var initialized = documentReady().then(function () {

          return init(_this2, client);
        });

        this._interactive = initialized.then(function () {
          return client;
        });
        this.ready = initialized.then(function (langs) {
          return translateView(_this2, langs);
        });
        initMutationObserver(this);

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

        client.on('languageschangerequest', function (requestedLangs) {
          return _this2.requestLanguages(requestedLangs);
        });

      }
  

      View.prototype.requestLanguages = function requestLanguages(requestedLangs, isGlobal) {
        var _this3 = this;
  
        var method = isGlobal ? function (client) {
          return client.method('requestLanguages', requestedLangs);
        } : function (client) {
          return changeLanguages(_this3, client, requestedLangs);
        };
        return this._interactive.then(method);
      };
  
      View.prototype.handleEvent = function handleEvent() {
        return this.requestLanguages(navigator.languages);

      };
  

      View.prototype.formatEntities = function formatEntities() {
        for (var _len5 = arguments.length, keys = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
          keys[_key5] = arguments[_key5];
        }
  

        return this._interactive.then(function (client) {

          return client.method('formatEntities', client.id, keys);

        });
      };
  
      View.prototype.formatValue = function formatValue(id, args) {
        return this._interactive.then(function (client) {
          return client.method('formatValues', client.id, [[id, args]]);
        }).then(function (values) {
          return values[0];
        });
      };
  
      View.prototype.formatValues = function formatValues() {

        for (var _len6 = arguments.length, keys = Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
          keys[_key6] = arguments[_key6];

        }
  
        return this._interactive.then(function (client) {
          return client.method('formatValues', client.id, keys);
        });
      };
  
      View.prototype.translateFragment = function translateFragment(frag) {

        return _translateFragment(this, frag);
      };

      View.prototype.observeRoot = function observeRoot(root) {
        observe(this, root);
      };
  
      View.prototype.disconnectRoot = function disconnectRoot(root) {
        disconnect(this, root);

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

      var doc = viewProps.get(view).doc;
      var resources = getResourceLinks(doc.head);
      var meta = getMeta(doc.head);
      view.observeRoot(doc.documentElement);
      return getAdditionalLanguages().then(function (additionalLangs) {
        return client.method('registerView', client.id, resources, meta, additionalLangs, navigator.languages);

      });
    }
  

    function changeLanguages(view, client, requestedLangs) {
      var doc = viewProps.get(view).doc;
      var meta = getMeta(doc.head);
      return getAdditionalLanguages().then(function (additionalLangs) {
        return client.method('changeLanguages', client.id, meta, additionalLangs, requestedLangs);
      }).then(function (_ref5) {
        var langs = _ref5.langs;
        var haveChanged = _ref5.haveChanged;
        return haveChanged ? translateView(view, langs) : undefined;

      });
    }
  

    function getAdditionalLanguages() {
      if (navigator.mozApps && navigator.mozApps.getAdditionalLanguages) {
        return navigator.mozApps.getAdditionalLanguages().catch(function () {
          return Object.create(null);
        });
      }
  
      return Promise.resolve(Object.create(null));
    }
  
    function translateView(view, langs) {
      var props = viewProps.get(view);
      var html = props.doc.documentElement;

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

          return setAllAndEmit(html, langs);
        });
      }
  

      var translated = langs[0].code === html.getAttribute('lang') ? Promise.resolve() : translateRoots(view).then(function () {

        return setLangDir(html, langs);
      });
  
      return translated.then(function () {
        setLangs(html, langs);

        props.ready = true;

      });
    }
  
    function setLangs(html, langs) {
      var codes = langs.map(function (lang) {
        return lang.code;
      });
      html.setAttribute('langs', codes.join(' '));
    }
  
    function setLangDir(html, langs) {
      var 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
      }));
    }
  

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

    var FSI = '⁨';
    var PDI = '⁩';

    var 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);

      var rv = undefined;

      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);

        }

      }

      if (id === '__proto__') {
        throw new L10nError('Illegal id: ' + id);
      }

      var 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) {
      var newLocals = undefined,
          value = undefined;

      try {
        var _resolveIdentifier = resolveIdentifier(ctx, lang, args, id);

        newLocals = _resolveIdentifier[0];
        value = _resolveIdentifier[1];
      } catch (err) {
        return [{ error: err }, FSI + '{{ ' + id + ' }}' + PDI];
      }

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

      if (typeof value === 'string') {
        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 (_ref6, cur) {
        var localsSeq = _ref6[0];
        var valueSeq = _ref6[1];

        if (typeof cur === 'string') {
          return [localsSeq, valueSeq + cur];

        } else {

          var _subPlaceable = subPlaceable(locals, ctx, lang, args, cur.name);

          var value = _subPlaceable[1];

          return [localsSeq, valueSeq + value];

        }

      }, [locals, '']);
    }

    function resolveSelector(ctx, lang, args, expr, index) {
      var selectorName = undefined;
      if (index[0].type === 'call' && index[0].expr.type === 'prop' && index[0].expr.expr.name === 'cldr') {
        selectorName = 'plural';
      } else {
        selectorName = index[0].name;
      }
      var selector = resolveIdentifier(ctx, lang, args, selectorName)[1];

      if (typeof selector !== 'function') {
        return selector;
      }

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

      if (selectorName === 'plural') {
        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);
      }

      if (index) {
        var selector = resolveSelector(ctx, lang, args, expr, index);
        if (selector in expr) {
          return resolveValue(locals, ctx, lang, args, expr[selector]);

        }

      }

      var defaultKey = expr.__default || 'other';
      if (defaultKey in expr) {
        return resolveValue(locals, ctx, lang, args, expr[defaultKey]);
      }

      throw new L10nError('Unresolvable value');
    }

    var 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
    };