WebCompDev / COMPONENTS

  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
  
  (function () {
    'use strict';
  
    var Service = bridge.service;
    var channel = new BroadcastChannel('l20n-channel');
  
    function broadcast(type, data) {
      return this.service.broadcast(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) {
        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, _ref) {
      var code = _ref.code;
      var src = _ref.src;
      var ver = _ref.ver;
  
      var url = res.replace('{locale}', code);

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

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

    }
  

    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 (_ref2, cur) {
        var localsSeq = _ref2[0];
        var valueSeq = _ref2[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
    };
  
    function isIn(n, list) {
      return list.indexOf(n) !== -1;
    }
    function isBetween(n, start, end) {
      return typeof n === typeof start && start <= n && n <= end;
    }
  
    var 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';
      },
      '3': function (n) {
        if (n === 1) {
          return 'one';
        }
        return 'other';
      },
      '4': function (n) {
        if (isBetween(n, 0, 1)) {
          return 'one';
        }
        return 'other';
      },
      '5': function (n) {
        if (isBetween(n, 0, 2) && n !== 2) {
          return 'one';

        }

        return 'other';
      },
      '6': function (n) {

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

        if (n % 10 === 1 && n % 100 !== 11) {
          return 'one';

        }

        return 'other';
      },
      '7': function (n) {

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

      '8': function (n) {
        if (isBetween(n, 3, 6)) {
          return 'few';
        }
        if (isBetween(n, 7, 10)) {

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

      '9': function (n) {
        if (n === 0 || n !== 1 && isBetween(n % 100, 1, 19)) {
          return 'few';
        }

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

      '10': function (n) {
        if (isBetween(n % 10, 2, 9) && !isBetween(n % 100, 11, 19)) {
          return 'few';
        }
        if (n % 10 === 1 && !isBetween(n % 100, 11, 19)) {
          return 'one';
        }
        return 'other';
      },
      '11': function (n) {
        if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) {
          return 'few';
        }
        if (n % 10 === 0 || isBetween(n % 10, 5, 9) || isBetween(n % 100, 11, 14)) {
          return 'many';
        }
        if (n % 10 === 1 && n % 100 !== 11) {
          return 'one';
        }
        return 'other';
      },
      '12': function (n) {
        if (isBetween(n, 2, 4)) {
          return 'few';
        }
        if (n === 1) {
          return 'one';
        }
        return 'other';
      },
      '13': function (n) {
        if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) {
          return 'few';
        }
        if (n !== 1 && isBetween(n % 10, 0, 1) || isBetween(n % 10, 5, 9) || isBetween(n % 100, 12, 14)) {
          return 'many';
        }
        if (n === 1) {
          return 'one';
        }
        return 'other';
      },
      '14': function (n) {
        if (isBetween(n % 100, 3, 4)) {
          return 'few';
        }
        if (n % 100 === 2) {
          return 'two';
        }
        if (n % 100 === 1) {
          return 'one';
        }
        return 'other';
      },
      '15': function (n) {
        if (n === 0 || isBetween(n % 100, 2, 10)) {
          return 'few';
        }
        if (isBetween(n % 100, 11, 19)) {
          return 'many';
        }
        if (n === 1) {
          return 'one';
        }
        return 'other';
      },
      '16': function (n) {
        if (n % 10 === 1 && n !== 11) {
          return 'one';
        }
        return 'other';
      },
      '17': function (n) {
        if (n === 3) {
          return 'few';
        }
        if (n === 0) {
          return 'zero';
        }
        if (n === 6) {
          return 'many';
        }
        if (n === 2) {
          return 'two';
        }
        if (n === 1) {
          return 'one';
        }
        return 'other';
      },
      '18': function (n) {
        if (n === 0) {
          return 'zero';
        }
        if (isBetween(n, 0, 2) && n !== 0 && n !== 2) {
          return 'one';
        }
        return 'other';
      },
      '19': function (n) {
        if (isBetween(n, 2, 10)) {
          return 'few';
        }

        if (isBetween(n, 0, 1)) {
          return 'one';
        }
        return 'other';
      },

      '20': function (n) {
        if ((isBetween(n % 10, 3, 4) || n % 10 === 9) && !(isBetween(n % 100, 10, 19) || isBetween(n % 100, 70, 79) || isBetween(n % 100, 90, 99))) {
          return 'few';
        }
        if (n % 1000000 === 0 && n !== 0) {
          return 'many';
        }
        if (n % 10 === 2 && !isIn(n % 100, [12, 72, 92])) {
          return 'two';
        }
        if (n % 10 === 1 && !isIn(n % 100, [11, 71, 91])) {

          return 'one';
        }
        return 'other';
      },

      '21': function (n) {

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

        if (n === 1) {
          return 'one';
        }
        return 'other';
      },
      '22': function (n) {
        if (isBetween(n, 0, 1) || isBetween(n, 11, 99)) {
          return 'one';
        }
        return 'other';
      },
      '23': function (n) {
        if (isBetween(n % 10, 1, 2) || n % 20 === 0) {
          return 'one';
        }
        return 'other';
      },
      '24': function (n) {
        if (isBetween(n, 3, 10) || isBetween(n, 13, 19)) {
          return 'few';
        }
        if (isIn(n, [2, 12])) {
          return 'two';
        }
        if (isIn(n, [1, 11])) {

          return 'one';
        }

        return 'other';
      }
    };
  
    function getPluralRule(code) {
      var index = locales2rules[code.replace(/-.*$/, '')];
      if (!(index in pluralRules)) {
        return function () {
          return 'other';
        };
      }
      return pluralRules[index];
    }
  
    var L20nIntl = typeof Intl !== 'undefined' ? Intl : {
      NumberFormat: function () {
        return {
          format: function (v) {
            return v;
          }
        };
      }
    };
  
    var Context = (function () {
      function Context(env, langs, resIds) {
        var _this = this;
  
        _classCallCheck(this, Context);
  
        this.langs = langs;
        this.resIds = resIds;
        this.env = env;
        this.emit = function (type, evt) {
          return env.emit(type, evt, _this);
        };
      }
  
      Context.prototype._formatTuple = function _formatTuple(lang, args, entity, id, key) {
        try {
          return format(this, lang, args, entity);
        } catch (err) {
          err.id = key ? id + '::' + key : id;
          err.lang = lang;
          this.emit('resolveerror', err);
          return [{ error: err }, err.id];
        }
      };
  
      Context.prototype._formatEntity = function _formatEntity(lang, args, entity, id) {
        var _formatTuple2 = this._formatTuple(lang, args, entity, id);
  
        var value = _formatTuple2[1];
  
        var formatted = {
          value: value,
          attrs: null
        };
  
        if (entity.attrs) {
          formatted.attrs = Object.create(null);
          for (var key in entity.attrs) {
            var _formatTuple3 = this._formatTuple(lang, args, entity.attrs[key], id, key);
  
            var attrValue = _formatTuple3[1];
  
            formatted.attrs[key] = attrValue;
          }
        }
  
        return formatted;
      };
  
      Context.prototype._formatValue = function _formatValue(lang, args, entity, id) {
        return this._formatTuple(lang, args, entity, id)[1];
      };
  
      Context.prototype.fetch = function fetch() {
        var _this2 = this;
  
        var langs = arguments.length <= 0 || arguments[0] === undefined ? this.langs : arguments[0];
  
        if (langs.length === 0) {
          return Promise.resolve(langs);
        }
  
        return Promise.all(this.resIds.map(function (resId) {
          return _this2.env._getResource(langs[0], resId);
        })).then(function () {
          return langs;
        });
      };
  
      Context.prototype._resolve = function _resolve(langs, keys, formatter, prevResolved) {
        var _this3 = this;
  
        var lang = langs[0];
  
        if (!lang) {
          return reportMissing.call(this, keys, formatter, prevResolved);
        }
  
        var hasUnresolved = false;
  
        var resolved = keys.map(function (key, i) {
          if (prevResolved && prevResolved[i] !== undefined) {
            return prevResolved[i];
          }
  
          var _ref3 = Array.isArray(key) ? key : [key, undefined];
  
          var id = _ref3[0];
          var args = _ref3[1];
  
          var entity = _this3._getEntity(lang, id);
  
          if (entity) {
            return formatter.call(_this3, lang, args, entity, id);
          }
  
          _this3.emit('notfounderror', new L10nError('"' + id + '"' + ' not found in ' + lang.code, id, lang));
          hasUnresolved = true;
        });
  
        if (!hasUnresolved) {
          return resolved;

        }

  
        return this.fetch(langs.slice(1)).then(function (nextLangs) {
          return _this3._resolve(nextLangs, keys, formatter, resolved);
        });
      };
  
      Context.prototype.formatEntities = function formatEntities() {
        var _this4 = this;
  
        for (var _len = arguments.length, keys = Array(_len), _key = 0; _key < _len; _key++) {
          keys[_key] = arguments[_key];

        }

  
        return this.fetch().then(function (langs) {
          return _this4._resolve(langs, keys, _this4._formatEntity);
        });
      };
  
      Context.prototype.formatValues = function formatValues() {
        var _this5 = this;
  
        for (var _len2 = arguments.length, keys = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          keys[_key2] = arguments[_key2];

        }

  
        return this.fetch().then(function (langs) {
          return _this5._resolve(langs, keys, _this5._formatValue);
        });
      };
  
      Context.prototype._getEntity = function _getEntity(lang, id) {
        var cache = this.env.resCache;
  
        for (var i = 0, resId = undefined; resId = this.resIds[i]; i++) {
          var resource = cache.get(resId + lang.code + lang.src);
          if (resource instanceof L10nError) {
            continue;
          }
          if (id in resource) {
            return resource[id];
          }

        }

        return undefined;
      };
  
      Context.prototype._getNumberFormatter = function _getNumberFormatter(lang) {
        if (!this.env.numberFormatters) {
          this.env.numberFormatters = new Map();

        }

        if (!this.env.numberFormatters.has(lang)) {
          var formatter = L20nIntl.NumberFormat(lang);
          this.env.numberFormatters.set(lang, formatter);
          return formatter;

        }

        return this.env.numberFormatters.get(lang);
      };
  
      Context.prototype._getMacro = function _getMacro(lang, id) {
        switch (id) {
          case 'plural':
            return getPluralRule(lang.code);
          default:
            return undefined;

        }

      };
  
      return Context;
    })();
  
    function reportMissing(keys, formatter, resolved) {
      var _this6 = this;
  
      var missingIds = new Set();
  
      keys.forEach(function (key, i) {
        if (resolved && resolved[i] !== undefined) {
          return;

        }

        var id = Array.isArray(key) ? key[0] : key;
        missingIds.add(id);
        resolved[i] = formatter === _this6._formatValue ? id : { value: id, attrs: null };
      });
  
      this.emit('notfounderror', new L10nError('"' + Array.from(missingIds).join(', ') + '"' + ' not found in any language', missingIds));
  
      return resolved;
    }
  
    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) {
            var 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') {
            var 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;