diff options
Diffstat (limited to 'web/static/js/react-intl-2.0.0-beta-2/react-intl.js')
| -rw-r--r-- | web/static/js/react-intl-2.0.0-beta-2/react-intl.js | 3842 |
1 files changed, 3842 insertions, 0 deletions
diff --git a/web/static/js/react-intl-2.0.0-beta-2/react-intl.js b/web/static/js/react-intl-2.0.0-beta-2/react-intl.js new file mode 100644 index 000000000..1f6d611fe --- /dev/null +++ b/web/static/js/react-intl-2.0.0-beta-2/react-intl.js @@ -0,0 +1,3842 @@ +/* + * Copyright 2015, 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.React); +}(this, function (exports,React) { 'use strict'; + + var React__default = 'default' in React ? React['default'] : React; + + var babelHelpers = {}; + + babelHelpers.typeof = function (obj) { + return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; + }; + + babelHelpers.classCallCheck = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + }; + + babelHelpers.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; + }; + })(); + + babelHelpers.defineProperty = 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; + }; + + babelHelpers.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; + }; + + babelHelpers.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; + }; + + babelHelpers.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; + }; + + babelHelpers.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); + } + }; + + babelHelpers; + // 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" } } } } }; + + // 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"; + } }; + + /* + 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$1 = 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$1.call(source, key)) { + obj[key] = source[key]; + } + } + } + + return obj; + } + + // Purposely using the same implementation as the Intl.js `Intl` polyfill. + // Copyright 2013 Andy Earnshaw, MIT License + + 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 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 + }; + })(); + + 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; + }; + + // -- 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$1(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$1(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$1(MessageFormat, '__localeData__', { value: objCreate$1(null) }); + defineProperty$1(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$1(MessageFormat, '__parse', { value: parser.parse }); + + // Define public `defaultLocale` property which defaults to English, but can be + // set by the developer. + defineProperty$1(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$1.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$1.call(defaults, type)) { + continue; + } + + mergedFormats[type] = mergedType = objCreate$1(defaults[type]); + + if (formats && hop$1.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); + }; + + MessageFormat.__addLocaleData(defaultLocale$1); + MessageFormat.defaultLocale = 'en'; + + // 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"; + }, "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" } } } } }; + + // Purposely using the same implementation as the Intl.js `Intl` polyfill. + // Copyright 2013 Andy Earnshaw, MIT License + + var hop$2 = Object.prototype.hasOwnProperty; + var toString = Object.prototype.toString; + + var realDefineProp$2 = (function () { + try { + return !!Object.defineProperty({}, 'a', {}); + } catch (e) { + return false; + } + })(); + + var es3$2 = !realDefineProp$2 && !Object.prototype.__defineGetter__; + + var defineProperty$2 = 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$2(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 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 + }; + } + + // ----------------------------------------------------------------------------- + + 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$2(this, '_locale', { value: this._resolveLocale(locales) }); + defineProperty$2(this, '_options', { value: { + style: this._resolveStyle(options.style), + units: this._isValidUnits(options.units) && options.units + } }); + + defineProperty$2(this, '_locales', { value: locales }); + defineProperty$2(this, '_fields', { value: this._findFields(this._locale) }); + defineProperty$2(this, '_messages', { value: objCreate$2(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$2(RelativeFormat, '__localeData__', { value: objCreate$2(null) }); + defineProperty$2(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$2(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$2(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; + }; + + RelativeFormat.__addLocaleData(defaultLocale); + RelativeFormat.defaultLocale = 'en'; + + function addLocaleData() { + var data = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0]; + + var locales = Array.isArray(data) ? data : [data]; + + locales.forEach(function (localeData) { + MessageFormat.__addLocaleData(localeData); + RelativeFormat.__addLocaleData(localeData); + }); + } + + function hasLocaleData(locale) { + var normalizedLocale = locale && locale.toLowerCase(); + + return !!(MessageFormat.__localeData__[normalizedLocale] && RelativeFormat.__localeData__[normalizedLocale]); + } + + 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.extends({}, intlConfigPropTypes, intlFormatPropTypes, { + 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']) + }; + + var invariant = (function (module) { + var exports = module.exports; + /** + * 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 __DEV__ = "development" !== 'production'; + + var invariant = function invariant(condition, format, a, b, c, d, e, f) { + if (__DEV__) { + 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; + return module.exports; + })({exports:{}}); + + var ESCAPED_CHARS = { + '&': '&', + '>': '>', + '<': '<', + '"': '"', + '\'': ''' + }; + + var UNSAFE_CHARS_REGEX = /[&><"']/g; + + function escape(str) { + return ('' + str).replace(UNSAFE_CHARS_REGEX, function (match) { + return ESCAPED_CHARS[match]; + }); + } + + 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.typeof(objA)) !== 'object' || objA === null || (typeof objB === 'undefined' ? 'undefined' : babelHelpers.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) || !shallowEquals(nextIntl, intl); + } + + 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) { + babelHelpers.inherits(InjectIntl, _Component); + + function InjectIntl(props, context) { + babelHelpers.classCallCheck(this, InjectIntl); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(InjectIntl).call(this, props, context)); + + invariantIntlContext(context); + return _this; + } + + babelHelpers.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.extends({}, this.props, babelHelpers.defineProperty({}, 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; + } + + 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); + + function filterFormatOptions(whitelist, obj) { + var defaults = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + return whitelist.reduce(function (opts, name) { + if (obj.hasOwnProperty(name)) { + opts[name] = obj[name]; + } else if (defaults.hasOwnProperty(name)) { + opts[name] = defaults[name]; + } + + return opts; + }, {}); + } + + 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 = filterFormatOptions(DATE_TIME_FORMAT_OPTIONS, options, defaults); + + return state.getDateTimeFormat(locale, filteredOptions).format(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 = filterFormatOptions(DATE_TIME_FORMAT_OPTIONS, options, defaults); + + return state.getDateTimeFormat(locale, filteredOptions).format(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 = filterFormatOptions(RELATIVE_FORMAT_OPTIONS, options, defaults); + + return state.getRelativeFormat(locale, filteredOptions).format(date, { + now: isFinite(now) ? now : state.now() + }); + } + + 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 = filterFormatOptions(NUMBER_FORMAT_OPTIONS, options, defaults); + + return state.getNumberFormat(locale, filteredOptions).format(value); + } + + function formatPlural(config, state, value) { + var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3]; + var locale = config.locale; + + var filteredOptions = filterFormatOptions(PLURAL_FORMAT_OPTIONS, options); + + return state.getPluralFormat(locale, filteredOptions).format(value); + } + + 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 = undefined; + + 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') { + 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 (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 = Object.prototype.hasOwnProperty; + + 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 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]; + babelHelpers.classCallCheck(this, IntlPluralFormat); + + var useOrdinal = options.style === 'ordinal'; + var pluralFn = findPluralFunction(resolveLocale(locales)); + + this.format = function (value) { + return pluralFn(value, useOrdinal); + }; + }; + + // ----------------------------------------------------------------------------- + + function createFormatCache(FormatConstructor) { + var cache = objCreate(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.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; + } + + var intlConfigPropNames = Object.keys(intlConfigPropTypes); + var intlFormatPropNames = Object.keys(intlFormatPropTypes); + + var IntlProvider = (function (_Component) { + babelHelpers.inherits(IntlProvider, _Component); + + function IntlProvider(props, context) { + babelHelpers.classCallCheck(this, IntlProvider); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(IntlProvider).call(this, props, context)); + + invariant(Intl, '[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/'); + + // Used to stabilize time when performing an initial rendering so that + // all relative times use the same reference "now" time. + var initialNow = undefined; + 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 = context.intl ? context.intl.now() : Date.now(); + } + + _this.state = { + // Creating `Intl*` formatters is expensive so these format caches + // memoize the `Intl*` constructors and have the same lifecycle as + // this IntlProvider instance. + getDateTimeFormat: createFormatCache(Intl.DateTimeFormat), + getNumberFormat: createFormatCache(Intl.NumberFormat), + getMessageFormat: createFormatCache(MessageFormat), + getRelativeFormat: createFormatCache(RelativeFormat), + getPluralFormat: createFormatCache(IntlPluralFormat), + + // Wrapper to provide stable "now" time for initial render. + now: function now() { + return _this._didDisplay ? Date.now() : initialNow; + } + }; + return _this; + } + + babelHelpers.createClass(IntlProvider, [{ + key: 'getConfig', + value: function getConfig() { + var _this2 = this; + + var _context$intl = this.context.intl; + var intlContext = _context$intl === undefined ? {} : _context$intl; + + // Build a whitelisted config object from `props` and `context.intl`, if + // an <IntlProvider> exists in the ancestry. + + var config = intlConfigPropNames.reduce(function (config, name) { + config[name] = _this2.props[name] || intlContext[name]; + return config; + }, {}); + + 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.extends({}, config, { + locale: defaultLocale, + formats: defaultFormats, + messages: IntlProvider.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); + + return { + intl: babelHelpers.extends({}, config, boundFormatFns, { + now: this.state.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.extends({}, intlConfigPropTypes, { + children: React.PropTypes.element.isRequired, + initialNow: React.PropTypes.any + }); + + IntlProvider.defaultProps = { + formats: {}, + messages: {}, + + defaultLocale: 'en', + defaultFormats: {} + }; + + var FormattedDate = (function (_Component) { + babelHelpers.inherits(FormattedDate, _Component); + + function FormattedDate(props, context) { + babelHelpers.classCallCheck(this, FormattedDate); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(FormattedDate).call(this, props, context)); + + invariantIntlContext(context); + return _this; + } + + babelHelpers.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.extends({}, dateTimeFormatPropTypes, { + value: React.PropTypes.any.isRequired, + format: React.PropTypes.string, + children: React.PropTypes.func + }); + + var FormattedTime = (function (_Component) { + babelHelpers.inherits(FormattedTime, _Component); + + function FormattedTime(props, context) { + babelHelpers.classCallCheck(this, FormattedTime); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(FormattedTime).call(this, props, context)); + + invariantIntlContext(context); + return _this; + } + + babelHelpers.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.extends({}, dateTimeFormatPropTypes, { + value: React.PropTypes.any.isRequired, + format: React.PropTypes.string, + children: React.PropTypes.func + }); + + 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; + } + } + + var FormattedRelative = (function (_Component) { + babelHelpers.inherits(FormattedRelative, _Component); + + function FormattedRelative(props, context) { + babelHelpers.classCallCheck(this, FormattedRelative); + + var _this = babelHelpers.possibleConstructorReturn(this, 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; + } + + babelHelpers.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 delta = Number(props.value) - 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: '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: 'componentDidMount', + value: function componentDidMount() { + this.scheduleNextUpdate(this.props, this.state); + } + }, { + 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.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.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 + }; + + var FormattedNumber = (function (_Component) { + babelHelpers.inherits(FormattedNumber, _Component); + + function FormattedNumber(props, context) { + babelHelpers.classCallCheck(this, FormattedNumber); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(FormattedNumber).call(this, props, context)); + + invariantIntlContext(context); + return _this; + } + + babelHelpers.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.extends({}, numberFormatPropTypes, { + value: React.PropTypes.any.isRequired, + format: React.PropTypes.string, + children: React.PropTypes.func + }); + + var FormattedPlural = (function (_Component) { + babelHelpers.inherits(FormattedPlural, _Component); + + function FormattedPlural(props, context) { + babelHelpers.classCallCheck(this, FormattedPlural); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(FormattedPlural).call(this, props, context)); + + invariantIntlContext(context); + return _this; + } + + babelHelpers.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.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' + }; + + var FormattedMessage = (function (_Component) { + babelHelpers.inherits(FormattedMessage, _Component); + + function FormattedMessage(props, context) { + babelHelpers.classCallCheck(this, FormattedMessage); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(FormattedMessage).call(this, props, context)); + + invariantIntlContext(context); + return _this; + } + + babelHelpers.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.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; + + // 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 tokenRegexp = new RegExp('(@__ELEMENT-' + uid + '-\\d+__@)', 'g'); + + var generateToken = (function () { + var counter = 0; + return function () { + return '@__ELEMENT-' + uid + '-' + (counter += 1) + '__@'; + }; + })(); + + var tokenizedValues = {}; + var 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] = token; + elements[token] = value; + } else { + tokenizedValues[name] = value; + } + }); + + var descriptor = { id: id, description: description, defaultMessage: defaultMessage }; + var formattedMessage = formatMessage(descriptor, tokenizedValues); + + // 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. + var nodes = formattedMessage.split(tokenRegexp).filter(function (part) { + return !!part; + }).map(function (part) { + return elements[part] || part; + }); + + if (typeof children === 'function') { + return children.apply(undefined, babelHelpers.toConsumableArray(nodes)); + } + + return React.createElement.apply(undefined, [tagName, null].concat(babelHelpers.toConsumableArray(nodes))); + } + }]); + return FormattedMessage; + })(React.Component); + + FormattedMessage.displayName = 'FormattedMessage'; + + FormattedMessage.contextTypes = { + intl: intlShape + }; + + FormattedMessage.propTypes = babelHelpers.extends({}, messageDescriptorPropTypes, { + values: React.PropTypes.object, + tagName: React.PropTypes.string, + children: React.PropTypes.func + }); + + FormattedMessage.defaultProps = { + values: {}, + tagName: 'span' + }; + + var FormattedHTMLMessage = (function (_Component) { + babelHelpers.inherits(FormattedHTMLMessage, _Component); + + function FormattedHTMLMessage(props, context) { + babelHelpers.classCallCheck(this, FormattedHTMLMessage); + + var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(FormattedHTMLMessage).call(this, props, context)); + + invariantIntlContext(context); + return _this; + } + + babelHelpers.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.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.extends({}, messageDescriptorPropTypes, { + values: React.PropTypes.object, + tagName: React.PropTypes.string, + children: React.PropTypes.func + }); + + FormattedHTMLMessage.defaultProps = { + values: {}, + tagName: 'span' + }; + + addLocaleData(defaultLocaleData); + + 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; + } + + exports.addLocaleData = addLocaleData; + exports.defineMessages = defineMessages; + exports.intlShape = intlShape; + exports.injectIntl = injectIntl; + exports.IntlProvider = IntlProvider; + exports.FormattedDate = FormattedDate; + exports.FormattedTime = FormattedTime; + exports.FormattedRelative = FormattedRelative; + exports.FormattedNumber = FormattedNumber; + exports.FormattedPlural = FormattedPlural; + exports.FormattedMessage = FormattedMessage; + exports.FormattedHTMLMessage = FormattedHTMLMessage; + +})); +//# sourceMappingURL=react-intl.js.map
\ No newline at end of file |