SGH / COMPONENTS

  '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 fetchResource(htmloptimizer, res, lang) {

    // We need to decode URI because build system DOM reader
    // may replace `{locale}` with `%7Blocale%7D`. See bug 1098188

    const url = decodeURI(res).replace('{locale}', lang.code);

    const {file, content} = htmloptimizer.getFileByRelativePath(url);
    if (!file) {
      return Promise.reject(new L10nError('Not found: ' + url));
    }
  
    const parsed = res.endsWith('.json') ?
      JSON.parse(content) : content;
    return Promise.resolve(parsed);
  }
  
  // Walk an entry node searching for content leaves
  function walkEntry(entry, fn) {
    if (typeof entry === 'string') {
      return fn(entry);
    }
  
    const newEntry = Object.create(null);
  
    if (entry.value) {
      newEntry.value = walkValue$1(entry.value, fn);
    }
  
    if (entry.index) {
      newEntry.index = entry.index;
    }
  
    if (entry.attrs) {
      newEntry.attrs = Object.create(null);
      for (let key in entry.attrs) {
        newEntry.attrs[key] = walkEntry(entry.attrs[key], fn);
      }
    }
  
    return newEntry;
  }
  
  function walkValue$1(value, fn) {
    if (typeof value === 'string') {
      return fn(value);
    }
  
    // skip expressions in placeables
    if (value.type) {
      return value;
    }
  
    const newValue = Array.isArray(value) ? [] : Object.create(null);
    const keys = Object.keys(value);
  
    for (let i = 0, key; (key = keys[i]); i++) {
      newValue[key] = walkValue$1(value[key], fn);
    }
  
    return newValue;
  }
  
  /* Pseudolocalizations
   *
   * pseudo is a dict of strategies to be used to modify the English
   * context in order to create pseudolocalizations.  These can be used by
   * developers to test the localizability of their code without having to
   * actually speak a foreign language.
   *
   * Currently, the following pseudolocales are supported:
   *
   *   fr-x-psaccent - Ȧȧƈƈḗḗƞŧḗḗḓ Ḗḗƞɠŀīīşħ
   *
   *     In Accented English all English letters are replaced by accented
   *     Unicode counterparts which don't impair the readability of the content.
   *     This allows developers to quickly test if any given string is being
   *     correctly displayed in its 'translated' form.  Additionally, simple
   *     heuristics are used to make certain words longer to better simulate the
   *     experience of international users.
   *
   *   ar-x-psbidi - ɥsıʅƃuƎ ıpıԐ
   *
   *     Bidi English is a fake RTL locale.  All words are surrounded by
   *     Unicode formatting marks forcing the RTL directionality of characters.
   *     In addition, to make the reversed text easier to read, individual
   *     letters are flipped.
   *
   *     Note: The name above is hardcoded to be RTL in case code editors have
   *     trouble with the RLO and PDF Unicode marks.  In reality, it should be
   *     surrounded by those marks as well.
   *
   * See https://bugzil.la/900182 for more information.
   *
   */
  
  function createGetter(id, name) {
    let _pseudo = null;
  
    return function getPseudo() {
      if (_pseudo) {
        return _pseudo;
      }
  
      const reAlphas = /[a-zA-Z]/g;
      const reVowels = /[aeiouAEIOU]/g;
      const reWords = /[^\W0-9_]+/g;
      // strftime tokens (%a, %Eb), template {vars}, HTML entities (‪)
      // and HTML tags.
      const reExcluded = /(%[EO]?\w|\{\s*.+?\s*\}|&[#\w]+;|<\s*.+?\s*>)/;
  
      const charMaps = {
        'fr-x-psaccent':
          'ȦƁƇḒḖƑƓĦĪĴĶĿḾȠǾƤɊŘŞŦŬṼẆẊẎẐ[\\]^_`ȧƀƈḓḗƒɠħīĵķŀḿƞǿƥɋřşŧŭṽẇẋẏẑ',
        'ar-x-psbidi':
          // XXX Use pɟפ˥ʎ as replacements for ᗡℲ⅁⅂⅄. https://bugzil.la/1007340
          '∀ԐↃpƎɟפHIſӼ˥WNOԀÒᴚS⊥∩ɅＭXʎZ[\\]ᵥ_,ɐqɔpǝɟƃɥıɾʞʅɯuodbɹsʇnʌʍxʎz',
      };
  
      const mods = {
        'fr-x-psaccent': val =>
          val.replace(reVowels, match => match + match.toLowerCase()),
  
        // Surround each word with Unicode formatting codes, RLO and PDF:
        //   U+202E:   RIGHT-TO-LEFT OVERRIDE (RLO)
        //   U+202C:   POP DIRECTIONAL FORMATTING (PDF)
        // See http://www.w3.org/International/questions/qa-bidi-controls
        'ar-x-psbidi': val =>
          val.replace(reWords, match => '\u202e' + match + '\u202c'),
      };
  
      // Replace each Latin letter with a Unicode character from map
      const replaceChars =
        (map, val) => val.replace(
          reAlphas, match => map.charAt(match.charCodeAt(0) - 65));
  
      const transform =
        val => replaceChars(charMaps[id], mods[id](val));
  
      // apply fn to translatable parts of val
      const apply = (fn, val) => {
        if (!val) {
          return val;
        }
  
        const parts = val.split(reExcluded);
        const modified = parts.map(function(part) {
          if (reExcluded.test(part)) {
            return part;
          }
          return fn(part);
        });
        return modified.join('');
      };
  
      return _pseudo = {
        name: transform(name),
        process: str => apply(transform, str)
      };
    };
  }
  
  const pseudo$1 = Object.defineProperties(Object.create(null), {
    'fr-x-psaccent': {
      enumerable: true,
      get: createGetter('fr-x-psaccent', 'Runtime Accented')
    },
    'ar-x-psbidi': {
      enumerable: true,
      get: createGetter('ar-x-psbidi', 'Runtime Bidi')
    }
  });
  

  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$1 = ['plural'];
  const MAX_PLACEABLE_LENGTH$1 = 2500;
  
  // Unicode bidi isolation characters
  const FSI$1 = '\u2068';
  const PDI$1 = '\u2069';
  
  const resolutionChain$1 = new WeakSet();
  
  function format$1(ctx, lang, args, entity) {
    if (typeof entity === 'string') {
      return [{}, entity];

    }