text: /*
   * Copyright 2016, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
  	typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
  	(factory((global.ReactIntl = global.ReactIntl || {}),global.React));
  }(this, (function (exports,React) { 'use strict';
  
  if (typeof React === 'undefined') {
      throw new ReferenceError('React must be loaded before ReactIntl.');
  }
  
  var React__default = 'default' in React ? React['default'] : React;
  
  // GENERATED FILE
  var defaultLocaleData = { "locale": "en", "pluralRuleFunction": function pluralRuleFunction(n, ord) {
      var s = String(n).split("."),
          v0 = !s[1],
          t0 = Number(s[0]) == n,
          n10 = t0 && s[0].slice(-1),
          n100 = t0 && s[0].slice(-2);if (ord) return n10 == 1 && n100 != 11 ? "one" : n10 == 2 && n100 != 12 ? "two" : n10 == 3 && n100 != 13 ? "few" : "other";return n == 1 && v0 ? "one" : "other";
    }, "fields": { "year": { "displayName": "year", "relative": { "0": "this year", "1": "next year", "-1": "last year" }, "relativeTime": { "future": { "one": "in {0} year", "other": "in {0} years" }, "past": { "one": "{0} year ago", "other": "{0} years ago" } } }, "month": { "displayName": "month", "relative": { "0": "this month", "1": "next month", "-1": "last month" }, "relativeTime": { "future": { "one": "in {0} month", "other": "in {0} months" }, "past": { "one": "{0} month ago", "other": "{0} months ago" } } }, "day": { "displayName": "day", "relative": { "0": "today", "1": "tomorrow", "-1": "yesterday" }, "relativeTime": { "future": { "one": "in {0} day", "other": "in {0} days" }, "past": { "one": "{0} day ago", "other": "{0} days ago" } } }, "hour": { "displayName": "hour", "relativeTime": { "future": { "one": "in {0} hour", "other": "in {0} hours" }, "past": { "one": "{0} hour ago", "other": "{0} hours ago" } } }, "minute": { "displayName": "minute", "relativeTime": { "future": { "one": "in {0} minute", "other": "in {0} minutes" }, "past": { "one": "{0} minute ago", "other": "{0} minutes ago" } } }, "second": { "displayName": "second", "relative": { "0": "now" }, "relativeTime": { "future": { "one": "in {0} second", "other": "in {0} seconds" }, "past": { "one": "{0} second ago", "other": "{0} seconds ago" } } } } };
  
  /*
  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
  Copyrights licensed under the New BSD License.
  See the accompanying LICENSE file for terms.
  */
  
  /* jslint esnext: true */
  
  var hop = Object.prototype.hasOwnProperty;
  
  function extend(obj) {
      var sources = Array.prototype.slice.call(arguments, 1),
          i,
          len,
          source,
          key;
  
      for (i = 0, len = sources.length; i < len; i += 1) {
          source = sources[i];
          if (!source) {
              continue;
          }
  
          for (key in source) {
              if (hop.call(source, key)) {
                  obj[key] = source[key];
              }
          }
      }
  
      return obj;
  }
  
  /*
  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
  Copyrights licensed under the New BSD License.
  See the accompanying LICENSE file for terms.
  */
  
  /* jslint esnext: true */
  
  // Purposely using the same implementation as the Intl.js `Intl` polyfill.
  // Copyright 2013 Andy Earnshaw, MIT License
  
  var realDefineProp = function () {
      try {
          return !!Object.defineProperty({}, 'a', {});
      } catch (e) {
          return false;
      }
  }();
  
  var es3 = !realDefineProp && !Object.prototype.__defineGetter__;
  
  var defineProperty = realDefineProp ? Object.defineProperty : function (obj, name, desc) {
  
      if ('get' in desc && obj.__defineGetter__) {
          obj.__defineGetter__(name, desc.get);
      } else if (!hop.call(obj, name) || 'value' in desc) {
          obj[name] = desc.value;
      }
  };
  
  var objCreate = Object.create || function (proto, props) {
      var obj, k;
  
      function F() {}
      F.prototype = proto;
      obj = new F();
  
      for (k in props) {
          if (hop.call(props, k)) {
              defineProperty(obj, k, props[k]);
          }
      }
  
      return obj;
  };
  
  function Compiler(locales, formats, pluralFn) {
      this.locales = locales;
      this.formats = formats;
      this.pluralFn = pluralFn;
  }
  
  Compiler.prototype.compile = function (ast) {
      this.pluralStack = [];
      this.currentPlural = null;
      this.pluralNumberFormat = null;
  
      return this.compileMessage(ast);
  };
  
  Compiler.prototype.compileMessage = function (ast) {
      if (!(ast && ast.type === 'messageFormatPattern')) {
          throw new Error('Message AST is not of type: "messageFormatPattern"');
      }
  
      var elements = ast.elements,
          pattern = [];
  
      var i, len, element;
  
      for (i = 0, len = elements.length; i < len; i += 1) {
          element = elements[i];
  
          switch (element.type) {
              case 'messageTextElement':
                  pattern.push(this.compileMessageText(element));
                  break;
  
              case 'argumentElement':
                  pattern.push(this.compileArgument(element));
                  break;
  
              default:
                  throw new Error('Message element does not have a valid type');
          }
      }
  
      return pattern;
  };
  
  Compiler.prototype.compileMessageText = function (element) {
      // When this `element` is part of plural sub-pattern and its value contains
      // an unescaped '#', use a `PluralOffsetString` helper to properly output
      // the number with the correct offset in the string.
      if (this.currentPlural && /(^|[^\\])#/g.test(element.value)) {
          // Create a cache a NumberFormat instance that can be reused for any
          // PluralOffsetString instance in this message.
          if (!this.pluralNumberFormat) {
              this.pluralNumberFormat = new Intl.NumberFormat(this.locales);
          }
  
          return new PluralOffsetString(this.currentPlural.id, this.currentPlural.format.offset, this.pluralNumberFormat, element.value);
      }
  
      // Unescape the escaped '#'s in the message text.
      return element.value.replace(/\\#/g, '#');
  };
  
  Compiler.prototype.compileArgument = function (element) {
      var format = element.format;
  
      if (!format) {
          return new StringFormat(element.id);
      }
  
      var formats = this.formats,
          locales = this.locales,
          pluralFn = this.pluralFn,
          options;
  
      switch (format.type) {
          case 'numberFormat':
              options = formats.number[format.style];
              return {
                  id: element.id,
                  format: new Intl.NumberFormat(locales, options).format
              };
  
          case 'dateFormat':
              options = formats.date[format.style];
              return {
                  id: element.id,
                  format: new Intl.DateTimeFormat(locales, options).format
              };
  
          case 'timeFormat':
              options = formats.time[format.style];
              return {
                  id: element.id,
                  format: new Intl.DateTimeFormat(locales, options).format
              };
  
          case 'pluralFormat':
              options = this.compileOptions(element);
              return new PluralFormat(element.id, format.ordinal, format.offset, options, pluralFn);
  
          case 'selectFormat':
              options = this.compileOptions(element);
              return new SelectFormat(element.id, options);
  
          default:
              throw new Error('Message element does not have a valid format type');
      }
  };
  
  Compiler.prototype.compileOptions = function (element) {
      var format = element.format,
          options = format.options,
          optionsHash = {};
  
      // Save the current plural element, if any, then set it to a new value when
      // compiling the options sub-patterns. This conforms the spec's algorithm
      // for handling `"#"` syntax in message text.
      this.pluralStack.push(this.currentPlural);
      this.currentPlural = format.type === 'pluralFormat' ? element : null;
  
      var i, len, option;
  
      for (i = 0, len = options.length; i < len; i += 1) {
          option = options[i];
  
          // Compile the sub-pattern and save it under the options's selector.
          optionsHash[option.selector] = this.compileMessage(option.value);
      }
  
      // Pop the plural stack to put back the original current plural value.
      this.currentPlural = this.pluralStack.pop();
  
      return optionsHash;
  };
  
  // -- Compiler Helper Classes --------------------------------------------------
  
  function StringFormat(id) {
      this.id = id;
  }
  
  StringFormat.prototype.format = function (value) {
      if (!value) {
          return '';
      }
  
      return typeof value === 'string' ? value : String(value);
  };
  
  function PluralFormat(id, useOrdinal, offset, options, pluralFn) {
      this.id = id;
      this.useOrdinal = useOrdinal;
      this.offset = offset;
      this.options = options;
      this.pluralFn = pluralFn;
  }
  
  PluralFormat.prototype.getOption = function (value) {
      var options = this.options;
  
      var option = options['=' + value] || options[this.pluralFn(value - this.offset, this.useOrdinal)];
  
      return option || options.other;
  };
  
  function PluralOffsetString(id, offset, numberFormat, string) {
      this.id = id;
      this.offset = offset;
      this.numberFormat = numberFormat;
      this.string = string;
  }
  
  PluralOffsetString.prototype.format = function (value) {
      var number = this.numberFormat.format(value - this.offset);
  
      return this.string.replace(/(^|[^\\])#/g, '$1' + number).replace(/\\#/g, '#');
  };
  
  function SelectFormat(id, options) {
      this.id = id;
      this.options = options;
  }
  
  SelectFormat.prototype.getOption = function (value) {
      var options = this.options;
      return options[value] || options.other;
  };
  
  var parser = (function () {
    /*
     * Generated by PEG.js 0.8.0.
     *
     * http://pegjs.majda.cz/
     */
  
    function peg$subclass(child, parent) {
      function ctor() {
        this.constructor = child;
      }
      ctor.prototype = parent.prototype;
      child.prototype = new ctor();
    }
  
    function SyntaxError(message, expected, found, offset, line, column) {
      this.message = message;
      this.expected = expected;
      this.found = found;
      this.offset = offset;
      this.line = line;
      this.column = column;
  
      this.name = "SyntaxError";
    }
  
    peg$subclass(SyntaxError, Error);
  
    function parse(input) {
      var options = arguments.length > 1 ? arguments[1] : {},
          peg$FAILED = {},
          peg$startRuleFunctions = { start: peg$parsestart },
          peg$startRuleFunction = peg$parsestart,
          peg$c0 = [],
          peg$c1 = function peg$c1(elements) {
        return {
          type: 'messageFormatPattern',
          elements: elements
        };
      },
          peg$c2 = peg$FAILED,
          peg$c3 = function peg$c3(text) {
        var string = '',
            i,
            j,
            outerLen,
            inner,
            innerLen;
  
        for (i = 0, outerLen = text.length; i < outerLen; i += 1) {
          inner = text[i];
  
          for (j = 0, innerLen = inner.length; j < innerLen; j += 1) {
            string += inner[j];
          }
        }
  
        return string;
      },
          peg$c4 = function peg$c4(messageText) {
        return {
          type: 'messageTextElement',
          value: messageText
        };
      },
          peg$c5 = /^[^ \t\n\r,.+={}#]/,
          peg$c6 = { type: "class", value: "[^ \\t\\n\\r,.+={}#]", description: "[^ \\t\\n\\r,.+={}#]" },
          peg$c7 = "{",
          peg$c8 = { type: "literal", value: "{", description: "\"{\"" },
          peg$c9 = null,
          peg$c10 = ",",
          peg$c11 = { type: "literal", value: ",", description: "\",\"" },
          peg$c12 = "}",
          peg$c13 = { type: "literal", value: "}", description: "\"}\"" },
          peg$c14 = function peg$c14(id, format) {
        return {
          type: 'argumentElement',
          id: id,
          format: format && format[2]
        };
      },
          peg$c15 = "number",
          peg$c16 = { type: "literal", value: "number", description: "\"number\"" },
          peg$c17 = "date",
          peg$c18 = { type: "literal", value: "date", description: "\"date\"" },
          peg$c19 = "time",
          peg$c20 = { type: "literal", value: "time", description: "\"time\"" },
          peg$c21 = function peg$c21(type, style) {
        return {
          type: type + 'Format',
          style: style && style[2]
        };
      },
          peg$c22 = "plural",
          peg$c23 = { type: "literal", value: "plural", description: "\"plural\"" },
          peg$c24 = function peg$c24(pluralStyle) {
        return {
          type: pluralStyle.type,
          ordinal: false,
          offset: pluralStyle.offset || 0,
          options: pluralStyle.options
        };
      },
          peg$c25 = "selectordinal",
          peg$c26 = { type: "literal", value: "selectordinal", description: "\"selectordinal\"" },
          peg$c27 = function peg$c27(pluralStyle) {
        return {
          type: pluralStyle.type,
          ordinal: true,
          offset: pluralStyle.offset || 0,
          options: pluralStyle.options
        };
      },
          peg$c28 = "select",
          peg$c29 = { type: "literal", value: "select", description: "\"select\"" },
          peg$c30 = function peg$c30(options) {
        return {
          type: 'selectFormat',
          options: options
        };
      },
          peg$c31 = "=",
          peg$c32 = { type: "literal", value: "=", description: "\"=\"" },
          peg$c33 = function peg$c33(selector, pattern) {
        return {
          type: 'optionalFormatPattern',
          selector: selector,
          value: pattern
        };
      },
          peg$c34 = "offset:",
          peg$c35 = { type: "literal", value: "offset:", description: "\"offset:\"" },
          peg$c36 = function peg$c36(number) {
        return number;
      },
          peg$c37 = function peg$c37(offset, options) {
        return {
          type: 'pluralFormat',
          offset: offset,
          options: options
        };
      },
          peg$c38 = { type: "other", description: "whitespace" },
          peg$c39 = /^[ \t\n\r]/,
          peg$c40 = { type: "class", value: "[ \\t\\n\\r]", description: "[ \\t\\n\\r]" },
          peg$c41 = { type: "other", description: "optionalWhitespace" },
          peg$c42 = /^[0-9]/,
          peg$c43 = { type: "class", value: "[0-9]", description: "[0-9]" },
          peg$c44 = /^[0-9a-f]/i,
          peg$c45 = { type: "class", value: "[0-9a-f]i", description: "[0-9a-f]i" },
          peg$c46 = "0",
          peg$c47 = { type: "literal", value: "0", description: "\"0\"" },
          peg$c48 = /^[1-9]/,
          peg$c49 = { type: "class", value: "[1-9]", description: "[1-9]" },
          peg$c50 = function peg$c50(digits) {
        return parseInt(digits, 10);
      },
          peg$c51 = /^[^{}\\\0-\x1F \t\n\r]/,
          peg$c52 = { type: "class", value: "[^{}\\\\\\0-\\x1F \\t\\n\\r]", description: "[^{}\\\\\\0-\\x1F \\t\\n\\r]" },
          peg$c53 = "\\\\",
          peg$c54 = { type: "literal", value: "\\\\", description: "\"\\\\\\\\\"" },
          peg$c55 = function peg$c55() {
        return '\\';
      },
          peg$c56 = "\\#",
          peg$c57 = { type: "literal", value: "\\#", description: "\"\\\\#\"" },
          peg$c58 = function peg$c58() {
        return '\\#';
      },
          peg$c59 = "\\{",
          peg$c60 = { type: "literal", value: "\\{", description: "\"\\\\{\"" },
          peg$c61 = function peg$c61() {
        return '{';
      },
          peg$c62 = "\\}",
          peg$c63 = { type: "literal", value: "\\}", description: "\"\\\\}\"" },
          peg$c64 = function peg$c64() {
        return '}';
      },
          peg$c65 = '\\u',
          peg$c66 = { type: "literal", value: '\\u', description: '"\\\\u"' },
          peg$c67 = function peg$c67(digits) {
        return String.fromCharCode(parseInt(digits, 16));
      },
          peg$c68 = function peg$c68(chars) {
        return chars.join('');
      },
          peg$currPos = 0,
          peg$reportedPos = 0,
          peg$cachedPos = 0,
          peg$cachedPosDetails = { line: 1, column: 1, seenCR: false },
          peg$maxFailPos = 0,
          peg$maxFailExpected = [],
          peg$silentFails = 0,
          peg$result;
  
      if ("startRule" in options) {
        if (!(options.startRule in peg$startRuleFunctions)) {
          throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
        }
  
        peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
      }
  
      function text() {
        return input.substring(peg$reportedPos, peg$currPos);
      }
  
      function offset() {
        return peg$reportedPos;
      }
  
      function line() {
        return peg$computePosDetails(peg$reportedPos).line;
      }
  
      function column() {
        return peg$computePosDetails(peg$reportedPos).column;
      }
  
      function expected(description) {
        throw peg$buildException(null, [{ type: "other", description: description }], peg$reportedPos);
      }
  
      function error(message) {
        throw peg$buildException(message, null, peg$reportedPos);
      }
  
      function peg$computePosDetails(pos) {
        function advance(details, startPos, endPos) {
          var p, ch;
  
          for (p = startPos; p < endPos; p++) {
            ch = input.charAt(p);
            if (ch === "\n") {
              if (!details.seenCR) {
                details.line++;
              }
              details.column = 1;
              details.seenCR = false;
            } else if (ch === "\r" || ch === '\u2028' || ch === '\u2029') {
              details.line++;
              details.column = 1;
              details.seenCR = true;
            } else {
              details.column++;
              details.seenCR = false;
            }
          }
        }
  
        if (peg$cachedPos !== pos) {
          if (peg$cachedPos > pos) {
            peg$cachedPos = 0;
            peg$cachedPosDetails = { line: 1, column: 1, seenCR: false };
          }
          advance(peg$cachedPosDetails, peg$cachedPos, pos);
          peg$cachedPos = pos;
        }
  
        return peg$cachedPosDetails;
      }
  
      function peg$fail(expected) {
        if (peg$currPos < peg$maxFailPos) {
          return;
        }
  
        if (peg$currPos > peg$maxFailPos) {
          peg$maxFailPos = peg$currPos;
          peg$maxFailExpected = [];
        }
  
        peg$maxFailExpected.push(expected);
      }
  
      function peg$buildException(message, expected, pos) {
        function cleanupExpected(expected) {
          var i = 1;
  
          expected.sort(function (a, b) {
            if (a.description < b.description) {
              return -1;
            } else if (a.description > b.description) {
              return 1;
            } else {
              return 0;
            }
          });
  
          while (i < expected.length) {
            if (expected[i - 1] === expected[i]) {
              expected.splice(i, 1);
            } else {
              i++;
            }
          }
        }
  
        function buildMessage(expected, found) {
          function stringEscape(s) {
            function hex(ch) {
              return ch.charCodeAt(0).toString(16).toUpperCase();
            }
  
            return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\x08/g, '\\b').replace(/\t/g, '\\t').replace(/\n/g, '\\n').replace(/\f/g, '\\f').replace(/\r/g, '\\r').replace(/[\x00-\x07\x0B\x0E\x0F]/g, function (ch) {
              return '\\x0' + hex(ch);
            }).replace(/[\x10-\x1F\x80-\xFF]/g, function (ch) {
              return '\\x' + hex(ch);
            }).replace(/[\u0180-\u0FFF]/g, function (ch) {
              return '\\u0' + hex(ch);
            }).replace(/[\u1080-\uFFFF]/g, function (ch) {
              return '\\u' + hex(ch);
            });
          }
  
          var expectedDescs = new Array(expected.length),
              expectedDesc,
              foundDesc,
              i;
  
          for (i = 0; i < expected.length; i++) {
            expectedDescs[i] = expected[i].description;
          }
  
          expectedDesc = expected.length > 1 ? expectedDescs.slice(0, -1).join(", ") + " or " + expectedDescs[expected.length - 1] : expectedDescs[0];
  
          foundDesc = found ? "\"" + stringEscape(found) + "\"" : "end of input";
  
          return "Expected " + expectedDesc + " but " + foundDesc + " found.";
        }
  
        var posDetails = peg$computePosDetails(pos),
            found = pos < input.length ? input.charAt(pos) : null;
  
        if (expected !== null) {
          cleanupExpected(expected);
        }
  
        return new SyntaxError(message !== null ? message : buildMessage(expected, found), expected, found, pos, posDetails.line, posDetails.column);
      }
  
      function peg$parsestart() {
        var s0;
  
        s0 = peg$parsemessageFormatPattern();
  
        return s0;
      }
  
      function peg$parsemessageFormatPattern() {
        var s0, s1, s2;
  
        s0 = peg$currPos;
        s1 = [];
        s2 = peg$parsemessageFormatElement();
        while (s2 !== peg$FAILED) {
          s1.push(s2);
          s2 = peg$parsemessageFormatElement();
        }
        if (s1 !== peg$FAILED) {
          peg$reportedPos = s0;
          s1 = peg$c1(s1);
        }
        s0 = s1;
  
        return s0;
      }
  
      function peg$parsemessageFormatElement() {
        var s0;
  
        s0 = peg$parsemessageTextElement();
        if (s0 === peg$FAILED) {
          s0 = peg$parseargumentElement();
        }
  
        return s0;
      }
  
      function peg$parsemessageText() {
        var s0, s1, s2, s3, s4, s5;
  
        s0 = peg$currPos;
        s1 = [];
        s2 = peg$currPos;
        s3 = peg$parse_();
        if (s3 !== peg$FAILED) {
          s4 = peg$parsechars();
          if (s4 !== peg$FAILED) {
            s5 = peg$parse_();
            if (s5 !== peg$FAILED) {
              s3 = [s3, s4, s5];
              s2 = s3;
            } else {
              peg$currPos = s2;
              s2 = peg$c2;
            }
          } else {
            peg$currPos = s2;
            s2 = peg$c2;
          }
        } else {
          peg$currPos = s2;
          s2 = peg$c2;
        }
        if (s2 !== peg$FAILED) {
          while (s2 !== peg$FAILED) {
            s1.push(s2);
            s2 = peg$currPos;
            s3 = peg$parse_();
            if (s3 !== peg$FAILED) {
              s4 = peg$parsechars();
              if (s4 !== peg$FAILED) {
                s5 = peg$parse_();
                if (s5 !== peg$FAILED) {
                  s3 = [s3, s4, s5];
                  s2 = s3;
                } else {
                  peg$currPos = s2;
                  s2 = peg$c2;
                }
              } else {
                peg$currPos = s2;
                s2 = peg$c2;
              }
            } else {
              peg$currPos = s2;
              s2 = peg$c2;
            }
          }
        } else {
          s1 = peg$c2;
        }
        if (s1 !== peg$FAILED) {
          peg$reportedPos = s0;
          s1 = peg$c3(s1);
        }
        s0 = s1;
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = peg$parsews();
          if (s1 !== peg$FAILED) {
            s1 = input.substring(s0, peg$currPos);
          }
          s0 = s1;
        }
  
        return s0;
      }
  
      function peg$parsemessageTextElement() {
        var s0, s1;
  
        s0 = peg$currPos;
        s1 = peg$parsemessageText();
        if (s1 !== peg$FAILED) {
          peg$reportedPos = s0;
          s1 = peg$c4(s1);
        }
        s0 = s1;
  
        return s0;
      }
  
      function peg$parseargument() {
        var s0, s1, s2;
  
        s0 = peg$parsenumber();
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = [];
          if (peg$c5.test(input.charAt(peg$currPos))) {
            s2 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s2 = peg$FAILED;
            if (peg$silentFails === 0) {
              peg$fail(peg$c6);
            }
          }
          if (s2 !== peg$FAILED) {
            while (s2 !== peg$FAILED) {
              s1.push(s2);
              if (peg$c5.test(input.charAt(peg$currPos))) {
                s2 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s2 = peg$FAILED;
                if (peg$silentFails === 0) {
                  peg$fail(peg$c6);
                }
              }
            }
          } else {
            s1 = peg$c2;
          }
          if (s1 !== peg$FAILED) {
            s1 = input.substring(s0, peg$currPos);
          }
          s0 = s1;
        }
  
        return s0;
      }
  
      function peg$parseargumentElement() {
        var s0, s1, s2, s3, s4, s5, s6, s7, s8;
  
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 123) {
          s1 = peg$c7;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c8);
          }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_();
          if (s2 !== peg$FAILED) {
            s3 = peg$parseargument();
            if (s3 !== peg$FAILED) {
              s4 = peg$parse_();
              if (s4 !== peg$FAILED) {
                s5 = peg$currPos;
                if (input.charCodeAt(peg$currPos) === 44) {
                  s6 = peg$c10;
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) {
                    peg$fail(peg$c11);
                  }
                }
                if (s6 !== peg$FAILED) {
                  s7 = peg$parse_();
                  if (s7 !== peg$FAILED) {
                    s8 = peg$parseelementFormat();
                    if (s8 !== peg$FAILED) {
                      s6 = [s6, s7, s8];
                      s5 = s6;
                    } else {
                      peg$currPos = s5;
                      s5 = peg$c2;
                    }
                  } else {
                    peg$currPos = s5;
                    s5 = peg$c2;
                  }
                } else {
                  peg$currPos = s5;
                  s5 = peg$c2;
                }
                if (s5 === peg$FAILED) {
                  s5 = peg$c9;
                }
                if (s5 !== peg$FAILED) {
                  s6 = peg$parse_();
                  if (s6 !== peg$FAILED) {
                    if (input.charCodeAt(peg$currPos) === 125) {
                      s7 = peg$c12;
                      peg$currPos++;
                    } else {
                      s7 = peg$FAILED;
                      if (peg$silentFails === 0) {
                        peg$fail(peg$c13);
                      }
                    }
                    if (s7 !== peg$FAILED) {
                      peg$reportedPos = s0;
                      s1 = peg$c14(s3, s5);
                      s0 = s1;
                    } else {
                      peg$currPos = s0;
                      s0 = peg$c2;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$c2;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$c2;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$c2;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parseelementFormat() {
        var s0;
  
        s0 = peg$parsesimpleFormat();
        if (s0 === peg$FAILED) {
          s0 = peg$parsepluralFormat();
          if (s0 === peg$FAILED) {
            s0 = peg$parseselectOrdinalFormat();
            if (s0 === peg$FAILED) {
              s0 = peg$parseselectFormat();
            }
          }
        }
  
        return s0;
      }
  
      function peg$parsesimpleFormat() {
        var s0, s1, s2, s3, s4, s5, s6;
  
        s0 = peg$currPos;
        if (input.substr(peg$currPos, 6) === peg$c15) {
          s1 = peg$c15;
          peg$currPos += 6;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c16);
          }
        }
        if (s1 === peg$FAILED) {
          if (input.substr(peg$currPos, 4) === peg$c17) {
            s1 = peg$c17;
            peg$currPos += 4;
          } else {
            s1 = peg$FAILED;
            if (peg$silentFails === 0) {
              peg$fail(peg$c18);
            }
          }
          if (s1 === peg$FAILED) {
            if (input.substr(peg$currPos, 4) === peg$c19) {
              s1 = peg$c19;
              peg$currPos += 4;
            } else {
              s1 = peg$FAILED;
              if (peg$silentFails === 0) {
                peg$fail(peg$c20);
              }
            }
          }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_();
          if (s2 !== peg$FAILED) {
            s3 = peg$currPos;
            if (input.charCodeAt(peg$currPos) === 44) {
              s4 = peg$c10;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) {
                peg$fail(peg$c11);
              }
            }
            if (s4 !== peg$FAILED) {
              s5 = peg$parse_();
              if (s5 !== peg$FAILED) {
                s6 = peg$parsechars();
                if (s6 !== peg$FAILED) {
                  s4 = [s4, s5, s6];
                  s3 = s4;
                } else {
                  peg$currPos = s3;
                  s3 = peg$c2;
                }
              } else {
                peg$currPos = s3;
                s3 = peg$c2;
              }
            } else {
              peg$currPos = s3;
              s3 = peg$c2;
            }
            if (s3 === peg$FAILED) {
              s3 = peg$c9;
            }
            if (s3 !== peg$FAILED) {
              peg$reportedPos = s0;
              s1 = peg$c21(s1, s3);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parsepluralFormat() {
        var s0, s1, s2, s3, s4, s5;
  
        s0 = peg$currPos;
        if (input.substr(peg$currPos, 6) === peg$c22) {
          s1 = peg$c22;
          peg$currPos += 6;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c23);
          }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_();
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 44) {
              s3 = peg$c10;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) {
                peg$fail(peg$c11);
              }
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$parse_();
              if (s4 !== peg$FAILED) {
                s5 = peg$parsepluralStyle();
                if (s5 !== peg$FAILED) {
                  peg$reportedPos = s0;
                  s1 = peg$c24(s5);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$c2;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$c2;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parseselectOrdinalFormat() {
        var s0, s1, s2, s3, s4, s5;
  
        s0 = peg$currPos;
        if (input.substr(peg$currPos, 13) === peg$c25) {
          s1 = peg$c25;
          peg$currPos += 13;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c26);
          }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_();
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 44) {
              s3 = peg$c10;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) {
                peg$fail(peg$c11);
              }
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$parse_();
              if (s4 !== peg$FAILED) {
                s5 = peg$parsepluralStyle();
                if (s5 !== peg$FAILED) {
                  peg$reportedPos = s0;
                  s1 = peg$c27(s5);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$c2;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$c2;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parseselectFormat() {
        var s0, s1, s2, s3, s4, s5, s6;
  
        s0 = peg$currPos;
        if (input.substr(peg$currPos, 6) === peg$c28) {
          s1 = peg$c28;
          peg$currPos += 6;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c29);
          }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_();
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 44) {
              s3 = peg$c10;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) {
                peg$fail(peg$c11);
              }
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$parse_();
              if (s4 !== peg$FAILED) {
                s5 = [];
                s6 = peg$parseoptionalFormatPattern();
                if (s6 !== peg$FAILED) {
                  while (s6 !== peg$FAILED) {
                    s5.push(s6);
                    s6 = peg$parseoptionalFormatPattern();
                  }
                } else {
                  s5 = peg$c2;
                }
                if (s5 !== peg$FAILED) {
                  peg$reportedPos = s0;
                  s1 = peg$c30(s5);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$c2;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$c2;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parseselector() {
        var s0, s1, s2, s3;
  
        s0 = peg$currPos;
        s1 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 61) {
          s2 = peg$c31;
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c32);
          }
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parsenumber();
          if (s3 !== peg$FAILED) {
            s2 = [s2, s3];
            s1 = s2;
          } else {
            peg$currPos = s1;
            s1 = peg$c2;
          }
        } else {
          peg$currPos = s1;
          s1 = peg$c2;
        }
        if (s1 !== peg$FAILED) {
          s1 = input.substring(s0, peg$currPos);
        }
        s0 = s1;
        if (s0 === peg$FAILED) {
          s0 = peg$parsechars();
        }
  
        return s0;
      }
  
      function peg$parseoptionalFormatPattern() {
        var s0, s1, s2, s3, s4, s5, s6, s7, s8;
  
        s0 = peg$currPos;
        s1 = peg$parse_();
        if (s1 !== peg$FAILED) {
          s2 = peg$parseselector();
          if (s2 !== peg$FAILED) {
            s3 = peg$parse_();
            if (s3 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 123) {
                s4 = peg$c7;
                peg$currPos++;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) {
                  peg$fail(peg$c8);
                }
              }
              if (s4 !== peg$FAILED) {
                s5 = peg$parse_();
                if (s5 !== peg$FAILED) {
                  s6 = peg$parsemessageFormatPattern();
                  if (s6 !== peg$FAILED) {
                    s7 = peg$parse_();
                    if (s7 !== peg$FAILED) {
                      if (input.charCodeAt(peg$currPos) === 125) {
                        s8 = peg$c12;
                        peg$currPos++;
                      } else {
                        s8 = peg$FAILED;
                        if (peg$silentFails === 0) {
                          peg$fail(peg$c13);
                        }
                      }
                      if (s8 !== peg$FAILED) {
                        peg$reportedPos = s0;
                        s1 = peg$c33(s2, s6);
                        s0 = s1;
                      } else {
                        peg$currPos = s0;
                        s0 = peg$c2;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$c2;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$c2;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$c2;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$c2;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parseoffset() {
        var s0, s1, s2, s3;
  
        s0 = peg$currPos;
        if (input.substr(peg$currPos, 7) === peg$c34) {
          s1 = peg$c34;
          peg$currPos += 7;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c35);
          }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_();
          if (s2 !== peg$FAILED) {
            s3 = peg$parsenumber();
            if (s3 !== peg$FAILED) {
              peg$reportedPos = s0;
              s1 = peg$c36(s3);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parsepluralStyle() {
        var s0, s1, s2, s3, s4;
  
        s0 = peg$currPos;
        s1 = peg$parseoffset();
        if (s1 === peg$FAILED) {
          s1 = peg$c9;
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_();
          if (s2 !== peg$FAILED) {
            s3 = [];
            s4 = peg$parseoptionalFormatPattern();
            if (s4 !== peg$FAILED) {
              while (s4 !== peg$FAILED) {
                s3.push(s4);
                s4 = peg$parseoptionalFormatPattern();
              }
            } else {
              s3 = peg$c2;
            }
            if (s3 !== peg$FAILED) {
              peg$reportedPos = s0;
              s1 = peg$c37(s1, s3);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$c2;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$c2;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$c2;
        }
  
        return s0;
      }
  
      function peg$parsews() {
        var s0, s1;
  
        peg$silentFails++;
        s0 = [];
        if (peg$c39.test(input.charAt(peg$currPos))) {
          s1 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c40);
          }
        }
        if (s1 !== peg$FAILED) {
          while (s1 !== peg$FAILED) {
            s0.push(s1);
            if (peg$c39.test(input.charAt(peg$currPos))) {
              s1 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s1 = peg$FAILED;
              if (peg$silentFails === 0) {
                peg$fail(peg$c40);
              }
            }
          }
        } else {
          s0 = peg$c2;
        }
        peg$silentFails--;
        if (s0 === peg$FAILED) {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c38);
          }
        }
  
        return s0;
      }
  
      function peg$parse_() {
        var s0, s1, s2;
  
        peg$silentFails++;
        s0 = peg$currPos;
        s1 = [];
        s2 = peg$parsews();
        while (s2 !== peg$FAILED) {
          s1.push(s2);
          s2 = peg$parsews();
        }
        if (s1 !== peg$FAILED) {
          s1 = input.substring(s0, peg$currPos);
        }
        s0 = s1;
        peg$silentFails--;
        if (s0 === peg$FAILED) {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c41);
          }
        }
  
        return s0;
      }
  
      function peg$parsedigit() {
        var s0;
  
        if (peg$c42.test(input.charAt(peg$currPos))) {
          s0 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s0 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c43);
          }
        }
  
        return s0;
      }
  
      function peg$parsehexDigit() {
        var s0;
  
        if (peg$c44.test(input.charAt(peg$currPos))) {
          s0 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s0 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c45);
          }
        }
  
        return s0;
      }
  
      function peg$parsenumber() {
        var s0, s1, s2, s3, s4, s5;
  
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 48) {
          s1 = peg$c46;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c47);
          }
        }
        if (s1 === peg$FAILED) {
          s1 = peg$currPos;
          s2 = peg$currPos;
          if (peg$c48.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) {
              peg$fail(peg$c49);
            }
          }
          if (s3 !== peg$FAILED) {
            s4 = [];
            s5 = peg$parsedigit();
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              s5 = peg$parsedigit();
            }
            if (s4 !== peg$FAILED) {
              s3 = [s3, s4];
              s2 = s3;
            } else {
              peg$currPos = s2;
              s2 = peg$c2;
            }
          } else {
            peg$currPos = s2;
            s2 = peg$c2;
          }
          if (s2 !== peg$FAILED) {
            s2 = input.substring(s1, peg$currPos);
          }
          s1 = s2;
        }
        if (s1 !== peg$FAILED) {
          peg$reportedPos = s0;
          s1 = peg$c50(s1);
        }
        s0 = s1;
  
        return s0;
      }
  
      function peg$parsechar() {
        var s0, s1, s2, s3, s4, s5, s6, s7;
  
        if (peg$c51.test(input.charAt(peg$currPos))) {
          s0 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s0 = peg$FAILED;
          if (peg$silentFails === 0) {
            peg$fail(peg$c52);
          }
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          if (input.substr(peg$currPos, 2) === peg$c53) {
            s1 = peg$c53;
            peg$currPos += 2;
          } else {
            s1 = peg$FAILED;
            if (peg$silentFails === 0) {
              peg$fail(peg$c54);
            }
          }
          if (s1 !== peg$FAILED) {
            peg$reportedPos = s0;
            s1 = peg$c55();
          }
          s0 = s1;
          if (s0 === peg$FAILED) {
            s0 = peg$currPos;
            if (input.substr(peg$currPos, 2) === peg$c56) {
              s1 = peg$c56;
              peg$currPos += 2;
            } else {
              s1 = peg$FAILED;
              if (peg$silentFails === 0) {
                peg$fail(peg$c57);
              }
            }
            if (s1 !== peg$FAILED) {
              peg$reportedPos = s0;
              s1 = peg$c58();
            }
            s0 = s1;
            if (s0 === peg$FAILED) {
              s0 = peg$currPos;
              if (input.substr(peg$currPos, 2) === peg$c59) {
                s1 = peg$c59;
                peg$currPos += 2;
              } else {
                s1 = peg$FAILED;
                if (peg$silentFails === 0) {
                  peg$fail(peg$c60);
                }
              }
              if (s1 !== peg$FAILED) {
                peg$reportedPos = s0;
                s1 = peg$c61();
              }
              s0 = s1;
              if (s0 === peg$FAILED) {
                s0 = peg$currPos;
                if (input.substr(peg$currPos, 2) === peg$c62) {
                  s1 = peg$c62;
                  peg$currPos += 2;
                } else {
                  s1 = peg$FAILED;
                  if (peg$silentFails === 0) {
                    peg$fail(peg$c63);
                  }
                }
                if (s1 !== peg$FAILED) {
                  peg$reportedPos = s0;
                  s1 = peg$c64();
                }
                s0 = s1;
                if (s0 === peg$FAILED) {
                  s0 = peg$currPos;
                  if (input.substr(peg$currPos, 2) === peg$c65) {
                    s1 = peg$c65;
                    peg$currPos += 2;
                  } else {
                    s1 = peg$FAILED;
                    if (peg$silentFails === 0) {
                      peg$fail(peg$c66);
                    }
                  }
                  if (s1 !== peg$FAILED) {
                    s2 = peg$currPos;
                    s3 = peg$currPos;
                    s4 = peg$parsehexDigit();
                    if (s4 !== peg$FAILED) {
                      s5 = peg$parsehexDigit();
                      if (s5 !== peg$FAILED) {
                        s6 = peg$parsehexDigit();
                        if (s6 !== peg$FAILED) {
                          s7 = peg$parsehexDigit();
                          if (s7 !== peg$FAILED) {
                            s4 = [s4, s5, s6, s7];
                            s3 = s4;
                          } else {
                            peg$currPos = s3;
                            s3 = peg$c2;
                          }
                        } else {
                          peg$currPos = s3;
                          s3 = peg$c2;
                        }
                      } else {
                        peg$currPos = s3;
                        s3 = peg$c2;
                      }
                    } else {
                      peg$currPos = s3;
                      s3 = peg$c2;
                    }
                    if (s3 !== peg$FAILED) {
                      s3 = input.substring(s2, peg$currPos);
                    }
                    s2 = s3;
                    if (s2 !== peg$FAILED) {
                      peg$reportedPos = s0;
                      s1 = peg$c67(s2);
                      s0 = s1;
                    } else {
                      peg$currPos = s0;
                      s0 = peg$c2;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$c2;
                  }
                }
              }
            }
          }
        }
  
        return s0;
      }
  
      function peg$parsechars() {
        var s0, s1, s2;
  
        s0 = peg$currPos;
        s1 = [];
        s2 = peg$parsechar();
        if (s2 !== peg$FAILED) {
          while (s2 !== peg$FAILED) {
            s1.push(s2);
            s2 = peg$parsechar();
          }
        } else {
          s1 = peg$c2;
        }
        if (s1 !== peg$FAILED) {
          peg$reportedPos = s0;
          s1 = peg$c68(s1);
        }
        s0 = s1;
  
        return s0;
      }
  
      peg$result = peg$startRuleFunction();
  
      if (peg$result !== peg$FAILED && peg$currPos === input.length) {
        return peg$result;
      } else {
        if (peg$result !== peg$FAILED && peg$currPos < input.length) {
          peg$fail({ type: "end", description: "end of input" });
        }
  
        throw peg$buildException(null, peg$maxFailExpected, peg$maxFailPos);
      }
    }
  
    return {
      SyntaxError: SyntaxError,
      parse: parse
    };
  })();
  
  /*
  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
  Copyrights licensed under the New BSD License.
  See the accompanying LICENSE file for terms.
  */
  
  /* jslint esnext: true */
  
  // -- MessageFormat --------------------------------------------------------
  
  function MessageFormat(message, locales, formats) {
      // Parse string messages into an AST.
      var ast = typeof message === 'string' ? MessageFormat.__parse(message) : message;
  
      if (!(ast && ast.type === 'messageFormatPattern')) {
          throw new TypeError('A message must be provided as a String or AST.');
      }
  
      // Creates a new object with the specified `formats` merged with the default
      // formats.
      formats = this._mergeFormats(MessageFormat.formats, formats);
  
      // Defined first because it's used to build the format pattern.
      defineProperty(this, '_locale', { value: this._resolveLocale(locales) });
  
      // Compile the `ast` to a pattern that is highly optimized for repeated
      // `format()` invocations. **Note:** This passes the `locales` set provided
      // to the constructor instead of just the resolved locale.
      var pluralFn = this._findPluralRuleFunction(this._locale);
      var pattern = this._compilePattern(ast, locales, formats, pluralFn);
  
      // "Bind" `format()` method to `this` so it can be passed by reference like
      // the other `Intl` APIs.
      var messageFormat = this;
      this.format = function (values) {
          return messageFormat._format(pattern, values);
      };
  }
  
  // Default format options used as the prototype of the `formats` provided to the
  // constructor. These are used when constructing the internal Intl.NumberFormat
  // and Intl.DateTimeFormat instances.
  defineProperty(MessageFormat, 'formats', {
      enumerable: true,
  
      value: {
          number: {
              'currency': {
                  style: 'currency'
              },
  
              'percent': {
                  style: 'percent'
              }
          },
  
          date: {
              'short': {
                  month: 'numeric',
                  day: 'numeric',
                  year: '2-digit'
              },
  
              'medium': {
                  month: 'short',
                  day: 'numeric',
                  year: 'numeric'
              },
  
              'long': {
                  month: 'long',
                  day: 'numeric',
                  year: 'numeric'
              },
  
              'full': {
                  weekday: 'long',
                  month: 'long',
                  day: 'numeric',
                  year: 'numeric'
              }
          },
  
          time: {
              'short': {
                  hour: 'numeric',
                  minute: 'numeric'
              },
  
              'medium': {
                  hour: 'numeric',
                  minute: 'numeric',
                  second: 'numeric'
              },
  
              'long': {
                  hour: 'numeric',
                  minute: 'numeric',
                  second: 'numeric',
                  timeZoneName: 'short'
              },
  
              'full': {
                  hour: 'numeric',
                  minute: 'numeric',
                  second: 'numeric',
                  timeZoneName: 'short'
              }
          }
      }
  });
  
  // Define internal private properties for dealing with locale data.
  defineProperty(MessageFormat, '__localeData__', { value: objCreate(null) });
  defineProperty(MessageFormat, '__addLocaleData', { value: function value(data) {
          if (!(data && data.locale)) {
              throw new Error('Locale data provided to IntlMessageFormat is missing a ' + '`locale` property');
          }
  
          MessageFormat.__localeData__[data.locale.toLowerCase()] = data;
      } });
  
  // Defines `__parse()` static method as an exposed private.
  defineProperty(MessageFormat, '__parse', { value: parser.parse });
  
  // Define public `defaultLocale` property which defaults to English, but can be
  // set by the developer.
  defineProperty(MessageFormat, 'defaultLocale', {
      enumerable: true,
      writable: true,
      value: undefined
  });
  
  MessageFormat.prototype.resolvedOptions = function () {
      // TODO: Provide anything else?
      return {
          locale: this._locale
      };
  };
  
  MessageFormat.prototype._compilePattern = function (ast, locales, formats, pluralFn) {
      var compiler = new Compiler(locales, formats, pluralFn);
      return compiler.compile(ast);
  };
  
  MessageFormat.prototype._findPluralRuleFunction = function (locale) {
      var localeData = MessageFormat.__localeData__;
      var data = localeData[locale.toLowerCase()];
  
      // The locale data is de-duplicated, so we have to traverse the locale's
      // hierarchy until we find a `pluralRuleFunction` to return.
      while (data) {
          if (data.pluralRuleFunction) {
              return data.pluralRuleFunction;
          }
  
          data = data.parentLocale && localeData[data.parentLocale.toLowerCase()];
      }
  
      throw new Error('Locale data added to IntlMessageFormat is missing a ' + '`pluralRuleFunction` for :' + locale);
  };
  
  MessageFormat.prototype._format = function (pattern, values) {
      var result = '',
          i,
          len,
          part,
          id,
          value;
  
      for (i = 0, len = pattern.length; i < len; i += 1) {
          part = pattern[i];
  
          // Exist early for string parts.
          if (typeof part === 'string') {
              result += part;
              continue;
          }
  
          id = part.id;
  
          // Enforce that all required values are provided by the caller.
          if (!(values && hop.call(values, id))) {
              throw new Error('A value must be provided for: ' + id);
          }
  
          value = values[id];
  
          // Recursively format plural and select parts' option — which can be a
          // nested pattern structure. The choosing of the option to use is
          // abstracted-by and delegated-to the part helper object.
          if (part.options) {
              result += this._format(part.getOption(value), values);
          } else {
              result += part.format(value);
          }
      }
  
      return result;
  };
  
  MessageFormat.prototype._mergeFormats = function (defaults, formats) {
      var mergedFormats = {},
          type,
          mergedType;
  
      for (type in defaults) {
          if (!hop.call(defaults, type)) {
              continue;
          }
  
          mergedFormats[type] = mergedType = objCreate(defaults[type]);
  
          if (formats && hop.call(formats, type)) {
              extend(mergedType, formats[type]);
          }
      }
  
      return mergedFormats;
  };
  
  MessageFormat.prototype._resolveLocale = function (locales) {
      if (typeof locales === 'string') {
          locales = [locales];
      }
  
      // Create a copy of the array so we can push on the default locale.
      locales = (locales || []).concat(MessageFormat.defaultLocale);
  
      var localeData = MessageFormat.__localeData__;
      var i, len, localeParts, data;
  
      // Using the set of locales + the default locale, we look for the first one
      // which that has been registered. When data does not exist for a locale, we
      // traverse its ancestors to find something that's been registered within
      // its hierarchy of locales. Since we lack the proper `parentLocale` data
      // here, we must take a naive approach to traversal.
      for (i = 0, len = locales.length; i < len; i += 1) {
          localeParts = locales[i].toLowerCase().split('-');
  
          while (localeParts.length) {
              data = localeData[localeParts.join('-')];
              if (data) {
                  // Return the normalized locale string; e.g., we return "en-US",
                  // instead of "en-us".
                  return data.locale;
              }
  
              localeParts.pop();
          }
      }
  
      var defaultLocale = locales.pop();
      throw new Error('No locale data has been added to IntlMessageFormat for: ' + locales.join(', ') + ', or the default locale: ' + defaultLocale);
  };
  
  // GENERATED FILE
  var defaultLocale = { "locale": "en", "pluralRuleFunction": function pluralRuleFunction(n, ord) {
      var s = String(n).split("."),
          v0 = !s[1],
          t0 = Number(s[0]) == n,
          n10 = t0 && s[0].slice(-1),
          n100 = t0 && s[0].slice(-2);if (ord) return n10 == 1 && n100 != 11 ? "one" : n10 == 2 && n100 != 12 ? "two" : n10 == 3 && n100 != 13 ? "few" : "other";return n == 1 && v0 ? "one" : "other";
    } };
  
  /* jslint esnext: true */
  
  MessageFormat.__addLocaleData(defaultLocale);
  MessageFormat.defaultLocale = 'en';
  
  /*
  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
  Copyrights licensed under the New BSD License.
  See the accompanying LICENSE file for terms.
  */
  
  /* jslint esnext: true */
  
  var round = Math.round;
  
  function daysToYears(days) {
      // 400 years have 146097 days (taking into account leap year rules)
      return days * 400 / 146097;
  }
  
  function diff (from, to) {
      // Convert to ms timestamps.
      from = +from;
      to = +to;
  
      var millisecond = round(to - from),
          second = round(millisecond / 1000),
          minute = round(second / 60),
          hour = round(minute / 60),
          day = round(hour / 24),
          week = round(day / 7);
  
      var rawYears = daysToYears(day),
          month = round(rawYears * 12),
          year = round(rawYears);
  
      return {
          millisecond: millisecond,
          second: second,
          minute: minute,
          hour: hour,
          day: day,
          week: week,
          month: month,
          year: year
      };
  }
  
  // Purposely using the same implementation as the Intl.js `Intl` polyfill.
  // Copyright 2013 Andy Earnshaw, MIT License
  
  var hop$1 = Object.prototype.hasOwnProperty;
  var toString = Object.prototype.toString;
  
  var realDefineProp$1 = function () {
      try {
          return !!Object.defineProperty({}, 'a', {});
      } catch (e) {
          return false;
      }
  }();
  
  var es3$1 = !realDefineProp$1 && !Object.prototype.__defineGetter__;
  
  var defineProperty$1 = realDefineProp$1 ? Object.defineProperty : function (obj, name, desc) {
  
      if ('get' in desc && obj.__defineGetter__) {
          obj.__defineGetter__(name, desc.get);
      } else if (!hop$1.call(obj, name) || 'value' in desc) {
          obj[name] = desc.value;
      }
  };
  
  var objCreate$1 = Object.create || function (proto, props) {
      var obj, k;
  
      function F() {}
      F.prototype = proto;
      obj = new F();
  
      for (k in props) {
          if (hop$1.call(props, k)) {
              defineProperty$1(obj, k, props[k]);
          }
      }
  
      return obj;
  };
  
  var arrIndexOf = Array.prototype.indexOf || function (search, fromIndex) {
      /*jshint validthis:true */
      var arr = this;
      if (!arr.length) {
          return -1;
      }
  
      for (var i = fromIndex || 0, max = arr.length; i < max; i++) {
          if (arr[i] === search) {
              return i;
          }
      }
  
      return -1;
  };
  
  var isArray = Array.isArray || function (obj) {
      return toString.call(obj) === '[object Array]';
  };
  
  var dateNow = Date.now || function () {
      return new Date().getTime();
  };
  
  /*
  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
  Copyrights licensed under the New BSD License.
  See the accompanying LICENSE file for terms.
  */
  
  /* jslint esnext: true */
  
  // -----------------------------------------------------------------------------
  
  var FIELDS = ['second', 'minute', 'hour', 'day', 'month', 'year'];
  var STYLES = ['best fit', 'numeric'];
  
  // -- RelativeFormat -----------------------------------------------------------
  
  function RelativeFormat(locales, options) {
      options = options || {};
  
      // Make a copy of `locales` if it's an array, so that it doesn't change
      // since it's used lazily.
      if (isArray(locales)) {
          locales = locales.concat();
      }
  
      defineProperty$1(this, '_locale', { value: this._resolveLocale(locales) });
      defineProperty$1(this, '_options', { value: {
              style: this._resolveStyle(options.style),
              units: this._isValidUnits(options.units) && options.units
          } });
  
      defineProperty$1(this, '_locales', { value: locales });
      defineProperty$1(this, '_fields', { value: this._findFields(this._locale) });
      defineProperty$1(this, '_messages', { value: objCreate$1(null) });
  
      // "Bind" `format()` method to `this` so it can be passed by reference like
      // the other `Intl` APIs.
      var relativeFormat = this;
      this.format = function format(date, options) {
          return relativeFormat._format(date, options);
      };
  }
  
  // Define internal private properties for dealing with locale data.
  defineProperty$1(RelativeFormat, '__localeData__', { value: objCreate$1(null) });
  defineProperty$1(RelativeFormat, '__addLocaleData', { value: function value(data) {
          if (!(data && data.locale)) {
              throw new Error('Locale data provided to IntlRelativeFormat is missing a ' + '`locale` property value');
          }
  
          RelativeFormat.__localeData__[data.locale.toLowerCase()] = data;
  
          // Add data to IntlMessageFormat.
          MessageFormat.__addLocaleData(data);
      } });
  
  // Define public `defaultLocale` property which can be set by the developer, or
  // it will be set when the first RelativeFormat instance is created by
  // leveraging the resolved locale from `Intl`.
  defineProperty$1(RelativeFormat, 'defaultLocale', {
      enumerable: true,
      writable: true,
      value: undefined
  });
  
  // Define public `thresholds` property which can be set by the developer, and
  // defaults to relative time thresholds from moment.js.
  defineProperty$1(RelativeFormat, 'thresholds', {
      enumerable: true,
  
      value: {
          second: 45, // seconds to minute
          minute: 45, // minutes to hour
          hour: 22, // hours to day
          day: 26, // days to month
          month: 11 // months to year
      }
  });
  
  RelativeFormat.prototype.resolvedOptions = function () {
      return {
          locale: this._locale,
          style: this._options.style,
          units: this._options.units
      };
  };
  
  RelativeFormat.prototype._compileMessage = function (units) {
      // `this._locales` is the original set of locales the user specified to the
      // constructor, while `this._locale` is the resolved root locale.
      var locales = this._locales;
      var resolvedLocale = this._locale;
  
      var field = this._fields[units];
      var relativeTime = field.relativeTime;
      var future = '';
      var past = '';
      var i;
  
      for (i in relativeTime.future) {
          if (relativeTime.future.hasOwnProperty(i)) {
              future += ' ' + i + ' {' + relativeTime.future[i].replace('{0}', '#') + '}';
          }
      }
  
      for (i in relativeTime.past) {
          if (relativeTime.past.hasOwnProperty(i)) {
              past += ' ' + i + ' {' + relativeTime.past[i].replace('{0}', '#') + '}';
          }
      }
  
      var message = '{when, select, future {{0, plural, ' + future + '}}' + 'past {{0, plural, ' + past + '}}}';
  
      // Create the synthetic IntlMessageFormat instance using the original
      // locales value specified by the user when constructing the the parent
      // IntlRelativeFormat instance.
      return new MessageFormat(message, locales);
  };
  
  RelativeFormat.prototype._getMessage = function (units) {
      var messages = this._messages;
  
      // Create a new synthetic message based on the locale data from CLDR.
      if (!messages[units]) {
          messages[units] = this._compileMessage(units);
      }
  
      return messages[units];
  };
  
  RelativeFormat.prototype._getRelativeUnits = function (diff, units) {
      var field = this._fields[units];
  
      if (field.relative) {
          return field.relative[diff];
      }
  };
  
  RelativeFormat.prototype._findFields = function (locale) {
      var localeData = RelativeFormat.__localeData__;
      var data = localeData[locale.toLowerCase()];
  
      // The locale data is de-duplicated, so we have to traverse the locale's
      // hierarchy until we find `fields` to return.
      while (data) {
          if (data.fields) {
              return data.fields;
          }
  
          data = data.parentLocale && localeData[data.parentLocale.toLowerCase()];
      }
  
      throw new Error('Locale data added to IntlRelativeFormat is missing `fields` for :' + locale);
  };
  
  RelativeFormat.prototype._format = function (date, options) {
      var now = options && options.now !== undefined ? options.now : dateNow();
  
      if (date === undefined) {
          date = now;
      }
  
      // Determine if the `date` and optional `now` values are valid, and throw a
      // similar error to what `Intl.DateTimeFormat#format()` would throw.
      if (!isFinite(now)) {
          throw new RangeError('The `now` option provided to IntlRelativeFormat#format() is not ' + 'in valid range.');
      }
  
      if (!isFinite(date)) {
          throw new RangeError('The date value provided to IntlRelativeFormat#format() is not ' + 'in valid range.');
      }
  
      var diffReport = diff(now, date);
      var units = this._options.units || this._selectUnits(diffReport);
      var diffInUnits = diffReport[units];
  
      if (this._options.style !== 'numeric') {
          var relativeUnits = this._getRelativeUnits(diffInUnits, units);
          if (relativeUnits) {
              return relativeUnits;
          }
      }
  
      return this._getMessage(units).format({
          '0': Math.abs(diffInUnits),
          when: diffInUnits < 0 ? 'past' : 'future'
      });
  };
  
  RelativeFormat.prototype._isValidUnits = function (units) {
      if (!units || arrIndexOf.call(FIELDS, units) >= 0) {
          return true;
      }
  
      if (typeof units === 'string') {
          var suggestion = /s$/.test(units) && units.substr(0, units.length - 1);
          if (suggestion && arrIndexOf.call(FIELDS, suggestion) >= 0) {
              throw new Error('"' + units + '" is not a valid IntlRelativeFormat `units` ' + 'value, did you mean: ' + suggestion);
          }
      }
  
      throw new Error('"' + units + '" is not a valid IntlRelativeFormat `units` value, it ' + 'must be one of: "' + FIELDS.join('", "') + '"');
  };
  
  RelativeFormat.prototype._resolveLocale = function (locales) {
      if (typeof locales === 'string') {
          locales = [locales];
      }
  
      // Create a copy of the array so we can push on the default locale.
      locales = (locales || []).concat(RelativeFormat.defaultLocale);
  
      var localeData = RelativeFormat.__localeData__;
      var i, len, localeParts, data;
  
      // Using the set of locales + the default locale, we look for the first one
      // which that has been registered. When data does not exist for a locale, we
      // traverse its ancestors to find something that's been registered within
      // its hierarchy of locales. Since we lack the proper `parentLocale` data
      // here, we must take a naive approach to traversal.
      for (i = 0, len = locales.length; i < len; i += 1) {
          localeParts = locales[i].toLowerCase().split('-');
  
          while (localeParts.length) {
              data = localeData[localeParts.join('-')];
              if (data) {
                  // Return the normalized locale string; e.g., we return "en-US",
                  // instead of "en-us".
                  return data.locale;
              }
  
              localeParts.pop();
          }
      }
  
      var defaultLocale = locales.pop();
      throw new Error('No locale data has been added to IntlRelativeFormat for: ' + locales.join(', ') + ', or the default locale: ' + defaultLocale);
  };
  
  RelativeFormat.prototype._resolveStyle = function (style) {
      // Default to "best fit" style.
      if (!style) {
          return STYLES[0];
      }
  
      if (arrIndexOf.call(STYLES, style) >= 0) {
          return style;
      }
  
      throw new Error('"' + style + '" is not a valid IntlRelativeFormat `style` value, it ' + 'must be one of: "' + STYLES.join('", "') + '"');
  };
  
  RelativeFormat.prototype._selectUnits = function (diffReport) {
      var i, l, units;
  
      for (i = 0, l = FIELDS.length; i < l; i += 1) {
          units = FIELDS[i];
  
          if (Math.abs(diffReport[units]) < RelativeFormat.thresholds[units]) {
              break;
          }
      }
  
      return units;
  };
  
  // GENERATED FILE
  var defaultLocale$1 = { "locale": "en", "pluralRuleFunction": function pluralRuleFunction(n, ord) {
      var s = String(n).split("."),
          v0 = !s[1],
          t0 = Number(s[0]) == n,
          n10 = t0 && s[0].slice(-1),
          n100 = t0 && s[0].slice(-2);if (ord) return n10 == 1 && n100 != 11 ? "one" : n10 == 2 && n100 != 12 ? "two" : n10 == 3 && n100 != 13 ? "few" : "other";return n == 1 && v0 ? "one" : "other";
    }, "fields": { "year": { "displayName": "year", "relative": { "0": "this year", "1": "next year", "-1": "last year" }, "relativeTime": { "future": { "one": "in {0} year", "other": "in {0} years" }, "past": { "one": "{0} year ago", "other": "{0} years ago" } } }, "month": { "displayName": "month", "relative": { "0": "this month", "1": "next month", "-1": "last month" }, "relativeTime": { "future": { "one": "in {0} month", "other": "in {0} months" }, "past": { "one": "{0} month ago", "other": "{0} months ago" } } }, "day": { "displayName": "day", "relative": { "0": "today", "1": "tomorrow", "-1": "yesterday" }, "relativeTime": { "future": { "one": "in {0} day", "other": "in {0} days" }, "past": { "one": "{0} day ago", "other": "{0} days ago" } } }, "hour": { "displayName": "hour", "relativeTime": { "future": { "one": "in {0} hour", "other": "in {0} hours" }, "past": { "one": "{0} hour ago", "other": "{0} hours ago" } } }, "minute": { "displayName": "minute", "relativeTime": { "future": { "one": "in {0} minute", "other": "in {0} minutes" }, "past": { "one": "{0} minute ago", "other": "{0} minutes ago" } } }, "second": { "displayName": "second", "relative": { "0": "now" }, "relativeTime": { "future": { "one": "in {0} second", "other": "in {0} seconds" }, "past": { "one": "{0} second ago", "other": "{0} seconds ago" } } } } };
  
  /* jslint esnext: true */
  
  RelativeFormat.__addLocaleData(defaultLocale$1);
  RelativeFormat.defaultLocale = 'en';
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  function addLocaleData() {
      var data = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
  
      var locales = Array.isArray(data) ? data : [data];
  
      locales.forEach(function (localeData) {
          if (localeData && localeData.locale) {
              MessageFormat.__addLocaleData(localeData);
              RelativeFormat.__addLocaleData(localeData);
          }
      });
  }
  
  function hasLocaleData(locale) {
      var localeParts = (locale || '').split('-');
  
      while (localeParts.length > 0) {
          if (hasIMFAndIRFLocaleData(localeParts.join('-'))) {
              return true;
          }
  
          localeParts.pop();
      }
  
      return false;
  }
  
  function hasIMFAndIRFLocaleData(locale) {
      var normalizedLocale = locale && locale.toLowerCase();
  
      return !!(MessageFormat.__localeData__[normalizedLocale] && RelativeFormat.__localeData__[normalizedLocale]);
  }
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
  };
  
  var jsx = function () {
    var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
    return function createRawReactElement(type, props, key, children) {
      var defaultProps = type && type.defaultProps;
      var childrenLength = arguments.length - 3;
  
      if (!props && childrenLength !== 0) {
        props = {};
      }
  
      if (props && defaultProps) {
        for (var propName in defaultProps) {
          if (props[propName] === void 0) {
            props[propName] = defaultProps[propName];
          }
        }
      } else if (!props) {
        props = defaultProps || {};
      }
  
      if (childrenLength === 1) {
        props.children = children;
      } else if (childrenLength > 1) {
        var childArray = Array(childrenLength);
  
        for (var i = 0; i < childrenLength; i++) {
          childArray[i] = arguments[i + 3];
        }
  
        props.children = childArray;
      }
  
      return {
        $$typeof: REACT_ELEMENT_TYPE,
        type: type,
        key: key === undefined ? null : '' + key,
        ref: null,
        props: props,
        _owner: null
      };
    };
  }();
  
  var asyncToGenerator = function (fn) {
    return function () {
      var gen = fn.apply(this, arguments);
      return new Promise(function (resolve, reject) {
        function step(key, arg) {
          try {
            var info = gen[key](arg);
            var value = info.value;
          } catch (error) {
            reject(error);
            return;
          }
  
          if (info.done) {
            resolve(value);
          } else {
            return Promise.resolve(value).then(function (value) {
              return step("next", value);
            }, function (err) {
              return step("throw", err);
            });
          }
        }
  
        return step("next");
      });
    };
  };
  
  var classCallCheck = function (instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  };
  
  var createClass = function () {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();
  
  var defineEnumerableProperties = function (obj, descs) {
    for (var key in descs) {
      var desc = descs[key];
      desc.configurable = desc.enumerable = true;
      if ("value" in desc) desc.writable = true;
      Object.defineProperty(obj, key, desc);
    }
  
    return obj;
  };
  
  var defaults = function (obj, defaults) {
    var keys = Object.getOwnPropertyNames(defaults);
  
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      var value = Object.getOwnPropertyDescriptor(defaults, key);
  
      if (value && value.configurable && obj[key] === undefined) {
        Object.defineProperty(obj, key, value);
      }
    }
  
    return obj;
  };
  
  var defineProperty$2 = function (obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
  
    return obj;
  };
  
  var _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
  
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
  
    return target;
  };
  
  var get = function get(object, property, receiver) {
    if (object === null) object = Function.prototype;
    var desc = Object.getOwnPropertyDescriptor(object, property);
  
    if (desc === undefined) {
      var parent = Object.getPrototypeOf(object);
  
      if (parent === null) {
        return undefined;
      } else {
        return get(parent, property, receiver);
      }
    } else if ("value" in desc) {
      return desc.value;
    } else {
      var getter = desc.get;
  
      if (getter === undefined) {
        return undefined;
      }
  
      return getter.call(receiver);
    }
  };
  
  var inherits = function (subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    }
  
    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  };
  
  var _instanceof = function (left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
      return right[Symbol.hasInstance](left);
    } else {
      return left instanceof right;
    }
  };
  
  var interopRequireDefault = function (obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  };
  
  var interopRequireWildcard = function (obj) {
    if (obj && obj.__esModule) {
      return obj;
    } else {
      var newObj = {};
  
      if (obj != null) {
        for (var key in obj) {
          if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
        }
      }
  
      newObj.default = obj;
      return newObj;
    }
  };
  
  var newArrowCheck = function (innerThis, boundThis) {
    if (innerThis !== boundThis) {
      throw new TypeError("Cannot instantiate an arrow function");
    }
  };
  
  var objectDestructuringEmpty = function (obj) {
    if (obj == null) throw new TypeError("Cannot destructure undefined");
  };
  
  var objectWithoutProperties = function (obj, keys) {
    var target = {};
  
    for (var i in obj) {
      if (keys.indexOf(i) >= 0) continue;
      if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
      target[i] = obj[i];
    }
  
    return target;
  };
  
  var possibleConstructorReturn = function (self, call) {
    if (!self) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
  
    return call && (typeof call === "object" || typeof call === "function") ? call : self;
  };
  
  var selfGlobal = typeof global === "undefined" ? self : global;
  
  var set = function set(object, property, value, receiver) {
    var desc = Object.getOwnPropertyDescriptor(object, property);
  
    if (desc === undefined) {
      var parent = Object.getPrototypeOf(object);
  
      if (parent !== null) {
        set(parent, property, value, receiver);
      }
    } else if ("value" in desc && desc.writable) {
      desc.value = value;
    } else {
      var setter = desc.set;
  
      if (setter !== undefined) {
        setter.call(receiver, value);
      }
    }
  
    return value;
  };
  
  var slicedToArray = function () {
    function sliceIterator(arr, i) {
      var _arr = [];
      var _n = true;
      var _d = false;
      var _e = undefined;
  
      try {
        for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
          _arr.push(_s.value);
  
          if (i && _arr.length === i) break;
        }
      } catch (err) {
        _d = true;
        _e = err;
      } finally {
        try {
          if (!_n && _i["return"]) _i["return"]();
        } finally {
          if (_d) throw _e;
        }
      }
  
      return _arr;
    }
  
    return function (arr, i) {
      if (Array.isArray(arr)) {
        return arr;
      } else if (Symbol.iterator in Object(arr)) {
        return sliceIterator(arr, i);
      } else {
        throw new TypeError("Invalid attempt to destructure non-iterable instance");
      }
    };
  }();
  
  var slicedToArrayLoose = function (arr, i) {
    if (Array.isArray(arr)) {
      return arr;
    } else if (Symbol.iterator in Object(arr)) {
      var _arr = [];
  
      for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
        _arr.push(_step.value);
  
        if (i && _arr.length === i) break;
      }
  
      return _arr;
    } else {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  };
  
  var taggedTemplateLiteral = function (strings, raw) {
    return Object.freeze(Object.defineProperties(strings, {
      raw: {
        value: Object.freeze(raw)
      }
    }));
  };
  
  var taggedTemplateLiteralLoose = function (strings, raw) {
    strings.raw = raw;
    return strings;
  };
  
  var temporalRef = function (val, name, undef) {
    if (val === undef) {
      throw new ReferenceError(name + " is not defined - temporal dead zone");
    } else {
      return val;
    }
  };
  
  var temporalUndefined = {};
  
  var toArray = function (arr) {
    return Array.isArray(arr) ? arr : Array.from(arr);
  };
  
  var toConsumableArray = function (arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
  
      return arr2;
    } else {
      return Array.from(arr);
    }
  };
  
  
  
  var babelHelpers$1 = Object.freeze({
    jsx: jsx,
    asyncToGenerator: asyncToGenerator,
    classCallCheck: classCallCheck,
    createClass: createClass,
    defineEnumerableProperties: defineEnumerableProperties,
    defaults: defaults,
    defineProperty: defineProperty$2,
    get: get,
    inherits: inherits,
    interopRequireDefault: interopRequireDefault,
    interopRequireWildcard: interopRequireWildcard,
    newArrowCheck: newArrowCheck,
    objectDestructuringEmpty: objectDestructuringEmpty,
    objectWithoutProperties: objectWithoutProperties,
    possibleConstructorReturn: possibleConstructorReturn,
    selfGlobal: selfGlobal,
    set: set,
    slicedToArray: slicedToArray,
    slicedToArrayLoose: slicedToArrayLoose,
    taggedTemplateLiteral: taggedTemplateLiteral,
    taggedTemplateLiteralLoose: taggedTemplateLiteralLoose,
    temporalRef: temporalRef,
    temporalUndefined: temporalUndefined,
    toArray: toArray,
    toConsumableArray: toConsumableArray,
    typeof: _typeof,
    extends: _extends,
    instanceof: _instanceof
  });
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var bool = React.PropTypes.bool;
  var number = React.PropTypes.number;
  var string = React.PropTypes.string;
  var func = React.PropTypes.func;
  var object = React.PropTypes.object;
  var oneOf = React.PropTypes.oneOf;
  var shape = React.PropTypes.shape;
  
  
  var intlConfigPropTypes = {
      locale: string,
      formats: object,
      messages: object,
  
      defaultLocale: string,
      defaultFormats: object
  };
  
  var intlFormatPropTypes = {
      formatDate: func.isRequired,
      formatTime: func.isRequired,
      formatRelative: func.isRequired,
      formatNumber: func.isRequired,
      formatPlural: func.isRequired,
      formatMessage: func.isRequired,
      formatHTMLMessage: func.isRequired
  };
  
  var intlShape = shape(babelHelpers$1['extends']({}, intlConfigPropTypes, intlFormatPropTypes, {
      formatters: object,
      now: func.isRequired
  }));
  
  var messageDescriptorPropTypes = {
      id: string.isRequired,
      description: string,
      defaultMessage: string
  };
  
  var dateTimeFormatPropTypes = {
      localeMatcher: oneOf(['best fit', 'lookup']),
      formatMatcher: oneOf(['basic', 'best fit']),
  
      timeZone: string,
      hour12: bool,
  
      weekday: oneOf(['narrow', 'short', 'long']),
      era: oneOf(['narrow', 'short', 'long']),
      year: oneOf(['numeric', '2-digit']),
      month: oneOf(['numeric', '2-digit', 'narrow', 'short', 'long']),
      day: oneOf(['numeric', '2-digit']),
      hour: oneOf(['numeric', '2-digit']),
      minute: oneOf(['numeric', '2-digit']),
      second: oneOf(['numeric', '2-digit']),
      timeZoneName: oneOf(['short', 'long'])
  };
  
  var numberFormatPropTypes = {
      localeMatcher: oneOf(['best fit', 'lookup']),
  
      style: oneOf(['decimal', 'currency', 'percent']),
      currency: string,
      currencyDisplay: oneOf(['symbol', 'code', 'name']),
      useGrouping: bool,
  
      minimumIntegerDigits: number,
      minimumFractionDigits: number,
      maximumFractionDigits: number,
      minimumSignificantDigits: number,
      maximumSignificantDigits: number
  };
  
  var relativeFormatPropTypes = {
      style: oneOf(['best fit', 'numeric']),
      units: oneOf(['second', 'minute', 'hour', 'day', 'month', 'year'])
  };
  
  var pluralFormatPropTypes = {
      style: oneOf(['cardinal', 'ordinal'])
  };
  
  function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }
  
  var invariant = createCommonjsModule(function (module) {
  /**
   * Copyright 2013-2015, Facebook, Inc.
   * All rights reserved.
   *
   * This source code is licensed under the BSD-style license found in the
   * LICENSE file in the root directory of this source tree. An additional grant
   * of patent rights can be found in the PATENTS file in the same directory.
   */
  
  'use strict';
  
  /**
   * Use invariant() to assert state which your program assumes to be true.
   *
   * Provide sprintf-style format (only %s is supported) and arguments
   * to provide information about what broke and what you were
   * expecting.
   *
   * The invariant message will be stripped in production, but the invariant
   * will remain to ensure logic does not differ in production.
   */
  
  var NODE_ENV = "development";
  
  var invariant = function invariant(condition, format, a, b, c, d, e, f) {
    if (NODE_ENV !== 'production') {
      if (format === undefined) {
        throw new Error('invariant requires an error message argument');
      }
    }
  
    if (!condition) {
      var error;
      if (format === undefined) {
        error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
      } else {
        var args = [a, b, c, d, e, f];
        var argIndex = 0;
        error = new Error(format.replace(/%s/g, function () {
          return args[argIndex++];
        }));
        error.name = 'Invariant Violation';
      }
  
      error.framesToPop = 1; // we don't care about invariant's own frame
      throw error;
    }
  };
  
  module.exports = invariant;
  });
  
  /*
  HTML escaping and shallow-equals implementations are the same as React's
  (on purpose.) Therefore, it has the following Copyright and Licensing:
  
  Copyright 2013-2014, Facebook, Inc.
  All rights reserved.
  
  This source code is licensed under the BSD-style license found in the LICENSE
  file in the root directory of React's source tree.
  */
  
  var intlConfigPropNames = Object.keys(intlConfigPropTypes);
  
  var ESCAPED_CHARS = {
      '&': '&amp;',
      '>': '&gt;',
      '<': '&lt;',
      '"': '&quot;',
      '\'': '&#x27;'
  };
  
  var UNSAFE_CHARS_REGEX = /[&><"']/g;
  
  function escape(str) {
      return ('' + str).replace(UNSAFE_CHARS_REGEX, function (match) {
          return ESCAPED_CHARS[match];
      });
  }
  
  function filterProps(props, whitelist) {
      var defaults = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
  
      return whitelist.reduce(function (filtered, name) {
          if (props.hasOwnProperty(name)) {
              filtered[name] = props[name];
          } else if (defaults.hasOwnProperty(name)) {
              filtered[name] = defaults[name];
          }
  
          return filtered;
      }, {});
  }
  
  function invariantIntlContext() {
      var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
      var intl = _ref.intl;
  
      invariant(intl, '[React Intl] Could not find required `intl` object. ' + '<IntlProvider> needs to exist in the component ancestry.');
  }
  
  function shallowEquals(objA, objB) {
      if (objA === objB) {
          return true;
      }
  
      if ((typeof objA === 'undefined' ? 'undefined' : babelHelpers$1['typeof'](objA)) !== 'object' || objA === null || (typeof objB === 'undefined' ? 'undefined' : babelHelpers$1['typeof'](objB)) !== 'object' || objB === null) {
          return false;
      }
  
      var keysA = Object.keys(objA);
      var keysB = Object.keys(objB);
  
      if (keysA.length !== keysB.length) {
          return false;
      }
  
      // Test for A's keys different from B.
      var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
      for (var i = 0; i < keysA.length; i++) {
          if (!bHasOwnProperty(keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
              return false;
          }
      }
  
      return true;
  }
  
  function shouldIntlComponentUpdate(_ref2, nextProps, nextState) {
      var props = _ref2.props;
      var state = _ref2.state;
      var _ref2$context = _ref2.context;
      var context = _ref2$context === undefined ? {} : _ref2$context;
      var nextContext = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
      var _context$intl = context.intl;
      var intl = _context$intl === undefined ? {} : _context$intl;
      var _nextContext$intl = nextContext.intl;
      var nextIntl = _nextContext$intl === undefined ? {} : _nextContext$intl;
  
  
      return !shallowEquals(nextProps, props) || !shallowEquals(nextState, state) || !(nextIntl === intl || shallowEquals(filterProps(nextIntl, intlConfigPropNames), filterProps(intl, intlConfigPropNames)));
  }
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  // Inspired by react-redux's `connect()` HOC factory function implementation:
  // https://github.com/rackt/react-redux
  
  function getDisplayName(Component) {
      return Component.displayName || Component.name || 'Component';
  }
  
  function injectIntl(WrappedComponent) {
      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
      var _options$intlPropName = options.intlPropName;
      var intlPropName = _options$intlPropName === undefined ? 'intl' : _options$intlPropName;
      var _options$withRef = options.withRef;
      var withRef = _options$withRef === undefined ? false : _options$withRef;
  
      var InjectIntl = function (_Component) {
          inherits(InjectIntl, _Component);
  
          function InjectIntl(props, context) {
              classCallCheck(this, InjectIntl);
  
              var _this = possibleConstructorReturn(this, (InjectIntl.__proto__ || Object.getPrototypeOf(InjectIntl)).call(this, props, context));
  
              invariantIntlContext(context);
              return _this;
          }
  
          createClass(InjectIntl, [{
              key: 'getWrappedInstance',
              value: function getWrappedInstance() {
                  invariant(withRef, '[React Intl] To access the wrapped instance, ' + 'the `{withRef: true}` option must be set when calling: ' + '`injectIntl()`');
  
                  return this.refs.wrappedInstance;
              }
          }, {
              key: 'render',
              value: function render() {
                  return React__default.createElement(WrappedComponent, babelHelpers$1['extends']({}, this.props, defineProperty$2({}, intlPropName, this.context.intl), {
                      ref: withRef ? 'wrappedInstance' : null
                  }));
              }
          }]);
          return InjectIntl;
      }(React.Component);
  
      InjectIntl.displayName = 'InjectIntl(' + getDisplayName(WrappedComponent) + ')';
  
      InjectIntl.contextTypes = {
          intl: intlShape
      };
  
      InjectIntl.WrappedComponent = WrappedComponent;
  
      return InjectIntl;
  }
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  function defineMessages(messageDescriptors) {
    // This simply returns what's passed-in because it's meant to be a hook for
    // babel-plugin-react-intl.
    return messageDescriptors;
  }
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  // This is a "hack" until a proper `intl-pluralformat` package is created.
  
  function resolveLocale(locales) {
      // IntlMessageFormat#_resolveLocale() does not depend on `this`.
      return MessageFormat.prototype._resolveLocale(locales);
  }
  
  function findPluralFunction(locale) {
      // IntlMessageFormat#_findPluralFunction() does not depend on `this`.
      return MessageFormat.prototype._findPluralRuleFunction(locale);
  }
  
  var IntlPluralFormat = function IntlPluralFormat(locales) {
      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
      classCallCheck(this, IntlPluralFormat);
  
      var useOrdinal = options.style === 'ordinal';
      var pluralFn = findPluralFunction(resolveLocale(locales));
  
      this.format = function (value) {
          return pluralFn(value, useOrdinal);
      };
  };
  
  /*
  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
  Copyrights licensed under the New BSD License.
  See the accompanying LICENSE file for terms.
  */
  
  /* jslint esnext: true */
  
  // Function.prototype.bind implementation from Mozilla Developer Network:
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind#Polyfill
  
  var bind = Function.prototype.bind || function (oThis) {
      if (typeof this !== 'function') {
          // closest thing possible to the ECMAScript 5
          // internal IsCallable function
          throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
      }
  
      var aArgs = Array.prototype.slice.call(arguments, 1),
          fToBind = this,
          fNOP = function fNOP() {},
          fBound = function fBound() {
          return fToBind.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments)));
      };
  
      if (this.prototype) {
          // native functions don't have a prototype
          fNOP.prototype = this.prototype;
      }
      fBound.prototype = new fNOP();
  
      return fBound;
  };
  
  // Purposely using the same implementation as the Intl.js `Intl` polyfill.
  // Copyright 2013 Andy Earnshaw, MIT License
  
  var hop$2 = Object.prototype.hasOwnProperty;
  
  var realDefineProp$2 = function () {
      try {
          return !!Object.defineProperty({}, 'a', {});
      } catch (e) {
          return false;
      }
  }();
  
  var es3$2 = !realDefineProp$2 && !Object.prototype.__defineGetter__;
  
  var defineProperty$3 = realDefineProp$2 ? Object.defineProperty : function (obj, name, desc) {
  
      if ('get' in desc && obj.__defineGetter__) {
          obj.__defineGetter__(name, desc.get);
      } else if (!hop$2.call(obj, name) || 'value' in desc) {
          obj[name] = desc.value;
      }
  };
  
  var objCreate$2 = Object.create || function (proto, props) {
      var obj, k;
  
      function F() {}
      F.prototype = proto;
      obj = new F();
  
      for (k in props) {
          if (hop$2.call(props, k)) {
              defineProperty$3(obj, k, props[k]);
          }
      }
  
      return obj;
  };
  
  /*
  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
  Copyrights licensed under the New BSD License.
  See the accompanying LICENSE file for terms.
  */
  
  /* jshint esnext: true */
  
  // -----------------------------------------------------------------------------
  
  function createFormatCache(FormatConstructor) {
      var cache = objCreate$2(null);
  
      return function () {
          var args = Array.prototype.slice.call(arguments);
          var cacheId = getCacheId(args);
          var format = cacheId && cache[cacheId];
  
          if (!format) {
              format = new (bind.apply(FormatConstructor, [null].concat(args)))();
  
              if (cacheId) {
                  cache[cacheId] = format;
              }
          }
  
          return format;
      };
  }
  
  // -- Utilities ----------------------------------------------------------------
  
  function getCacheId(inputs) {
      // When JSON is not available in the runtime, we will not create a cache id.
      if (typeof JSON === 'undefined') {
          return;
      }
  
      var cacheId = [];
  
      var i, len, input;
  
      for (i = 0, len = inputs.length; i < len; i += 1) {
          input = inputs[i];
  
          if (input && (typeof input === 'undefined' ? 'undefined' : babelHelpers$1['typeof'](input)) === 'object') {
              cacheId.push(orderedProps(input));
          } else {
              cacheId.push(input);
          }
      }
  
      return JSON.stringify(cacheId);
  }
  
  function orderedProps(obj) {
      var props = [],
          keys = [];
  
      var key, i, len, prop;
  
      for (key in obj) {
          if (obj.hasOwnProperty(key)) {
              keys.push(key);
          }
      }
  
      var orderedKeys = keys.sort();
  
      for (i = 0, len = orderedKeys.length; i < len; i += 1) {
          key = orderedKeys[i];
          prop = {};
  
          prop[key] = obj[key];
          props[i] = prop;
      }
  
      return props;
  }
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var DATE_TIME_FORMAT_OPTIONS = Object.keys(dateTimeFormatPropTypes);
  var NUMBER_FORMAT_OPTIONS = Object.keys(numberFormatPropTypes);
  var RELATIVE_FORMAT_OPTIONS = Object.keys(relativeFormatPropTypes);
  var PLURAL_FORMAT_OPTIONS = Object.keys(pluralFormatPropTypes);
  
  var RELATIVE_FORMAT_THRESHOLDS = {
      second: 60, // seconds to minute
      minute: 60, // minutes to hour
      hour: 24, // hours to day
      day: 30, // days to month
      month: 12 };
  
  function updateRelativeFormatThresholds(newThresholds) {
      var thresholds = RelativeFormat.thresholds;
      thresholds.second = newThresholds.second;
      thresholds.minute = newThresholds.minute;
      thresholds.hour = newThresholds.hour;
      thresholds.day = newThresholds.day;
      thresholds.month = newThresholds.month;
  }
  
  function getNamedFormat(formats, type, name) {
      var format = formats && formats[type] && formats[type][name];
      if (format) {
          return format;
      }
  
      if ("development" !== 'production') {
          console.error('[React Intl] No ' + type + ' format named: ' + name);
      }
  }
  
  function formatDate(config, state, value) {
      var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
      var locale = config.locale;
      var formats = config.formats;
      var format = options.format;
  
  
      var date = new Date(value);
      var defaults = format && getNamedFormat(formats, 'date', format);
      var filteredOptions = filterProps(options, DATE_TIME_FORMAT_OPTIONS, defaults);
  
      try {
          return state.getDateTimeFormat(locale, filteredOptions).format(date);
      } catch (e) {
          if ("development" !== 'production') {
              console.error('[React Intl] Error formatting date.\n' + e);
          }
      }
  
      return String(date);
  }
  
  function formatTime(config, state, value) {
      var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
      var locale = config.locale;
      var formats = config.formats;
      var format = options.format;
  
  
      var date = new Date(value);
      var defaults = format && getNamedFormat(formats, 'time', format);
      var filteredOptions = filterProps(options, DATE_TIME_FORMAT_OPTIONS, defaults);
  
      if (!filteredOptions.hour && !filteredOptions.minute && !filteredOptions.second) {
          // Add default formatting options if hour, minute, or second isn't defined.
          filteredOptions = babelHelpers$1['extends']({}, filteredOptions, { hour: 'numeric', minute: 'numeric' });
      }
  
      try {
          return state.getDateTimeFormat(locale, filteredOptions).format(date);
      } catch (e) {
          if ("development" !== 'production') {
              console.error('[React Intl] Error formatting time.\n' + e);
          }
      }
  
      return String(date);
  }
  
  function formatRelative(config, state, value) {
      var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
      var locale = config.locale;
      var formats = config.formats;
      var format = options.format;
  
  
      var date = new Date(value);
      var now = new Date(options.now);
      var defaults = format && getNamedFormat(formats, 'relative', format);
      var filteredOptions = filterProps(options, RELATIVE_FORMAT_OPTIONS, defaults);
  
      // Capture the current threshold values, then temporarily override them with
      // specific values just for this render.
      var oldThresholds = babelHelpers$1['extends']({}, RelativeFormat.thresholds);
      updateRelativeFormatThresholds(RELATIVE_FORMAT_THRESHOLDS);
  
      try {
          return state.getRelativeFormat(locale, filteredOptions).format(date, {
              now: isFinite(now) ? now : state.now()
          });
      } catch (e) {
          if ("development" !== 'production') {
              console.error('[React Intl] Error formatting relative time.\n' + e);
          }
      } finally {
          updateRelativeFormatThresholds(oldThresholds);
      }
  
      return String(date);
  }
  
  function formatNumber(config, state, value) {
      var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
      var locale = config.locale;
      var formats = config.formats;
      var format = options.format;
  
  
      var defaults = format && getNamedFormat(formats, 'number', format);
      var filteredOptions = filterProps(options, NUMBER_FORMAT_OPTIONS, defaults);
  
      try {
          return state.getNumberFormat(locale, filteredOptions).format(value);
      } catch (e) {
          if ("development" !== 'production') {
              console.error('[React Intl] Error formatting number.\n' + e);
          }
      }
  
      return String(value);
  }
  
  function formatPlural(config, state, value) {
      var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
      var locale = config.locale;
  
  
      var filteredOptions = filterProps(options, PLURAL_FORMAT_OPTIONS);
  
      try {
          return state.getPluralFormat(locale, filteredOptions).format(value);
      } catch (e) {
          if ("development" !== 'production') {
              console.error('[React Intl] Error formatting plural.\n' + e);
          }
      }
  
      return 'other';
  }
  
  function formatMessage(config, state) {
      var messageDescriptor = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
      var values = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
      var locale = config.locale;
      var formats = config.formats;
      var messages = config.messages;
      var defaultLocale = config.defaultLocale;
      var defaultFormats = config.defaultFormats;
      var id = messageDescriptor.id;
      var defaultMessage = messageDescriptor.defaultMessage;
  
      // `id` is a required field of a Message Descriptor.
  
      invariant(id, '[React Intl] An `id` must be provided to format a message.');
  
      var message = messages && messages[id];
      var hasValues = Object.keys(values).length > 0;
  
      // Avoid expensive message formatting for simple messages without values. In
      // development messages will always be formatted in case of missing values.
      if (!hasValues && "development" === 'production') {
          return message || defaultMessage || id;
      }
  
      var formattedMessage = void 0;
  
      if (message) {
          try {
              var formatter = state.getMessageFormat(message, locale, formats);
  
              formattedMessage = formatter.format(values);
          } catch (e) {
              if ("development" !== 'production') {
                  console.error('[React Intl] Error formatting message: "' + id + '" for locale: "' + locale + '"' + (defaultMessage ? ', using default message as fallback.' : '') + ('\n' + e));
              }
          }
      } else {
          if ("development" !== 'production') {
              // This prevents warnings from littering the console in development
              // when no `messages` are passed into the <IntlProvider> for the
              // default locale, and a default message is in the source.
              if (!defaultMessage || locale && locale.toLowerCase() !== defaultLocale.toLowerCase()) {
  
                  console.error('[React Intl] Missing message: "' + id + '" for locale: "' + locale + '"' + (defaultMessage ? ', using default message as fallback.' : ''));
              }
          }
      }
  
      if (!formattedMessage && defaultMessage) {
          try {
              var _formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats);
  
              formattedMessage = _formatter.format(values);
          } catch (e) {
              if ("development" !== 'production') {
                  console.error('[React Intl] Error formatting the default message for: "' + id + '"' + ('\n' + e));
              }
          }
      }
  
      if (!formattedMessage) {
          if ("development" !== 'production') {
              console.error('[React Intl] Cannot format message: "' + id + '", ' + ('using message ' + (message || defaultMessage ? 'source' : 'id') + ' as fallback.'));
          }
      }
  
      return formattedMessage || message || defaultMessage || id;
  }
  
  function formatHTMLMessage(config, state, messageDescriptor) {
      var rawValues = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
  
      // Process all the values before they are used when formatting the ICU
      // Message string. Since the formatted message might be injected via
      // `innerHTML`, all String-based values need to be HTML-escaped.
      var escapedValues = Object.keys(rawValues).reduce(function (escaped, name) {
          var value = rawValues[name];
          escaped[name] = typeof value === 'string' ? escape(value) : value;
          return escaped;
      }, {});
  
      return formatMessage(config, state, messageDescriptor, escapedValues);
  }
  
  
  
  var format = Object.freeze({
      formatDate: formatDate,
      formatTime: formatTime,
      formatRelative: formatRelative,
      formatNumber: formatNumber,
      formatPlural: formatPlural,
      formatMessage: formatMessage,
      formatHTMLMessage: formatHTMLMessage
  });
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var intlConfigPropNames$1 = Object.keys(intlConfigPropTypes);
  var intlFormatPropNames = Object.keys(intlFormatPropTypes);
  
  // These are not a static property on the `IntlProvider` class so the intl
  // config values can be inherited from an <IntlProvider> ancestor.
  var defaultProps = {
      formats: {},
      messages: {},
  
      defaultLocale: 'en',
      defaultFormats: {}
  };
  
  var IntlProvider = function (_Component) {
      inherits(IntlProvider, _Component);
  
      function IntlProvider(props, context) {
          classCallCheck(this, IntlProvider);
  
          var _this = possibleConstructorReturn(this, (IntlProvider.__proto__ || Object.getPrototypeOf(IntlProvider)).call(this, props, context));
  
          invariant(typeof Intl !== 'undefined', '[React Intl] The `Intl` APIs must be available in the runtime, ' + 'and do not appear to be built-in. An `Intl` polyfill should be loaded.\n' + 'See: http://formatjs.io/guides/runtime-environments/');
  
          var intlContext = context.intl;
  
          // Used to stabilize time when performing an initial rendering so that
          // all relative times use the same reference "now" time.
  
          var initialNow = void 0;
          if (isFinite(props.initialNow)) {
              initialNow = Number(props.initialNow);
          } else {
              // When an `initialNow` isn't provided via `props`, look to see an
              // <IntlProvider> exists in the ancestry and call its `now()`
              // function to propagate its value for "now".
              initialNow = intlContext ? intlContext.now() : Date.now();
          }
  
          // Creating `Intl*` formatters is expensive. If there's a parent
          // `<IntlProvider>`, then its formatters will be used. Otherwise, this
          // memoize the `Intl*` constructors and cache them for the lifecycle of
          // this IntlProvider instance.
  
          var _ref = intlContext || {};
  
          var _ref$formatters = _ref.formatters;
          var formatters = _ref$formatters === undefined ? {
              getDateTimeFormat: createFormatCache(Intl.DateTimeFormat),
              getNumberFormat: createFormatCache(Intl.NumberFormat),
              getMessageFormat: createFormatCache(MessageFormat),
              getRelativeFormat: createFormatCache(RelativeFormat),
              getPluralFormat: createFormatCache(IntlPluralFormat)
          } : _ref$formatters;
  
  
          _this.state = babelHelpers$1['extends']({}, formatters, {
  
              // Wrapper to provide stable "now" time for initial render.
              now: function now() {
                  return _this._didDisplay ? Date.now() : initialNow;
              }
          });
          return _this;
      }
  
      createClass(IntlProvider, [{
          key: 'getConfig',
          value: function getConfig() {
              var intlContext = this.context.intl;
  
              // Build a whitelisted config object from `props`, defaults, and
              // `context.intl`, if an <IntlProvider> exists in the ancestry.
  
              var config = filterProps(this.props, intlConfigPropNames$1, intlContext);
  
              // Apply default props. This must be applied last after the props have
              // been resolved and inherited from any <IntlProvider> in the ancestry.
              // This matches how React resolves `defaultProps`.
              for (var propName in defaultProps) {
                  if (config[propName] === undefined) {
                      config[propName] = defaultProps[propName];
                  }
              }
  
              if (!hasLocaleData(config.locale)) {
                  var _config = config;
                  var locale = _config.locale;
                  var defaultLocale = _config.defaultLocale;
                  var defaultFormats = _config.defaultFormats;
  
  
                  if ("development" !== 'production') {
                      console.error('[React Intl] Missing locale data for locale: "' + locale + '". ' + ('Using default locale: "' + defaultLocale + '" as fallback.'));
                  }
  
                  // Since there's no registered locale data for `locale`, this will
                  // fallback to the `defaultLocale` to make sure things can render.
                  // The `messages` are overridden to the `defaultProps` empty object
                  // to maintain referential equality across re-renders. It's assumed
                  // each <FormattedMessage> contains a `defaultMessage` prop.
                  config = babelHelpers$1['extends']({}, config, {
                      locale: defaultLocale,
                      formats: defaultFormats,
                      messages: defaultProps.messages
                  });
              }
  
              return config;
          }
      }, {
          key: 'getBoundFormatFns',
          value: function getBoundFormatFns(config, state) {
              return intlFormatPropNames.reduce(function (boundFormatFns, name) {
                  boundFormatFns[name] = format[name].bind(null, config, state);
                  return boundFormatFns;
              }, {});
          }
      }, {
          key: 'getChildContext',
          value: function getChildContext() {
              var config = this.getConfig();
  
              // Bind intl factories and current config to the format functions.
              var boundFormatFns = this.getBoundFormatFns(config, this.state);
  
              var _state = this.state;
              var now = _state.now;
              var formatters = objectWithoutProperties(_state, ['now']);
  
  
              return {
                  intl: babelHelpers$1['extends']({}, config, boundFormatFns, {
                      formatters: formatters,
                      now: now
                  })
              };
          }
      }, {
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate() {
              for (var _len = arguments.length, next = Array(_len), _key = 0; _key < _len; _key++) {
                  next[_key] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this].concat(next));
          }
      }, {
          key: 'componentDidMount',
          value: function componentDidMount() {
              this._didDisplay = true;
          }
      }, {
          key: 'render',
          value: function render() {
              return React.Children.only(this.props.children);
          }
      }]);
      return IntlProvider;
  }(React.Component);
  
  IntlProvider.displayName = 'IntlProvider';
  
  IntlProvider.contextTypes = {
      intl: intlShape
  };
  
  IntlProvider.childContextTypes = {
      intl: intlShape.isRequired
  };
  
  IntlProvider.propTypes = babelHelpers$1['extends']({}, intlConfigPropTypes, {
      children: React.PropTypes.element.isRequired,
      initialNow: React.PropTypes.any
  });
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var FormattedDate = function (_Component) {
      inherits(FormattedDate, _Component);
  
      function FormattedDate(props, context) {
          classCallCheck(this, FormattedDate);
  
          var _this = possibleConstructorReturn(this, (FormattedDate.__proto__ || Object.getPrototypeOf(FormattedDate)).call(this, props, context));
  
          invariantIntlContext(context);
          return _this;
      }
  
      createClass(FormattedDate, [{
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate() {
              for (var _len = arguments.length, next = Array(_len), _key = 0; _key < _len; _key++) {
                  next[_key] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this].concat(next));
          }
      }, {
          key: 'render',
          value: function render() {
              var formatDate = this.context.intl.formatDate;
              var _props = this.props;
              var value = _props.value;
              var children = _props.children;
  
  
              var formattedDate = formatDate(value, this.props);
  
              if (typeof children === 'function') {
                  return children(formattedDate);
              }
  
              return React__default.createElement(
                  'span',
                  null,
                  formattedDate
              );
          }
      }]);
      return FormattedDate;
  }(React.Component);
  
  FormattedDate.displayName = 'FormattedDate';
  
  FormattedDate.contextTypes = {
      intl: intlShape
  };
  
  FormattedDate.propTypes = babelHelpers$1['extends']({}, dateTimeFormatPropTypes, {
      value: React.PropTypes.any.isRequired,
      format: React.PropTypes.string,
      children: React.PropTypes.func
  });
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var FormattedTime = function (_Component) {
      inherits(FormattedTime, _Component);
  
      function FormattedTime(props, context) {
          classCallCheck(this, FormattedTime);
  
          var _this = possibleConstructorReturn(this, (FormattedTime.__proto__ || Object.getPrototypeOf(FormattedTime)).call(this, props, context));
  
          invariantIntlContext(context);
          return _this;
      }
  
      createClass(FormattedTime, [{
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate() {
              for (var _len = arguments.length, next = Array(_len), _key = 0; _key < _len; _key++) {
                  next[_key] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this].concat(next));
          }
      }, {
          key: 'render',
          value: function render() {
              var formatTime = this.context.intl.formatTime;
              var _props = this.props;
              var value = _props.value;
              var children = _props.children;
  
  
              var formattedTime = formatTime(value, this.props);
  
              if (typeof children === 'function') {
                  return children(formattedTime);
              }
  
              return React__default.createElement(
                  'span',
                  null,
                  formattedTime
              );
          }
      }]);
      return FormattedTime;
  }(React.Component);
  
  FormattedTime.displayName = 'FormattedTime';
  
  FormattedTime.contextTypes = {
      intl: intlShape
  };
  
  FormattedTime.propTypes = babelHelpers$1['extends']({}, dateTimeFormatPropTypes, {
      value: React.PropTypes.any.isRequired,
      format: React.PropTypes.string,
      children: React.PropTypes.func
  });
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var SECOND = 1000;
  var MINUTE = 1000 * 60;
  var HOUR = 1000 * 60 * 60;
  var DAY = 1000 * 60 * 60 * 24;
  
  // The maximum timer delay value is a 32-bit signed integer.
  // See: https://mdn.io/setTimeout
  var MAX_TIMER_DELAY = 2147483647;
  
  function selectUnits(delta) {
      var absDelta = Math.abs(delta);
  
      if (absDelta < MINUTE) {
          return 'second';
      }
  
      if (absDelta < HOUR) {
          return 'minute';
      }
  
      if (absDelta < DAY) {
          return 'hour';
      }
  
      // The maximum scheduled delay will be measured in days since the maximum
      // timer delay is less than the number of milliseconds in 25 days.
      return 'day';
  }
  
  function getUnitDelay(units) {
      switch (units) {
          case 'second':
              return SECOND;
          case 'minute':
              return MINUTE;
          case 'hour':
              return HOUR;
          case 'day':
              return DAY;
          default:
              return MAX_TIMER_DELAY;
      }
  }
  
  function isSameDate(a, b) {
      if (a === b) {
          return true;
      }
  
      var aTime = new Date(a).getTime();
      var bTime = new Date(b).getTime();
  
      return isFinite(aTime) && isFinite(bTime) && aTime === bTime;
  }
  
  var FormattedRelative = function (_Component) {
      inherits(FormattedRelative, _Component);
  
      function FormattedRelative(props, context) {
          classCallCheck(this, FormattedRelative);
  
          var _this = possibleConstructorReturn(this, (FormattedRelative.__proto__ || Object.getPrototypeOf(FormattedRelative)).call(this, props, context));
  
          invariantIntlContext(context);
  
          var now = isFinite(props.initialNow) ? Number(props.initialNow) : context.intl.now();
  
          // `now` is stored as state so that `render()` remains a function of
          // props + state, instead of accessing `Date.now()` inside `render()`.
          _this.state = { now: now };
          return _this;
      }
  
      createClass(FormattedRelative, [{
          key: 'scheduleNextUpdate',
          value: function scheduleNextUpdate(props, state) {
              var _this2 = this;
  
              var updateInterval = props.updateInterval;
  
              // If the `updateInterval` is falsy, including `0`, then auto updates
              // have been turned off, so we bail and skip scheduling an update.
  
              if (!updateInterval) {
                  return;
              }
  
              var time = new Date(props.value).getTime();
              var delta = time - state.now;
              var units = props.units || selectUnits(delta);
  
              var unitDelay = getUnitDelay(units);
              var unitRemainder = Math.abs(delta % unitDelay);
  
              // We want the largest possible timer delay which will still display
              // accurate information while reducing unnecessary re-renders. The delay
              // should be until the next "interesting" moment, like a tick from
              // "1 minute ago" to "2 minutes ago" when the delta is 120,000ms.
              var delay = delta < 0 ? Math.max(updateInterval, unitDelay - unitRemainder) : Math.max(updateInterval, unitRemainder);
  
              clearTimeout(this._timer);
  
              this._timer = setTimeout(function () {
                  _this2.setState({ now: _this2.context.intl.now() });
              }, delay);
          }
      }, {
          key: 'componentDidMount',
          value: function componentDidMount() {
              this.scheduleNextUpdate(this.props, this.state);
          }
      }, {
          key: 'componentWillReceiveProps',
          value: function componentWillReceiveProps(_ref) {
              var nextValue = _ref.value;
  
              // When the `props.value` date changes, `state.now` needs to be updated,
              // and the next update can be rescheduled.
              if (!isSameDate(nextValue, this.props.value)) {
                  this.setState({ now: this.context.intl.now() });
              }
          }
      }, {
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate() {
              for (var _len = arguments.length, next = Array(_len), _key = 0; _key < _len; _key++) {
                  next[_key] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this].concat(next));
          }
      }, {
          key: 'componentWillUpdate',
          value: function componentWillUpdate(nextProps, nextState) {
              this.scheduleNextUpdate(nextProps, nextState);
          }
      }, {
          key: 'componentWillUnmount',
          value: function componentWillUnmount() {
              clearTimeout(this._timer);
          }
      }, {
          key: 'render',
          value: function render() {
              var formatRelative = this.context.intl.formatRelative;
              var _props = this.props;
              var value = _props.value;
              var children = _props.children;
  
  
              var formattedRelative = formatRelative(value, babelHelpers$1['extends']({}, this.props, this.state));
  
              if (typeof children === 'function') {
                  return children(formattedRelative);
              }
  
              return React__default.createElement(
                  'span',
                  null,
                  formattedRelative
              );
          }
      }]);
      return FormattedRelative;
  }(React.Component);
  
  FormattedRelative.displayName = 'FormattedRelative';
  
  FormattedRelative.contextTypes = {
      intl: intlShape
  };
  
  FormattedRelative.propTypes = babelHelpers$1['extends']({}, relativeFormatPropTypes, {
      value: React.PropTypes.any.isRequired,
      format: React.PropTypes.string,
      updateInterval: React.PropTypes.number,
      initialNow: React.PropTypes.any,
      children: React.PropTypes.func
  });
  
  FormattedRelative.defaultProps = {
      updateInterval: 1000 * 10
  };
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var FormattedNumber = function (_Component) {
      inherits(FormattedNumber, _Component);
  
      function FormattedNumber(props, context) {
          classCallCheck(this, FormattedNumber);
  
          var _this = possibleConstructorReturn(this, (FormattedNumber.__proto__ || Object.getPrototypeOf(FormattedNumber)).call(this, props, context));
  
          invariantIntlContext(context);
          return _this;
      }
  
      createClass(FormattedNumber, [{
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate() {
              for (var _len = arguments.length, next = Array(_len), _key = 0; _key < _len; _key++) {
                  next[_key] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this].concat(next));
          }
      }, {
          key: 'render',
          value: function render() {
              var formatNumber = this.context.intl.formatNumber;
              var _props = this.props;
              var value = _props.value;
              var children = _props.children;
  
  
              var formattedNumber = formatNumber(value, this.props);
  
              if (typeof children === 'function') {
                  return children(formattedNumber);
              }
  
              return React__default.createElement(
                  'span',
                  null,
                  formattedNumber
              );
          }
      }]);
      return FormattedNumber;
  }(React.Component);
  
  FormattedNumber.displayName = 'FormattedNumber';
  
  FormattedNumber.contextTypes = {
      intl: intlShape
  };
  
  FormattedNumber.propTypes = babelHelpers$1['extends']({}, numberFormatPropTypes, {
      value: React.PropTypes.any.isRequired,
      format: React.PropTypes.string,
      children: React.PropTypes.func
  });
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var FormattedPlural = function (_Component) {
      inherits(FormattedPlural, _Component);
  
      function FormattedPlural(props, context) {
          classCallCheck(this, FormattedPlural);
  
          var _this = possibleConstructorReturn(this, (FormattedPlural.__proto__ || Object.getPrototypeOf(FormattedPlural)).call(this, props, context));
  
          invariantIntlContext(context);
          return _this;
      }
  
      createClass(FormattedPlural, [{
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate() {
              for (var _len = arguments.length, next = Array(_len), _key = 0; _key < _len; _key++) {
                  next[_key] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this].concat(next));
          }
      }, {
          key: 'render',
          value: function render() {
              var formatPlural = this.context.intl.formatPlural;
              var _props = this.props;
              var value = _props.value;
              var other = _props.other;
              var children = _props.children;
  
  
              var pluralCategory = formatPlural(value, this.props);
              var formattedPlural = this.props[pluralCategory] || other;
  
              if (typeof children === 'function') {
                  return children(formattedPlural);
              }
  
              return React__default.createElement(
                  'span',
                  null,
                  formattedPlural
              );
          }
      }]);
      return FormattedPlural;
  }(React.Component);
  
  FormattedPlural.displayName = 'FormattedPlural';
  
  FormattedPlural.contextTypes = {
      intl: intlShape
  };
  
  FormattedPlural.propTypes = babelHelpers$1['extends']({}, pluralFormatPropTypes, {
      value: React.PropTypes.any.isRequired,
  
      other: React.PropTypes.node.isRequired,
      zero: React.PropTypes.node,
      one: React.PropTypes.node,
      two: React.PropTypes.node,
      few: React.PropTypes.node,
      many: React.PropTypes.node,
  
      children: React.PropTypes.func
  });
  
  FormattedPlural.defaultProps = {
      style: 'cardinal'
  };
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var FormattedMessage = function (_Component) {
      inherits(FormattedMessage, _Component);
  
      function FormattedMessage(props, context) {
          classCallCheck(this, FormattedMessage);
  
          var _this = possibleConstructorReturn(this, (FormattedMessage.__proto__ || Object.getPrototypeOf(FormattedMessage)).call(this, props, context));
  
          invariantIntlContext(context);
          return _this;
      }
  
      createClass(FormattedMessage, [{
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate(nextProps) {
              var values = this.props.values;
              var nextValues = nextProps.values;
  
  
              if (!shallowEquals(nextValues, values)) {
                  return true;
              }
  
              // Since `values` has already been checked, we know they're not
              // different, so the current `values` are carried over so the shallow
              // equals comparison on the other props isn't affected by the `values`.
              var nextPropsToCheck = babelHelpers$1['extends']({}, nextProps, {
                  values: values
              });
  
              for (var _len = arguments.length, next = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  next[_key - 1] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this, nextPropsToCheck].concat(next));
          }
      }, {
          key: 'render',
          value: function render() {
              var formatMessage = this.context.intl.formatMessage;
              var _props = this.props;
              var id = _props.id;
              var description = _props.description;
              var defaultMessage = _props.defaultMessage;
              var values = _props.values;
              var tagName = _props.tagName;
              var children = _props.children;
  
  
              var tokenDelimiter = void 0;
              var tokenizedValues = void 0;
              var elements = void 0;
  
              var hasValues = values && Object.keys(values).length > 0;
              if (hasValues) {
                  (function () {
                      // Creates a token with a random UID that should not be guessable or
                      // conflict with other parts of the `message` string.
                      var uid = Math.floor(Math.random() * 0x10000000000).toString(16);
  
                      var generateToken = function () {
                          var counter = 0;
                          return function () {
                              return 'ELEMENT-' + uid + '-' + (counter += 1);
                          };
                      }();
  
                      // Splitting with a delimiter to support IE8. When using a regex
                      // with a capture group IE8 does not include the capture group in
                      // the resulting array.
                      tokenDelimiter = '@__' + uid + '__@';
                      tokenizedValues = {};
                      elements = {};
  
                      // Iterates over the `props` to keep track of any React Element
                      // values so they can be represented by the `token` as a placeholder
                      // when the `message` is formatted. This allows the formatted
                      // message to then be broken-up into parts with references to the
                      // React Elements inserted back in.
                      Object.keys(values).forEach(function (name) {
                          var value = values[name];
  
                          if (React.isValidElement(value)) {
                              var token = generateToken();
                              tokenizedValues[name] = tokenDelimiter + token + tokenDelimiter;
                              elements[token] = value;
                          } else {
                              tokenizedValues[name] = value;
                          }
                      });
                  })();
              }
  
              var descriptor = { id: id, description: description, defaultMessage: defaultMessage };
              var formattedMessage = formatMessage(descriptor, tokenizedValues || values);
  
              var nodes = void 0;
  
              var hasElements = elements && Object.keys(elements).length > 0;
              if (hasElements) {
                  // Split the message into parts so the React Element values captured
                  // above can be inserted back into the rendered message. This
                  // approach allows messages to render with React Elements while
                  // keeping React's virtual diffing working properly.
                  nodes = formattedMessage.split(tokenDelimiter).filter(function (part) {
                      return !!part;
                  }).map(function (part) {
                      return elements[part] || part;
                  });
              } else {
                  nodes = [formattedMessage];
              }
  
              if (typeof children === 'function') {
                  return children.apply(undefined, toConsumableArray(nodes));
              }
  
              return React.createElement.apply(undefined, [tagName, null].concat(toConsumableArray(nodes)));
          }
      }]);
      return FormattedMessage;
  }(React.Component);
  
  FormattedMessage.displayName = 'FormattedMessage';
  
  FormattedMessage.contextTypes = {
      intl: intlShape
  };
  
  FormattedMessage.propTypes = babelHelpers$1['extends']({}, messageDescriptorPropTypes, {
      values: React.PropTypes.object,
      tagName: React.PropTypes.string,
      children: React.PropTypes.func
  });
  
  FormattedMessage.defaultProps = {
      values: {},
      tagName: 'span'
  };
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  var FormattedHTMLMessage = function (_Component) {
      inherits(FormattedHTMLMessage, _Component);
  
      function FormattedHTMLMessage(props, context) {
          classCallCheck(this, FormattedHTMLMessage);
  
          var _this = possibleConstructorReturn(this, (FormattedHTMLMessage.__proto__ || Object.getPrototypeOf(FormattedHTMLMessage)).call(this, props, context));
  
          invariantIntlContext(context);
          return _this;
      }
  
      createClass(FormattedHTMLMessage, [{
          key: 'shouldComponentUpdate',
          value: function shouldComponentUpdate(nextProps) {
              var values = this.props.values;
              var nextValues = nextProps.values;
  
  
              if (!shallowEquals(nextValues, values)) {
                  return true;
              }
  
              // Since `values` has already been checked, we know they're not
              // different, so the current `values` are carried over so the shallow
              // equals comparison on the other props isn't affected by the `values`.
              var nextPropsToCheck = babelHelpers$1['extends']({}, nextProps, {
                  values: values
              });
  
              for (var _len = arguments.length, next = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  next[_key - 1] = arguments[_key];
              }
  
              return shouldIntlComponentUpdate.apply(undefined, [this, nextPropsToCheck].concat(next));
          }
      }, {
          key: 'render',
          value: function render() {
              var formatHTMLMessage = this.context.intl.formatHTMLMessage;
              var _props = this.props;
              var id = _props.id;
              var description = _props.description;
              var defaultMessage = _props.defaultMessage;
              var rawValues = _props.values;
              var tagName = _props.tagName;
              var children = _props.children;
  
  
              var descriptor = { id: id, description: description, defaultMessage: defaultMessage };
              var formattedHTMLMessage = formatHTMLMessage(descriptor, rawValues);
  
              if (typeof children === 'function') {
                  return children(formattedHTMLMessage);
              }
  
              // Since the message presumably has HTML in it, we need to set
              // `innerHTML` in order for it to be rendered and not escaped by React.
              // To be safe, all string prop values were escaped when formatting the
              // message. It is assumed that the message is not UGC, and came from the
              // developer making it more like a template.
              //
              // Note: There's a perf impact of using this component since there's no
              // way for React to do its virtual DOM diffing.
              return React.createElement(tagName, {
                  dangerouslySetInnerHTML: {
                      __html: formattedHTMLMessage
                  }
              });
          }
      }]);
      return FormattedHTMLMessage;
  }(React.Component);
  
  FormattedHTMLMessage.displayName = 'FormattedHTMLMessage';
  
  FormattedHTMLMessage.contextTypes = {
      intl: intlShape
  };
  
  FormattedHTMLMessage.propTypes = babelHelpers$1['extends']({}, messageDescriptorPropTypes, {
      values: React.PropTypes.object,
      tagName: React.PropTypes.string,
      children: React.PropTypes.func
  });
  
  FormattedHTMLMessage.defaultProps = {
      values: {},
      tagName: 'span'
  };
  
  /*
   * Copyright 2015, Yahoo Inc.
   * Copyrights licensed under the New BSD License.
   * See the accompanying LICENSE file for terms.
   */
  
  addLocaleData(defaultLocaleData);
  
  exports.addLocaleData = addLocaleData;
  exports.intlShape = intlShape;
  exports.injectIntl = injectIntl;
  exports.defineMessages = defineMessages;
  exports.IntlProvider = IntlProvider;
  exports.FormattedDate = FormattedDate;
  exports.FormattedTime = FormattedTime;
  exports.FormattedRelative = FormattedRelative;
  exports.FormattedNumber = FormattedNumber;
  exports.FormattedPlural = FormattedPlural;
  exports.FormattedMessage = FormattedMessage;
  exports.FormattedHTMLMessage = FormattedHTMLMessage;
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  })));
  //# sourceMappingURL=react-intl.js.map
  