SGH / COMPONENTS

  (function () { 'use strict';
  
    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));
    }
  
    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(ver, res, lang) {
      const url = res.replace('{locale}', lang.code);

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

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

    }
  

    const MAX_PLACEABLES$1 = 100;

    var L20nParser = {
      parse: function(emit, string) {
        this._source = string;
        this._index = 0;
        this._length = string.length;
        this.entries = Object.create(null);
        this.emit = emit;

        return this.getResource();
      },

      getResource: function() {
        this.getWS();
        while (this._index < this._length) {
          try {
            this.getEntry();
          } catch (e) {
            if (e instanceof L10nError) {
              // we want to recover, but we don't need it in entries
              this.getJunkEntry();
              if (!this.emit) {
                throw e;
              }
            } else {
              throw e;
            }
          }

          if (this._index < this._length) {
            this.getWS();
          }
        }

        return this.entries;
      },

      getEntry: function() {
        if (this._source[this._index] === '<') {
          ++this._index;
          const id = this.getIdentifier();
          if (this._source[this._index] === '[') {
            ++this._index;
            return this.getEntity(id, this.getItemList(this.getExpression, ']'));
          }
          return this.getEntity(id);
        }

        if (this._source.startsWith('/*', this._index)) {
          return this.getComment();

        }

        throw this.error('Invalid entry');
      },

      getEntity: function(id, index) {
        if (!this.getRequiredWS()) {
          throw this.error('Expected white space');
        }

        const ch = this._source[this._index];
        const value = this.getValue(ch, index === undefined);
        let attrs;

        if (value === undefined) {
          if (ch === '>') {
            throw this.error('Expected ">"');
          }
          attrs = this.getAttributes();
        } else {
          const ws1 = this.getRequiredWS();
          if (this._source[this._index] !== '>') {
            if (!ws1) {
              throw this.error('Expected ">"');
            }
            attrs = this.getAttributes();
          }
        }

        // skip '>'
        ++this._index;

        if (id in this.entries) {
          throw this.error('Duplicate entry ID "' + id, 'duplicateerror');
        }
        if (!attrs && !index && typeof value === 'string') {
          this.entries[id] = value;
        } else {
          this.entries[id] = {
            value,
            attrs,
            index
          };
        }
      },

      getValue: function(ch = this._source[this._index], optional = false) {
        switch (ch) {
          case '\'':
          case '"':
            return this.getString(ch, 1);
          case '{':
            return this.getHash();
        }

        if (!optional) {
          throw this.error('Unknown value type');

        }

        return;
      },

      getWS: function() {
        let cc = this._source.charCodeAt(this._index);
        // space, \n, \t, \r
        while (cc === 32 || cc === 10 || cc === 9 || cc === 13) {
          cc = this._source.charCodeAt(++this._index);

        }

      },

      getRequiredWS: function() {
        const pos = this._index;
        let cc = this._source.charCodeAt(pos);
        // space, \n, \t, \r
        while (cc === 32 || cc === 10 || cc === 9 || cc === 13) {
          cc = this._source.charCodeAt(++this._index);
        }
        return this._index !== pos;
      },

      getIdentifier: function() {
        const start = this._index;
        let cc = this._source.charCodeAt(this._index);

        if ((cc >= 97 && cc <= 122) || // a-z
            (cc >= 65 && cc <= 90) ||  // A-Z
            cc === 95) {               // _
          cc = this._source.charCodeAt(++this._index);
        } else {
          throw this.error('Identifier has to start with [a-zA-Z_]');

        }

  
        while ((cc >= 97 && cc <= 122) || // a-z
               (cc >= 65 && cc <= 90) ||  // A-Z
               (cc >= 48 && cc <= 57) ||  // 0-9
               cc === 95) {               // _
          cc = this._source.charCodeAt(++this._index);

        }

  
        return this._source.slice(start, this._index);
      },
  
      getUnicodeChar: function() {
        for (let i = 0; i < 4; i++) {
          let cc = this._source.charCodeAt(++this._index);
          if ((cc > 96 && cc < 103) || // a-f
              (cc > 64 && cc < 71) ||  // A-F
              (cc > 47 && cc < 58)) {  // 0-9
            continue;
          }
          throw this.error('Illegal unicode escape sequence');

        }

        this._index++;
        return String.fromCharCode(
          parseInt(this._source.slice(this._index - 4, this._index), 16));
      },

      stringRe: /"|'|{{|\\/g,
      getString: function(opchar, opcharLen) {
        const body = [];
        let placeables = 0;

        this._index += opcharLen;
        const start = this._index;

        let bufStart = start;
        let buf = '';

        while (true) {
          this.stringRe.lastIndex = this._index;
          const match = this.stringRe.exec(this._source);

          if (!match) {
            throw this.error('Unclosed string literal');
          }

          if (match[0] === '"' || match[0] === '\'') {
            if (match[0] !== opchar) {
              this._index += opcharLen;
              continue;
            }
            this._index = match.index + opcharLen;
            break;
          }

          if (match[0] === '{{') {
            if (placeables > MAX_PLACEABLES$1 - 1) {
              throw this.error('Too many placeables, maximum allowed is ' +
                  MAX_PLACEABLES$1);
            }
            placeables++;
            if (match.index > bufStart || buf.length > 0) {
              body.push(buf + this._source.slice(bufStart, match.index));
              buf = '';
            }
            this._index = match.index + 2;
            this.getWS();
            body.push(this.getExpression());
            this.getWS();
            this._index += 2;
            bufStart = this._index;
            continue;
          }

          if (match[0] === '\\') {
            this._index = match.index + 1;
            const ch2 = this._source[this._index];
            if (ch2 === 'u') {
              buf += this._source.slice(bufStart, match.index) +
                this.getUnicodeChar();
            } else if (ch2 === opchar || ch2 === '\\') {
              buf += this._source.slice(bufStart, match.index) + ch2;
              this._index++;
            } else if (this._source.startsWith('{{', this._index)) {
              buf += this._source.slice(bufStart, match.index) + '{{';
              this._index += 2;
            } else {
              throw this.error('Illegal escape sequence');
            }
            bufStart = this._index;
          }

        }

  
        if (body.length === 0) {
          return buf + this._source.slice(bufStart, this._index - opcharLen);

        }

  
        if (this._index - opcharLen > bufStart || buf.length > 0) {
          body.push(buf + this._source.slice(bufStart, this._index - opcharLen));

        }

  
        return body;

      },

  
      getAttributes: function() {
        const attrs = Object.create(null);
  
        while (true) {
          this.getAttribute(attrs);
          const ws1 = this.getRequiredWS();
          const ch = this._source.charAt(this._index);
          if (ch === '>') {
            break;
          } else if (!ws1) {
            throw this.error('Expected ">"');
          }

        }

        return attrs;

      },

  
      getAttribute: function(attrs) {
        const key = this.getIdentifier();
        let index;
  
        if (this._source[this._index]=== '[') {
          ++this._index;
          this.getWS();
          index = this.getItemList(this.getExpression, ']');

        }

        this.getWS();
        if (this._source[this._index] !== ':') {
          throw this.error('Expected ":"');

        }

        ++this._index;
        this.getWS();
        const value = this.getValue();
  
        if (key in attrs) {
          throw this.error('Duplicate attribute "' + key, 'duplicateerror');

        }

  
        if (!index && typeof value === 'string') {
          attrs[key] = value;
        } else {
          attrs[key] = {
            value,
            index
          };

        }

      },

  
      getHash: function() {
        const items = Object.create(null);
  
        ++this._index;
        this.getWS();
  
        let defKey;
  
        while (true) {
          const [key, value, def] = this.getHashItem();
          items[key] = value;
  
          if (def) {
            if (defKey) {
              throw this.error('Default item redefinition forbidden');
            }
            defKey = key;
          }
          this.getWS();
  
          const comma = this._source[this._index] === ',';
          if (comma) {
            ++this._index;
            this.getWS();
          }
          if (this._source[this._index] === '}') {
            ++this._index;
            break;
          }
          if (!comma) {
            throw this.error('Expected "}"');
          }

        }

  
        if (defKey) {
          items.__default = defKey;

        }

  
        return items;

      },

  
      getHashItem: function() {
        let defItem = false;
        if (this._source[this._index] === '*') {
          ++this._index;
          defItem = true;

        }

  
        const key = this.getIdentifier();
        this.getWS();
        if (this._source[this._index] !== ':') {
          throw this.error('Expected ":"');

        }

        ++this._index;
        this.getWS();
  
        return [key, this.getValue(), defItem];

      },

  
      getComment: function() {
        this._index += 2;
        const start = this._index;
        const end = this._source.indexOf('*/', start);
  
        if (end === -1) {
          throw this.error('Comment without a closing tag');

        }

  
        this._index = end + 2;
      },
  
      getExpression: function () {
        let exp = this.getPrimaryExpression();
  
        while (true) {
          let ch = this._source[this._index];
          if (ch === '.' || ch === '[') {
            ++this._index;
            exp = this.getPropertyExpression(exp, ch === '[');
          } else if (ch === '(') {
            ++this._index;
            exp = this.getCallExpression(exp);
          } else {
            break;
          }

        }

  
        return exp;
      },
  
      getPropertyExpression: function(idref, computed) {
        let exp;
  
        if (computed) {
          this.getWS();
          exp = this.getExpression();
          this.getWS();
          if (this._source[this._index] !== ']') {
            throw this.error('Expected "]"');
          }
          ++this._index;
        } else {
          exp = this.getIdentifier();

        }

  
        return {
          type: 'prop',
          expr: idref,
          prop: exp,
          cmpt: computed
        };

      },

  
      getCallExpression: function(callee) {
        this.getWS();
  
        return {
          type: 'call',
          expr: callee,
          args: this.getItemList(this.getExpression, ')')
        };
      },
  
      getPrimaryExpression: function() {
        const ch = this._source[this._index];
  
        switch (ch) {
          case '$':
            ++this._index;
            return {
              type: 'var',
              name: this.getIdentifier()
            };
          case '@':
            ++this._index;
            return {
              type: 'glob',
              name: this.getIdentifier()
            };
          default:
            return {
              type: 'id',
              name: this.getIdentifier()
            };

        }

      },
  
      getItemList: function(callback, closeChar) {
        const items = [];
        let closed = false;
  
        this.getWS();
  
        if (this._source[this._index] === closeChar) {
          ++this._index;
          closed = true;

        }

  
        while (!closed) {
          items.push(callback.call(this));
          this.getWS();
          let ch = this._source.charAt(this._index);
          switch (ch) {
            case ',':
              ++this._index;
              this.getWS();
              break;
            case closeChar:
              ++this._index;
              closed = true;
              break;
            default:
              throw this.error('Expected "," or "' + closeChar + '"');
          }

        }

  
        return items;

      },

  
  
      getJunkEntry: function() {
        const pos = this._index;
        let nextEntity = this._source.indexOf('<', pos);
        let nextComment = this._source.indexOf('/*', pos);
  
        if (nextEntity === -1) {
          nextEntity = this._length;

        }

        if (nextComment === -1) {
          nextComment = this._length;

        }

  
        let nextEntry = Math.min(nextEntity, nextComment);
  
        this._index = nextEntry;

      },

  
      error: function(message, type = 'parsererror') {
        const pos = this._index;
  
        let start = this._source.lastIndexOf('<', pos - 1);
        const lastClose = this._source.lastIndexOf('>', pos - 1);
        start = lastClose > start ? lastClose + 1 : start;
        const context = this._source.slice(start, pos + 10);
  
        const msg = message + ' at pos ' + pos + ': `' + context + '`';
        const err = new L10nError(msg);
        if (this.emit) {
          this.emit(type, err);

        }

        return err;

      },

    };
  
    var MAX_PLACEABLES = 100;
  
    var PropertiesParser = {
      patterns: null,
      entryIds: null,
      emit: null,
  
      init: function() {
        this.patterns = {
          comment: /^\s*#|^\s*$/,
          entity: /^([^=\s]+)\s*=\s*(.*)$/,
          multiline: /[^\\]\\$/,
          index: /\{\[\s*(\w+)(?:\(([^\)]*)\))?\s*\]\}/i,
          unicode: /\\u([0-9a-fA-F]{1,4})/g,
          entries: /[^\r\n]+/g,
          controlChars: /\\([\\\n\r\t\b\f\{\}\"\'])/g,
          placeables: /\{\{\s*([^\s]*?)\s*\}\}/,
        };
      },
  
      parse: function(emit, source) {
        if (!this.patterns) {
          this.init();

        }

        this.emit = emit;
  
        var entries = {};
  
        var lines = source.match(this.patterns.entries);
        if (!lines) {
          return entries;

        }

        for (var i = 0; i < lines.length; i++) {
          var line = lines[i];
  
          if (this.patterns.comment.test(line)) {
            continue;
          }
  
          while (this.patterns.multiline.test(line) && i < lines.length) {
            line = line.slice(0, -1) + lines[++i].trim();
          }
  
          var entityMatch = line.match(this.patterns.entity);
          if (entityMatch) {
            try {
              this.parseEntity(entityMatch[1], entityMatch[2], entries);
            } catch (e) {
              if (!this.emit) {
                throw e;
              }
            }
          }

        }

        return entries;

      },

  
      parseEntity: function(id, value, entries) {
        var name, key;
  
        var pos = id.indexOf('[');
        if (pos !== -1) {
          name = id.substr(0, pos);
          key = id.substring(pos + 1, id.length - 1);
        } else {
          name = id;
          key = null;

        }

  
        var nameElements = name.split('.');
  
        if (nameElements.length > 2) {
          throw this.error('Error in ID: "' + name + '".' +
              ' Nested attributes are not supported.');

        }

  
        var attr;
        if (nameElements.length > 1) {
          name = nameElements[0];
          attr = nameElements[1];
  
          if (attr[0] === '$') {
            throw this.error('Attribute can\'t start with "$"');
          }
        } else {
          attr = null;

        }

  
        this.setEntityValue(name, attr, key, this.unescapeString(value), entries);

      },

  
      setEntityValue: function(id, attr, key, rawValue, entries) {
        var value = rawValue.indexOf('{{') > -1 ?
          this.parseString(rawValue) : rawValue;
  
        var isSimpleValue = typeof value === 'string';
        var root = entries;
  
        var isSimpleNode = typeof entries[id] === 'string';
  
        if (!entries[id] && (attr || key || !isSimpleValue)) {
          entries[id] = Object.create(null);
          isSimpleNode = false;

        }

  
        if (attr) {
          if (isSimpleNode) {
            const val = entries[id];
            entries[id] = Object.create(null);
            entries[id].value = val;
          }
          if (!entries[id].attrs) {
            entries[id].attrs = Object.create(null);
          }
          if (!entries[id].attrs && !isSimpleValue) {
            entries[id].attrs[attr] = Object.create(null);
          }
          root = entries[id].attrs;
          id = attr;

        }

  
        if (key) {
          isSimpleNode = false;
          if (typeof root[id] === 'string') {
            const val = root[id];
            root[id] = Object.create(null);
            root[id].index = this.parseIndex(val);
            root[id].value = Object.create(null);
          }
          root = root[id].value;
          id = key;
          isSimpleValue = true;

        }

  
        if (isSimpleValue && (!entries[id] || isSimpleNode)) {
          if (id in root) {
            throw this.error();
          }
          root[id] = value;
        } else {
          if (!root[id]) {
            root[id] = Object.create(null);
          }
          root[id].value = value;

        }

      },

  
      parseString: function(str) {
        var chunks = str.split(this.patterns.placeables);
        var complexStr = [];
  
        var len = chunks.length;
        var placeablesCount = (len - 1) / 2;
  
        if (placeablesCount >= MAX_PLACEABLES) {
          throw this.error('Too many placeables (' + placeablesCount +
                              ', max allowed is ' + MAX_PLACEABLES + ')');

        }

  
        for (var i = 0; i < chunks.length; i++) {
          if (chunks[i].length === 0) {
            continue;
          }
          if (i % 2 === 1) {
            complexStr.push({type: 'idOrVar', name: chunks[i]});
          } else {
            complexStr.push(chunks[i]);
          }

        }

        return complexStr;

      },

  
      unescapeString: function(str) {
        if (str.lastIndexOf('\\') !== -1) {
          str = str.replace(this.patterns.controlChars, '$1');

        }

        return str.replace(this.patterns.unicode, function(match, token) {
          return String.fromCodePoint(parseInt(token, 16));
        });

      },

  
      parseIndex: function(str) {
        var match = str.match(this.patterns.index);
        if (!match) {
          throw new L10nError('Malformed index');

        }

        if (match[2]) {
          return [{
            type: 'call',
            expr: {
              type: 'prop',
              expr: {
                type: 'glob',
                name: 'cldr'
              },
              prop: 'plural',
              cmpt: false
            }, args: [{
              type: 'idOrVar',
              name: match[2]
            }]
          }];
        } else {
          return [{type: 'idOrVar', name: match[1]}];

        }

      },
  
      error: function(msg, type = 'parsererror') {
        const err = new L10nError(msg);
        if (this.emit) {
          this.emit(type, err);

        }

        return err;

      }

    };

    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;