WebCompDev / COMPONENTS

  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
  
  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, _ref) {
    var code = _ref.code;
  
    var url = decodeURI(res).replace('{locale}', code);

  
    var _htmloptimizer$getFileByRelativePath = htmloptimizer.getFileByRelativePath(url);
  
    var file = _htmloptimizer$getFileByRelativePath.file;
    var content = _htmloptimizer$getFileByRelativePath.content;
  
    if (!file) {
      return Promise.reject(new L10nError('Not found: ' + url));
    }
  
    var parsed = res.endsWith('.json') ? JSON.parse(content) : content;
    return Promise.resolve(parsed);
  }
  
  function walkEntry(entry, fn) {
    if (typeof entry === 'string') {
      return fn(entry);
    }
  
    var 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 (var 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);
    }
  
    if (value.type) {
      return value;
    }
  
    var newValue = Array.isArray(value) ? [] : Object.create(null);
    var keys = Object.keys(value);
  
    for (var i = 0, key = undefined; key = keys[i]; i++) {
      newValue[key] = walkValue$1(value[key], fn);
    }
  
    return newValue;
  }
  
  function createGetter(id, name) {
    var _pseudo = null;
  
    return function getPseudo() {
      if (_pseudo) {
        return _pseudo;
      }
  
      var reAlphas = /[a-zA-Z]/g;
      var reVowels = /[aeiouAEIOU]/g;
      var reWords = /[^\W0-9_]+/g;
  
      var reExcluded = /(%[EO]?\w|\{\s*.+?\s*\}|&[#\w]+;|<\s*.+?\s*>)/;
  
      var charMaps = {
        'fr-x-psaccent': 'ȦƁƇḒḖƑƓĦĪĴĶĿḾȠǾƤɊŘŞŦŬṼẆẊẎẐ[\\]^_`ȧƀƈḓḗƒɠħīĵķŀḿƞǿƥɋřşŧŭṽẇẋẏẑ',
        'ar-x-psbidi': '∀ԐↃpƎɟפHIſӼ˥WNOԀÒᴚS⊥∩ɅＭXʎZ[\\]ᵥ_,ɐqɔpǝɟƃɥıɾʞʅɯuodbɹsʇnʌʍxʎz'
      };
  
      var mods = {
        'fr-x-psaccent': function (val) {
          return val.replace(reVowels, function (match) {
            return match + match.toLowerCase();
          });
        },
  
        'ar-x-psbidi': function (val) {
          return val.replace(reWords, function (match) {
            return '‮' + match + '‬';
          });
        }
      };
  
      var replaceChars = function (map, val) {
        return val.replace(reAlphas, function (match) {
          return map.charAt(match.charCodeAt(0) - 65);
        });
      };
  
      var transform = function (val) {
        return replaceChars(charMaps[id], mods[id](val));
      };
  
      var apply = function (fn, val) {
        if (!val) {
          return val;
        }
  
        var parts = val.split(reExcluded);
        var modified = parts.map(function (part) {
          if (reExcluded.test(part)) {
            return part;
          }
          return fn(part);
        });
        return modified.join('');
      };
  
      return _pseudo = {
        name: transform(name),
        process: function (str) {
          return apply(transform, str);
        }
      };
    };
  }
  
  var 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')
    }
  });
  

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

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

  var resolutionChain$1 = new WeakSet();

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

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

    resolutionChain$1.add(entity);

    var rv = undefined;

    try {
      rv = resolveValue$1({}, ctx, lang, args, entity.value, entity.index);
    } finally {
      resolutionChain$1.delete(entity);
    }
    return rv;
  }

  function resolveIdentifier$1(ctx, lang, args, id) {
    if (KNOWN_MACROS$1.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$1(ctx, lang, args, entity);
    }

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

  function subPlaceable$1(locals, ctx, lang, args, id) {
    var newLocals = undefined,
        value = undefined;

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

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

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

    if (typeof value === 'string') {
      if (value.length >= MAX_PLACEABLE_LENGTH$1) {
        throw new L10nError('Too many characters in placeable (' + value.length + ', max allowed is ' + MAX_PLACEABLE_LENGTH$1 + ')');

      }

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

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

  function interpolate$1(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$1 = subPlaceable$1(locals, ctx, lang, args, cur.name);

        var value = _subPlaceable$1[1];
  
        return [localsSeq, valueSeq + value];

      }

    }, [locals, '']);
  }

  function resolveSelector$1(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$1(ctx, lang, args, selectorName)[1];

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

    var argValue = index[0].args ? resolveIdentifier$1(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$1(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$1(locals, ctx, lang, args, expr);
    }

  
    if (index) {
      var selector = resolveSelector$1(ctx, lang, args, expr, index);
      if (selector in expr) {
        return resolveValue$1(locals, ctx, lang, args, expr[selector]);
      }
    }
  
    var defaultKey = expr.__default || 'other';
    if (defaultKey in expr) {
      return resolveValue$1(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$1(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;