react-intl-polyfill
Version:
React component that add window.Intl support before rendering if the browser doesn't have it
1,374 lines (1,373 loc) • 87.3 kB
JavaScript
import { a as createCommonjsModule, b as unwrapExports, c as commonjsGlobal } from './chunk-7b6dff8b.js';
var core = createCommonjsModule(function (module) {
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
};
var jsx = function () {
var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
return function createRawReactElement(type, props, key, children) {
var defaultProps = type && type.defaultProps;
var childrenLength = arguments.length - 3;
if (!props && childrenLength !== 0) {
props = {};
}
if (props && defaultProps) {
for (var propName in defaultProps) {
if (props[propName] === void 0) {
props[propName] = defaultProps[propName];
}
}
} else if (!props) {
props = defaultProps || {};
}
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 3];
}
props.children = childArray;
}
return {
$$typeof: REACT_ELEMENT_TYPE,
type: type,
key: key === undefined ? null : '' + key,
ref: null,
props: props,
_owner: null
};
};
}();
var asyncToGenerator = function (fn) {
return function () {
var gen = fn.apply(this, arguments);
return new Promise(function (resolve, reject) {
function step(key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
return Promise.resolve(value).then(function (value) {
return step("next", value);
}, function (err) {
return step("throw", err);
});
}
}
return step("next");
});
};
};
var classCallCheck = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
var createClass = function () {
function defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
};
}();
var defineEnumerableProperties = function (obj, descs) {
for (var key in descs) {
var desc = descs[key];
desc.configurable = desc.enumerable = true;
if ("value" in desc) desc.writable = true;
Object.defineProperty(obj, key, desc);
}
return obj;
};
var defaults = function (obj, defaults) {
var keys = Object.getOwnPropertyNames(defaults);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var value = Object.getOwnPropertyDescriptor(defaults, key);
if (value && value.configurable && obj[key] === undefined) {
Object.defineProperty(obj, key, value);
}
}
return obj;
};
var defineProperty$1 = function (obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
};
var _extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
var get = function get(object, property, receiver) {
if (object === null) object = Function.prototype;
var desc = Object.getOwnPropertyDescriptor(object, property);
if (desc === undefined) {
var parent = Object.getPrototypeOf(object);
if (parent === null) {
return undefined;
} else {
return get(parent, property, receiver);
}
} else if ("value" in desc) {
return desc.value;
} else {
var getter = desc.get;
if (getter === undefined) {
return undefined;
}
return getter.call(receiver);
}
};
var inherits = function (subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
enumerable: false,
writable: true,
configurable: true
}
});
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};
var _instanceof = function (left, right) {
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
return right[Symbol.hasInstance](left);
} else {
return left instanceof right;
}
};
var interopRequireDefault = function (obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
};
var interopRequireWildcard = function (obj) {
if (obj && obj.__esModule) {
return obj;
} else {
var newObj = {};
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
}
}
newObj.default = obj;
return newObj;
}
};
var newArrowCheck = function (innerThis, boundThis) {
if (innerThis !== boundThis) {
throw new TypeError("Cannot instantiate an arrow function");
}
};
var objectDestructuringEmpty = function (obj) {
if (obj == null) throw new TypeError("Cannot destructure undefined");
};
var objectWithoutProperties = function (obj, keys) {
var target = {};
for (var i in obj) {
if (keys.indexOf(i) >= 0) continue;
if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
target[i] = obj[i];
}
return target;
};
var possibleConstructorReturn = function (self, call) {
if (!self) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return call && (typeof call === "object" || typeof call === "function") ? call : self;
};
var selfGlobal = typeof commonjsGlobal === "undefined" ? self : commonjsGlobal;
var set = function set(object, property, value, receiver) {
var desc = Object.getOwnPropertyDescriptor(object, property);
if (desc === undefined) {
var parent = Object.getPrototypeOf(object);
if (parent !== null) {
set(parent, property, value, receiver);
}
} else if ("value" in desc && desc.writable) {
desc.value = value;
} else {
var setter = desc.set;
if (setter !== undefined) {
setter.call(receiver, value);
}
}
return value;
};
var slicedToArray = function () {
function sliceIterator(arr, i) {
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
try {
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"]) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
return function (arr, i) {
if (Array.isArray(arr)) {
return arr;
} else if (Symbol.iterator in Object(arr)) {
return sliceIterator(arr, i);
} else {
throw new TypeError("Invalid attempt to destructure non-iterable instance");
}
};
}();
var slicedToArrayLoose = function (arr, i) {
if (Array.isArray(arr)) {
return arr;
} else if (Symbol.iterator in Object(arr)) {
var _arr = [];
for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
_arr.push(_step.value);
if (i && _arr.length === i) break;
}
return _arr;
} else {
throw new TypeError("Invalid attempt to destructure non-iterable instance");
}
};
var taggedTemplateLiteral = function (strings, raw) {
return Object.freeze(Object.defineProperties(strings, {
raw: {
value: Object.freeze(raw)
}
}));
};
var taggedTemplateLiteralLoose = function (strings, raw) {
strings.raw = raw;
return strings;
};
var temporalRef = function (val, name, undef) {
if (val === undef) {
throw new ReferenceError(name + " is not defined - temporal dead zone");
} else {
return val;
}
};
var temporalUndefined = {};
var toArray = function (arr) {
return Array.isArray(arr) ? arr : Array.from(arr);
};
var toConsumableArray = function (arr) {
if (Array.isArray(arr)) {
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
return arr2;
} else {
return Array.from(arr);
}
};
var babelHelpers$1 = Object.freeze({
jsx: jsx,
asyncToGenerator: asyncToGenerator,
classCallCheck: classCallCheck,
createClass: createClass,
defineEnumerableProperties: defineEnumerableProperties,
defaults: defaults,
defineProperty: defineProperty$1,
get: get,
inherits: inherits,
interopRequireDefault: interopRequireDefault,
interopRequireWildcard: interopRequireWildcard,
newArrowCheck: newArrowCheck,
objectDestructuringEmpty: objectDestructuringEmpty,
objectWithoutProperties: objectWithoutProperties,
possibleConstructorReturn: possibleConstructorReturn,
selfGlobal: selfGlobal,
set: set,
slicedToArray: slicedToArray,
slicedToArrayLoose: slicedToArrayLoose,
taggedTemplateLiteral: taggedTemplateLiteral,
taggedTemplateLiteralLoose: taggedTemplateLiteralLoose,
temporalRef: temporalRef,
temporalUndefined: temporalUndefined,
toArray: toArray,
toConsumableArray: toConsumableArray,
typeof: _typeof,
extends: _extends,
instanceof: _instanceof
});
var realDefineProp = function () {
var sentinel = function sentinel() {};
try {
Object.defineProperty(sentinel, 'a', {
get: function get() {
return 1;
}
});
Object.defineProperty(sentinel, 'prototype', { writable: false });
return sentinel.a === 1 && sentinel.prototype instanceof Object;
} catch (e) {
return false;
}
}();
var es3 = !realDefineProp && !Object.prototype.__defineGetter__;
var hop = Object.prototype.hasOwnProperty;
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 arrIndexOf = Array.prototype.indexOf || function (search) {
var t = this;
if (!t.length) return -1;
for (var i = arguments[1] || 0, max = t.length; i < max; i++) {
if (t[i] === search) return i;
}
return -1;
};
var objCreate = Object.create || function (proto, props) {
var obj = void 0;
function F() {}
F.prototype = proto;
obj = new F();
for (var k in props) {
if (hop.call(props, k)) defineProperty(obj, k, props[k]);
}
return obj;
};
var arrSlice = Array.prototype.slice;
var arrConcat = Array.prototype.concat;
var arrPush = Array.prototype.push;
var arrJoin = Array.prototype.join;
var arrShift = Array.prototype.shift;
var fnBind = Function.prototype.bind || function (thisObj) {
var fn = this,
args = arrSlice.call(arguments, 1);
if (fn.length === 1) {
return function () {
return fn.apply(thisObj, arrConcat.call(args, arrSlice.call(arguments)));
};
}
return function () {
return fn.apply(thisObj, arrConcat.call(args, arrSlice.call(arguments)));
};
};
var internals = objCreate(null);
var secret = Math.random();
function log10Floor(n) {
if (typeof Math.log10 === 'function') return Math.floor(Math.log10(n));
var x = Math.round(Math.log(n) * Math.LOG10E);
return x - (Number('1e' + x) > n);
}
function Record(obj) {
for (var k in obj) {
if (obj instanceof Record || hop.call(obj, k)) defineProperty(this, k, { value: obj[k], enumerable: true, writable: true, configurable: true });
}
}
Record.prototype = objCreate(null);
function List() {
defineProperty(this, 'length', { writable: true, value: 0 });
if (arguments.length) arrPush.apply(this, arrSlice.call(arguments));
}
List.prototype = objCreate(null);
function createRegExpRestore() {
if (internals.disableRegExpRestore) {
return function () {};
}
var regExpCache = {
lastMatch: RegExp.lastMatch || '',
leftContext: RegExp.leftContext,
multiline: RegExp.multiline,
input: RegExp.input
},
has = false;
for (var i = 1; i <= 9; i++) {
has = (regExpCache['$' + i] = RegExp['$' + i]) || has;
}return function () {
var esc = /[.?*+^$[\]\\(){}|-]/g,
lm = regExpCache.lastMatch.replace(esc, '\\$&'),
reg = new List();
if (has) {
for (var _i = 1; _i <= 9; _i++) {
var m = regExpCache['$' + _i];
if (!m) lm = '()' + lm;
else {
m = m.replace(esc, '\\$&');
lm = lm.replace(m, '(' + m + ')');
}
arrPush.call(reg, lm.slice(0, lm.indexOf('(') + 1));
lm = lm.slice(lm.indexOf('(') + 1);
}
}
var exprStr = arrJoin.call(reg, '') + lm;
exprStr = exprStr.replace(/(\\\(|\\\)|[^()])+/g, function (match) {
return '[\\s\\S]{' + match.replace('\\', '').length + '}';
});
var expr = new RegExp(exprStr, regExpCache.multiline ? 'gm' : 'g');
expr.lastIndex = regExpCache.leftContext.length;
expr.exec(regExpCache.input);
};
}
function toObject(arg) {
if (arg === null) throw new TypeError('Cannot convert null or undefined to object');
if ((typeof arg === 'undefined' ? 'undefined' : babelHelpers$1['typeof'](arg)) === 'object') return arg;
return Object(arg);
}
function toNumber(arg) {
if (typeof arg === 'number') return arg;
return Number(arg);
}
function toInteger(arg) {
var number = toNumber(arg);
if (isNaN(number)) return 0;
if (number === +0 || number === -0 || number === +Infinity || number === -Infinity) return number;
if (number < 0) return Math.floor(Math.abs(number)) * -1;
return Math.floor(Math.abs(number));
}
function toLength(arg) {
var len = toInteger(arg);
if (len <= 0) return 0;
if (len === Infinity) return Math.pow(2, 53) - 1;
return Math.min(len, Math.pow(2, 53) - 1);
}
function getInternalProperties(obj) {
if (hop.call(obj, '__getInternalProperties')) return obj.__getInternalProperties(secret);
return objCreate(null);
}
var extlang = '[a-z]{3}(?:-[a-z]{3}){0,2}';
var language = '(?:[a-z]{2,3}(?:-' + extlang + ')?|[a-z]{4}|[a-z]{5,8})';
var script = '[a-z]{4}';
var region = '(?:[a-z]{2}|\\d{3})';
var variant = '(?:[a-z0-9]{5,8}|\\d[a-z0-9]{3})';
var singleton = '[0-9a-wy-z]';
var extension = singleton + '(?:-[a-z0-9]{2,8})+';
var privateuse = 'x(?:-[a-z0-9]{1,8})+';
var irregular = '(?:en-GB-oed' + '|i-(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)' + '|sgn-(?:BE-FR|BE-NL|CH-DE))';
var regular = '(?:art-lojban|cel-gaulish|no-bok|no-nyn' + '|zh-(?:guoyu|hakka|min|min-nan|xiang))';
var grandfathered = '(?:' + irregular + '|' + regular + ')';
var langtag = language + '(?:-' + script + ')?(?:-' + region + ')?(?:-' + variant + ')*(?:-' + extension + ')*(?:-' + privateuse + ')?';
var expBCP47Syntax = RegExp('^(?:' + langtag + '|' + privateuse + '|' + grandfathered + ')$', 'i');
var expVariantDupes = RegExp('^(?!x).*?-(' + variant + ')-(?:\\w{4,8}-(?!x-))*\\1\\b', 'i');
var expSingletonDupes = RegExp('^(?!x).*?-(' + singleton + ')-(?:\\w+-(?!x-))*\\1\\b', 'i');
var expExtSequences = RegExp('-' + extension, 'ig');
var defaultLocale = void 0;
function setDefaultLocale(locale) {
defaultLocale = locale;
}
var redundantTags = {
tags: {
"art-lojban": "jbo",
"i-ami": "ami",
"i-bnn": "bnn",
"i-hak": "hak",
"i-klingon": "tlh",
"i-lux": "lb",
"i-navajo": "nv",
"i-pwn": "pwn",
"i-tao": "tao",
"i-tay": "tay",
"i-tsu": "tsu",
"no-bok": "nb",
"no-nyn": "nn",
"sgn-BE-FR": "sfb",
"sgn-BE-NL": "vgt",
"sgn-CH-DE": "sgg",
"zh-guoyu": "cmn",
"zh-hakka": "hak",
"zh-min-nan": "nan",
"zh-xiang": "hsn",
"sgn-BR": "bzs",
"sgn-CO": "csn",
"sgn-DE": "gsg",
"sgn-DK": "dsl",
"sgn-ES": "ssp",
"sgn-FR": "fsl",
"sgn-GB": "bfi",
"sgn-GR": "gss",
"sgn-IE": "isg",
"sgn-IT": "ise",
"sgn-JP": "jsl",
"sgn-MX": "mfs",
"sgn-NI": "ncs",
"sgn-NL": "dse",
"sgn-NO": "nsl",
"sgn-PT": "psr",
"sgn-SE": "swl",
"sgn-US": "ase",
"sgn-ZA": "sfs",
"zh-cmn": "cmn",
"zh-cmn-Hans": "cmn-Hans",
"zh-cmn-Hant": "cmn-Hant",
"zh-gan": "gan",
"zh-wuu": "wuu",
"zh-yue": "yue"
},
subtags: {
BU: "MM",
DD: "DE",
FX: "FR",
TP: "TL",
YD: "YE",
ZR: "CD",
heploc: "alalc97",
'in': "id",
iw: "he",
ji: "yi",
jw: "jv",
mo: "ro",
ayx: "nun",
bjd: "drl",
ccq: "rki",
cjr: "mom",
cka: "cmr",
cmk: "xch",
drh: "khk",
drw: "prs",
gav: "dev",
hrr: "jal",
ibi: "opa",
kgh: "kml",
lcq: "ppr",
mst: "mry",
myt: "mry",
sca: "hle",
tie: "ras",
tkk: "twm",
tlw: "weo",
tnf: "prs",
ybd: "rki",
yma: "lrr"
},
extLang: {
aao: ["aao", "ar"],
abh: ["abh", "ar"],
abv: ["abv", "ar"],
acm: ["acm", "ar"],
acq: ["acq", "ar"],
acw: ["acw", "ar"],
acx: ["acx", "ar"],
acy: ["acy", "ar"],
adf: ["adf", "ar"],
ads: ["ads", "sgn"],
aeb: ["aeb", "ar"],
aec: ["aec", "ar"],
aed: ["aed", "sgn"],
aen: ["aen", "sgn"],
afb: ["afb", "ar"],
afg: ["afg", "sgn"],
ajp: ["ajp", "ar"],
apc: ["apc", "ar"],
apd: ["apd", "ar"],
arb: ["arb", "ar"],
arq: ["arq", "ar"],
ars: ["ars", "ar"],
ary: ["ary", "ar"],
arz: ["arz", "ar"],
ase: ["ase", "sgn"],
asf: ["asf", "sgn"],
asp: ["asp", "sgn"],
asq: ["asq", "sgn"],
asw: ["asw", "sgn"],
auz: ["auz", "ar"],
avl: ["avl", "ar"],
ayh: ["ayh", "ar"],
ayl: ["ayl", "ar"],
ayn: ["ayn", "ar"],
ayp: ["ayp", "ar"],
bbz: ["bbz", "ar"],
bfi: ["bfi", "sgn"],
bfk: ["bfk", "sgn"],
bjn: ["bjn", "ms"],
bog: ["bog", "sgn"],
bqn: ["bqn", "sgn"],
bqy: ["bqy", "sgn"],
btj: ["btj", "ms"],
bve: ["bve", "ms"],
bvl: ["bvl", "sgn"],
bvu: ["bvu", "ms"],
bzs: ["bzs", "sgn"],
cdo: ["cdo", "zh"],
cds: ["cds", "sgn"],
cjy: ["cjy", "zh"],
cmn: ["cmn", "zh"],
coa: ["coa", "ms"],
cpx: ["cpx", "zh"],
csc: ["csc", "sgn"],
csd: ["csd", "sgn"],
cse: ["cse", "sgn"],
csf: ["csf", "sgn"],
csg: ["csg", "sgn"],
csl: ["csl", "sgn"],
csn: ["csn", "sgn"],
csq: ["csq", "sgn"],
csr: ["csr", "sgn"],
czh: ["czh", "zh"],
czo: ["czo", "zh"],
doq: ["doq", "sgn"],
dse: ["dse", "sgn"],
dsl: ["dsl", "sgn"],
dup: ["dup", "ms"],
ecs: ["ecs", "sgn"],
esl: ["esl", "sgn"],
esn: ["esn", "sgn"],
eso: ["eso", "sgn"],
eth: ["eth", "sgn"],
fcs: ["fcs", "sgn"],
fse: ["fse", "sgn"],
fsl: ["fsl", "sgn"],
fss: ["fss", "sgn"],
gan: ["gan", "zh"],
gds: ["gds", "sgn"],
gom: ["gom", "kok"],
gse: ["gse", "sgn"],
gsg: ["gsg", "sgn"],
gsm: ["gsm", "sgn"],
gss: ["gss", "sgn"],
gus: ["gus", "sgn"],
hab: ["hab", "sgn"],
haf: ["haf", "sgn"],
hak: ["hak", "zh"],
hds: ["hds", "sgn"],
hji: ["hji", "ms"],
hks: ["hks", "sgn"],
hos: ["hos", "sgn"],
hps: ["hps", "sgn"],
hsh: ["hsh", "sgn"],
hsl: ["hsl", "sgn"],
hsn: ["hsn", "zh"],
icl: ["icl", "sgn"],
ils: ["ils", "sgn"],
inl: ["inl", "sgn"],
ins: ["ins", "sgn"],
ise: ["ise", "sgn"],
isg: ["isg", "sgn"],
isr: ["isr", "sgn"],
jak: ["jak", "ms"],
jax: ["jax", "ms"],
jcs: ["jcs", "sgn"],
jhs: ["jhs", "sgn"],
jls: ["jls", "sgn"],
jos: ["jos", "sgn"],
jsl: ["jsl", "sgn"],
jus: ["jus", "sgn"],
kgi: ["kgi", "sgn"],
knn: ["knn", "kok"],
kvb: ["kvb", "ms"],
kvk: ["kvk", "sgn"],
kvr: ["kvr", "ms"],
kxd: ["kxd", "ms"],
lbs: ["lbs", "sgn"],
lce: ["lce", "ms"],
lcf: ["lcf", "ms"],
liw: ["liw", "ms"],
lls: ["lls", "sgn"],
lsg: ["lsg", "sgn"],
lsl: ["lsl", "sgn"],
lso: ["lso", "sgn"],
lsp: ["lsp", "sgn"],
lst: ["lst", "sgn"],
lsy: ["lsy", "sgn"],
ltg: ["ltg", "lv"],
lvs: ["lvs", "lv"],
lzh: ["lzh", "zh"],
max: ["max", "ms"],
mdl: ["mdl", "sgn"],
meo: ["meo", "ms"],
mfa: ["mfa", "ms"],
mfb: ["mfb", "ms"],
mfs: ["mfs", "sgn"],
min: ["min", "ms"],
mnp: ["mnp", "zh"],
mqg: ["mqg", "ms"],
mre: ["mre", "sgn"],
msd: ["msd", "sgn"],
msi: ["msi", "ms"],
msr: ["msr", "sgn"],
mui: ["mui", "ms"],
mzc: ["mzc", "sgn"],
mzg: ["mzg", "sgn"],
mzy: ["mzy", "sgn"],
nan: ["nan", "zh"],
nbs: ["nbs", "sgn"],
ncs: ["ncs", "sgn"],
nsi: ["nsi", "sgn"],
nsl: ["nsl", "sgn"],
nsp: ["nsp", "sgn"],
nsr: ["nsr", "sgn"],
nzs: ["nzs", "sgn"],
okl: ["okl", "sgn"],
orn: ["orn", "ms"],
ors: ["ors", "ms"],
pel: ["pel", "ms"],
pga: ["pga", "ar"],
pks: ["pks", "sgn"],
prl: ["prl", "sgn"],
prz: ["prz", "sgn"],
psc: ["psc", "sgn"],
psd: ["psd", "sgn"],
pse: ["pse", "ms"],
psg: ["psg", "sgn"],
psl: ["psl", "sgn"],
pso: ["pso", "sgn"],
psp: ["psp", "sgn"],
psr: ["psr", "sgn"],
pys: ["pys", "sgn"],
rms: ["rms", "sgn"],
rsi: ["rsi", "sgn"],
rsl: ["rsl", "sgn"],
sdl: ["sdl", "sgn"],
sfb: ["sfb", "sgn"],
sfs: ["sfs", "sgn"],
sgg: ["sgg", "sgn"],
sgx: ["sgx", "sgn"],
shu: ["shu", "ar"],
slf: ["slf", "sgn"],
sls: ["sls", "sgn"],
sqk: ["sqk", "sgn"],
sqs: ["sqs", "sgn"],
ssh: ["ssh", "ar"],
ssp: ["ssp", "sgn"],
ssr: ["ssr", "sgn"],
svk: ["svk", "sgn"],
swc: ["swc", "sw"],
swh: ["swh", "sw"],
swl: ["swl", "sgn"],
syy: ["syy", "sgn"],
tmw: ["tmw", "ms"],
tse: ["tse", "sgn"],
tsm: ["tsm", "sgn"],
tsq: ["tsq", "sgn"],
tss: ["tss", "sgn"],
tsy: ["tsy", "sgn"],
tza: ["tza", "sgn"],
ugn: ["ugn", "sgn"],
ugy: ["ugy", "sgn"],
ukl: ["ukl", "sgn"],
uks: ["uks", "sgn"],
urk: ["urk", "ms"],
uzn: ["uzn", "uz"],
uzs: ["uzs", "uz"],
vgt: ["vgt", "sgn"],
vkk: ["vkk", "ms"],
vkt: ["vkt", "ms"],
vsi: ["vsi", "sgn"],
vsl: ["vsl", "sgn"],
vsv: ["vsv", "sgn"],
wuu: ["wuu", "zh"],
xki: ["xki", "sgn"],
xml: ["xml", "sgn"],
xmm: ["xmm", "ms"],
xms: ["xms", "sgn"],
yds: ["yds", "sgn"],
ysl: ["ysl", "sgn"],
yue: ["yue", "zh"],
zib: ["zib", "sgn"],
zlm: ["zlm", "ms"],
zmi: ["zmi", "ms"],
zsl: ["zsl", "sgn"],
zsm: ["zsm", "ms"]
}
};
function toLatinUpperCase(str) {
var i = str.length;
while (i--) {
var ch = str.charAt(i);
if (ch >= "a" && ch <= "z") str = str.slice(0, i) + ch.toUpperCase() + str.slice(i + 1);
}
return str;
}
function IsStructurallyValidLanguageTag(locale) {
if (!expBCP47Syntax.test(locale)) return false;
if (expVariantDupes.test(locale)) return false;
if (expSingletonDupes.test(locale)) return false;
return true;
}
function CanonicalizeLanguageTag(locale) {
var match = void 0,
parts = void 0;
locale = locale.toLowerCase();
parts = locale.split('-');
for (var i = 1, max = parts.length; i < max; i++) {
if (parts[i].length === 2) parts[i] = parts[i].toUpperCase();
else if (parts[i].length === 4) parts[i] = parts[i].charAt(0).toUpperCase() + parts[i].slice(1);
else if (parts[i].length === 1 && parts[i] !== 'x') break;
}
locale = arrJoin.call(parts, '-');
if ((match = locale.match(expExtSequences)) && match.length > 1) {
match.sort();
locale = locale.replace(RegExp('(?:' + expExtSequences.source + ')+', 'i'), arrJoin.call(match, ''));
}
if (hop.call(redundantTags.tags, locale)) locale = redundantTags.tags[locale];
parts = locale.split('-');
for (var _i = 1, _max = parts.length; _i < _max; _i++) {
if (hop.call(redundantTags.subtags, parts[_i])) parts[_i] = redundantTags.subtags[parts[_i]];else if (hop.call(redundantTags.extLang, parts[_i])) {
parts[_i] = redundantTags.extLang[parts[_i]][0];
if (_i === 1 && redundantTags.extLang[parts[1]][1] === parts[0]) {
parts = arrSlice.call(parts, _i++);
_max -= 1;
}
}
}
return arrJoin.call(parts, '-');
}
function DefaultLocale() {
return defaultLocale;
}
var expCurrencyCode = /^[A-Z]{3}$/;
function IsWellFormedCurrencyCode(currency) {
var c = String(currency);
var normalized = toLatinUpperCase(c);
if (expCurrencyCode.test(normalized) === false) return false;
return true;
}
var expUnicodeExSeq = /-u(?:-[0-9a-z]{2,8})+/gi;
function CanonicalizeLocaleList(locales) {
if (locales === undefined) return new List();
var seen = new List();
locales = typeof locales === 'string' ? [locales] : locales;
var O = toObject(locales);
var len = toLength(O.length);
var k = 0;
while (k < len) {
var Pk = String(k);
var kPresent = Pk in O;
if (kPresent) {
var kValue = O[Pk];
if (kValue === null || typeof kValue !== 'string' && (typeof kValue === "undefined" ? "undefined" : babelHelpers$1["typeof"](kValue)) !== 'object') throw new TypeError('String or Object type expected');
var tag = String(kValue);
if (!IsStructurallyValidLanguageTag(tag)) throw new RangeError("'" + tag + "' is not a structurally valid language tag");
tag = CanonicalizeLanguageTag(tag);
if (arrIndexOf.call(seen, tag) === -1) arrPush.call(seen, tag);
}
k++;
}
return seen;
}
function BestAvailableLocale(availableLocales, locale) {
var candidate = locale;
while (candidate) {
if (arrIndexOf.call(availableLocales, candidate) > -1) return candidate;
var pos = candidate.lastIndexOf('-');
if (pos < 0) return;
if (pos >= 2 && candidate.charAt(pos - 2) === '-') pos -= 2;
candidate = candidate.substring(0, pos);
}
}
function LookupMatcher(availableLocales, requestedLocales) {
var i = 0;
var len = requestedLocales.length;
var availableLocale = void 0;
var locale = void 0,
noExtensionsLocale = void 0;
while (i < len && !availableLocale) {
locale = requestedLocales[i];
noExtensionsLocale = String(locale).replace(expUnicodeExSeq, '');
availableLocale = BestAvailableLocale(availableLocales, noExtensionsLocale);
i++;
}
var result = new Record();
if (availableLocale !== undefined) {
result['[[locale]]'] = availableLocale;
if (String(locale) !== String(noExtensionsLocale)) {
var extension = locale.match(expUnicodeExSeq)[0];
var extensionIndex = locale.indexOf('-u-');
result['[[extension]]'] = extension;
result['[[extensionIndex]]'] = extensionIndex;
}
}
else
result['[[locale]]'] = DefaultLocale();
return result;
}
function BestFitMatcher(availableLocales, requestedLocales) {
return LookupMatcher(availableLocales, requestedLocales);
}
function ResolveLocale(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData) {
if (availableLocales.length === 0) {
throw new ReferenceError('No locale data has been provided for this object yet.');
}
var matcher = options['[[localeMatcher]]'];
var r = void 0;
if (matcher === 'lookup')
r = LookupMatcher(availableLocales, requestedLocales);
else
r = BestFitMatcher(availableLocales, requestedLocales);
var foundLocale = r['[[locale]]'];
var extensionSubtags = void 0,
extensionSubtagsLength = void 0;
if (hop.call(r, '[[extension]]')) {
var extension = r['[[extension]]'];
var split = String.prototype.split;
extensionSubtags = split.call(extension, '-');
extensionSubtagsLength = extensionSubtags.length;
}
var result = new Record();
result['[[dataLocale]]'] = foundLocale;
var supportedExtension = '-u';
var i = 0;
var len = relevantExtensionKeys.length;
while (i < len) {
var key = relevantExtensionKeys[i];
var foundLocaleData = localeData[foundLocale];
var keyLocaleData = foundLocaleData[key];
var value = keyLocaleData['0'];
var supportedExtensionAddition = '';
var indexOf = arrIndexOf;
if (extensionSubtags !== undefined) {
var keyPos = indexOf.call(extensionSubtags, key);
if (keyPos !== -1) {
if (keyPos + 1 < extensionSubtagsLength && extensionSubtags[keyPos + 1].length > 2) {
var requestedValue = extensionSubtags[keyPos + 1];
var valuePos = indexOf.call(keyLocaleData, requestedValue);
if (valuePos !== -1) {
value = requestedValue,
supportedExtensionAddition = '-' + key + '-' + value;
}
}
else {
var _valuePos = indexOf(keyLocaleData, 'true');
if (_valuePos !== -1)
value = 'true';
}
}
}
if (hop.call(options, '[[' + key + ']]')) {
var optionsValue = options['[[' + key + ']]'];
if (indexOf.call(keyLocaleData, optionsValue) !== -1) {
if (optionsValue !== value) {
value = optionsValue;
supportedExtensionAddition = '';
}
}
}
result['[[' + key + ']]'] = value;
supportedExtension += supportedExtensionAddition;
i++;
}
if (supportedExtension.length > 2) {
var privateIndex = foundLocale.indexOf("-x-");
if (privateIndex === -1) {
foundLocale = foundLocale + supportedExtension;
}
else {
var preExtension = foundLocale.substring(0, privateIndex);
var postExtension = foundLocale.substring(privateIndex);
foundLocale = preExtension + supportedExtension + postExtension;
}
foundLocale = CanonicalizeLanguageTag(foundLocale);
}
result['[[locale]]'] = foundLocale;
return result;
}
function LookupSupportedLocales(availableLocales, requestedLocales) {
var len = requestedLocales.length;
var subset = new List();
var k = 0;
while (k < len) {
var locale = requestedLocales[k];
var noExtensionsLocale = String(locale).replace(expUnicodeExSeq, '');
var availableLocale = BestAvailableLocale(availableLocales, noExtensionsLocale);
if (availableLocale !== undefined) arrPush.call(subset, locale);
k++;
}
var subsetArray = arrSlice.call(subset);
return subsetArray;
}
function BestFitSupportedLocales(availableLocales, requestedLocales) {
return LookupSupportedLocales(availableLocales, requestedLocales);
}
function SupportedLocales(availableLocales, requestedLocales, options) {
var matcher = void 0,
subset = void 0;
if (options !== undefined) {
options = new Record(toObject(options));
matcher = options.localeMatcher;
if (matcher !== undefined) {
matcher = String(matcher);
if (matcher !== 'lookup' && matcher !== 'best fit') throw new RangeError('matcher should be "lookup" or "best fit"');
}
}
if (matcher === undefined || matcher === 'best fit')
subset = BestFitSupportedLocales(availableLocales, requestedLocales);
else
subset = LookupSupportedLocales(availableLocales, requestedLocales);
for (var P in subset) {
if (!hop.call(subset, P)) continue;
defineProperty(subset, P, {
writable: false, configurable: false, value: subset[P]
});
}
defineProperty(subset, 'length', { writable: false });
return subset;
}
function GetOption(options, property, type, values, fallback) {
var value = options[property];
if (value !== undefined) {
value = type === 'boolean' ? Boolean(value) : type === 'string' ? String(value) : value;
if (values !== undefined) {
if (arrIndexOf.call(values, value) === -1) throw new RangeError("'" + value + "' is not an allowed value for `" + property + '`');
}
return value;
}
return fallback;
}
function GetNumberOption(options, property, minimum, maximum, fallback) {
var value = options[property];
if (value !== undefined) {
value = Number(value);
if (isNaN(value) || value < minimum || value > maximum) throw new RangeError('Value is not a number or outside accepted range');
return Math.floor(value);
}
return fallback;
}
var Intl = {};
function getCanonicalLocales(locales) {
var ll = CanonicalizeLocaleList(locales);
{
var result = [];
var len = ll.length;
var k = 0;
while (k < len) {
result[k] = ll[k];
k++;
}
return result;
}
}
Object.defineProperty(Intl, 'getCanonicalLocales', {
enumerable: false,
configurable: true,
writable: true,
value: getCanonicalLocales
});
var currencyMinorUnits = {
BHD: 3, BYR: 0, XOF: 0, BIF: 0, XAF: 0, CLF: 4, CLP: 0, KMF: 0, DJF: 0,
XPF: 0, GNF: 0, ISK: 0, IQD: 3, JPY: 0, JOD: 3, KRW: 0, KWD: 3, LYD: 3,
OMR: 3, PYG: 0, RWF: 0, TND: 3, UGX: 0, UYI: 0, VUV: 0, VND: 0
};
function NumberFormatConstructor() {
var locales = arguments[0];
var options = arguments[1];
if (!this || this === Intl) {
return new Intl.NumberFormat(locales, options);
}
return InitializeNumberFormat(toObject(this), locales, options);
}
defineProperty(Intl, 'NumberFormat', {
configurable: true,
writable: true,
value: NumberFormatConstructor
});
defineProperty(Intl.NumberFormat, 'prototype', {
writable: false
});
function InitializeNumberFormat(numberFormat, locales, options) {
var internal = getInternalProperties(numberFormat);
var regexpRestore = createRegExpRestore();
if (internal['[[initializedIntlObject]]'] === true) throw new TypeError('`this` object has already been initialized as an Intl object');
defineProperty(numberFormat, '__getInternalProperties', {
value: function value() {
if (arguments[0] === secret) return internal;
}
});
internal['[[initializedIntlObject]]'] = true;
var requestedLocales = CanonicalizeLocaleList(locales);
if (options === undefined)
options = {};
else
options = toObject(options);
var opt = new Record(),
matcher = GetOption(options, 'localeMatcher', 'string', new List('lookup', 'best fit'), 'best fit');
opt['[[localeMatcher]]'] = matcher;
var localeData = internals.NumberFormat['[[localeData]]'];
var r = ResolveLocale(internals.NumberFormat['[[availableLocales]]'], requestedLocales, opt, internals.NumberFormat['[[relevantExtensionKeys]]'], localeData);
internal['[[locale]]'] = r['[[locale]]'];
internal['[[numberingSystem]]'] = r['[[nu]]'];
internal['[[dataLocale]]'] = r['[[dataLocale]]'];
var dataLocale = r['[[dataLocale]]'];
var s = GetOption(options, 'style', 'string', new List('decimal', 'percent', 'currency'), 'decimal');
internal['[[style]]'] = s;
var c = GetOption(options, 'currency', 'string');
if (c !== undefined && !IsWellFormedCurrencyCode(c)) throw new RangeError("'" + c + "' is not a valid currency code");
if (s === 'currency' && c === undefined) throw new TypeError('Currency code is required when style is currency');
var cDigits = void 0;
if (s === 'currency') {
c = c.toUpperCase();
internal['[[currency]]'] = c;
cDigits = CurrencyDigits(c);
}
var cd = GetOption(options, 'currencyDisplay', 'string', new List('code', 'symbol', 'name'), 'symbol');
if (s === 'currency') internal['[[currencyDisplay]]'] = cd;
var mnid = GetNumberOption(options, 'minimumIntegerDigits', 1, 21, 1);
internal['[[minimumIntegerDigits]]'] = mnid;
var mnfdDefault = s === 'currency' ? cDigits : 0;
var mnfd = GetNumberOption(options, 'minimumFractionDigits', 0, 20, mnfdDefault);
internal['[[minimumFractionDigits]]'] = mnfd;
var mxfdDefault = s === 'currency' ? Math.max(mnfd, cDigits) : s === 'percent' ? Math.max(mnfd, 0) : Math.max(mnfd, 3);
var mxfd = GetNumberOption(options, 'maximumFractionDigits', mnfd, 20, mxfdDefault);
internal['[[maximumFractionDigits]]'] = mxfd;
var mnsd = options.minimumSignificantDigits;
var mxsd = options.maximumSignificantDigits;
if (mnsd !== undefined || mxsd !== undefined) {
mnsd = GetNumberOption(options, 'minimumSignificantDigits', 1, 21, 1);
mxsd = GetNumberOption(options, 'maximumSignificantDigits', mnsd, 21, 21);
internal['[[minimumSignificantDigits]]'] = mnsd;
internal['[[maximumSignificantDigits]]'] = mxsd;
}
var g = GetOption(options, 'useGrouping', 'boolean', undefined, true);
internal['[[useGrouping]]'] = g;
var dataLocaleData = localeData[dataLocale];
var patterns = dataLocaleData.patterns;
var stylePatterns = patterns[s];
internal['[[positivePattern]]'] = stylePatterns.positivePattern;
internal['[[negativePattern]]'] = stylePatterns.negativePattern;
internal['[[boundFormat]]'] = undefined;
internal['[[initializedNumberFormat]]'] = true;
if (es3) numberFormat.format = GetFormatNumber.call(numberFormat);
regexpRestore();
return numberFormat;
}
function CurrencyDigits(currency) {
return currencyMinorUnits[currency] !== undefined ? currencyMinorUnits[currency] : 2;
}
internals.NumberFormat = {
'[[availableLocales]]': [],
'[[relevantExtensionKeys]]': ['nu'],
'[[localeData]]': {}
};
defineProperty(Intl.NumberFormat, 'supportedLocalesOf', {
configurable: true,
writable: true,
value: fnBind.call(function (locales) {
if (!hop.call(this, '[[availableLocales]]')) throw new TypeError('supportedLocalesOf() is not a constructor');
var regexpRestore = createRegExpRestore(),
options = arguments[1],
availableLocales = this['[[availableLocales]]'],
requestedLocales = CanonicalizeLocaleList(locales);
regexpRestore();
return SupportedLocales(availableLocales, requestedLocales, options);
}, internals.NumberFormat)
});
defineProperty(Intl.NumberFormat.prototype, 'format', {
configurable: true,
get: GetFormatNumber
});
function GetFormatNumber() {
var internal = this !== null && babelHelpers$1["typeof"](this) === 'object' && getInternalProperties(this);
if (!internal || !internal['[[initializedNumberFormat]]']) throw new TypeError('`this` value for format() is not an initialized Intl.NumberFormat object.');
if (internal['[[boundFormat]]'] === undefined) {
var F = function F(value) {
return FormatNumber(this, Number(value));
};
var bf = fnBind.call(F, this);
internal['[[boundFormat]]'] = bf;
}
return internal['[[boundFormat]]'];
}
function formatToParts() {
var value = arguments.length <= 0 || arguments[0] === undefined ? undefined : arguments[0];
var internal = this !== null && babelHelpers$1["typeof"](this) === 'object' && getInternalProperties(this);
if (!internal || !internal['[[initializedNumberFormat]]']) throw new TypeError('`this` value for formatToParts() is not an initialized Intl.NumberFormat object.');
var x = Number(value);
return FormatNumberToParts(this, x);
}
Object.defineProperty(Intl.NumberFormat.prototype, 'formatToParts', {
configurable: true,
enumerable: false,
writable: true,
value: formatToParts
});
function FormatNumberToParts(numberFormat, x) {
var parts = PartitionNumberPattern(numberFormat, x);
var result = [];
var n = 0;
for (var i = 0; parts.length > i; i++) {
var part = parts[i];
var O = {};
O.type = part['[[type]]'];
O.value = part['[[value]]'];
result[n] = O;
n += 1;
}
return result;
}
function PartitionNumberPattern(numberFormat, x) {
var internal = getInternalProperties(numberFormat),
locale = internal['[[dataLocale]]'],
nums = internal['[[numberingSystem]]'],
data = internals.NumberFormat['[[localeData]]'][locale],
ild = data.symbols[nums] || data.symbols.latn,
pattern = void 0;
if (!isNaN(x) && x < 0) {
x = -x;
pattern = internal['[[negativePattern]]'];
}
else {
pattern = internal['[[positivePattern]]'];
}
var result = new List();
var beginIndex = pattern.indexOf('{', 0);
var endIndex = 0;
var nextIndex = 0;
var length = pattern.length;
while (beginIndex > -1 && beginIndex < length) {
endIndex = pattern.indexOf('}', beginIndex);
if (endIndex === -1) throw new Error();
if (beginIndex > nextIndex) {
var literal = pattern.substring(nextIndex, beginIndex);
arrPush.call(result, { '[[type]]': 'literal', '[[value]]': literal });
}
var p = pattern.substring(beginIndex + 1, endIndex);
if (p === "number") {
if (isNaN(x)) {
var n = ild.nan;
arrPush.call(result, { '[[type]]': 'nan', '[[value]]': n });
}
else if (!isFinite(x)) {
var _n = ild.infinity;
arrPush.call(result, { '[[type]]': 'infinity', '[[value]]': _n });
}
else {
if (internal['[[style]]'] === 'percent' && isFinite(x)) x *= 100;
var _n2 = void 0;
if (hop.call(internal, '[[minimumSignificantDigits]]') && hop.call(internal, '[[maximumSignificantDigits]]')) {
_n2 = ToRawPrecision(x, internal['[[minimumSignificantDigits]]'], internal['[[maximumSignificantDigits]]']);
}
else {
_n2 = ToRawFixed(x, internal['[[minimumIntegerDigits]]'], internal['[[minimumFractionDigits]]'], internal['[[maximumFractionDigits]]']);
}
if (numSys[nums]) {
(function () {
var digits = numSys[nums];
_n2 = String(_n2).replace(/\d/g, function (digit) {
return digits[digit];
});
})();
}
else _n2 = String(_n2);
var integer = void 0;
var fraction = void 0;
var decimalSepIndex = _n2.indexOf('.', 0);
if (decimalSepIndex > 0) {
integer = _n2.substring(0, decimalSepIndex);
fraction = _n2.substring(decimalSepIndex + 1, decimalSepIndex.length);
}
else {
integer = _n2;
fraction = undefined;
}
if (internal['[[useGrouping]]'] === true) {
var groupSepSymbol = ild.group;
var groups = [];
var pgSize = data.patterns.primaryGroupSize || 3;
var sgSize = data.patterns.secondaryGroupSize || pgSize;
if (integer.length > pgSize) {
var end = integer.length - pgSize;
var idx = end % sgSize;
var start = integer.slice(0, idx);
if (start.length) arrPush.call(groups, start);
while (idx < end) {
arrPush.call(groups, integer.slice(idx, idx + sgSize));
idx += sgSize;
}
arrPush.call(groups, integer.slice(end));
} else {
arrPush.call(groups, integer);
}
if (groups.length === 0) throw new Error();
while (groups.length) {
var integerGroup = arrShift.call(groups);
arrPush.call(result, { '[[type]]': 'integer', '[[value]]': integerGroup });
if (groups.length) {
arrPush.call(result, { '[[type]]': 'group', '[[value]]': groupSepSymbol });
}
}
}
else {
arrPush.call(result, { '[[type]]': 'integer', '[[value]]': integer });
}
if (fraction !== undefined) {
var decimalSepSymbol = ild.decimal;
arrPush.call(result, { '[[type]]': 'decimal', '[[value]]': decimalSepSymbol });
arrPush.call(result, { '[[type]]': 'fraction', '[[value]]': fraction });
}
}
}
else if (p === "plusSign") {
var plusSignSymbol = ild.plusSign;
arrPush.call(result, { '[[type]]': 'plusSign', '[[value]]': plusSignSymbol });
}
else if (p === "minusSign") {
var minusSignSymbol = ild.minusSign;
arrPush.call(result, { '[[type]]': 'minusSign', '[[value]]': minusSignSymbol });
}
else if (p === "percentSign" && internal['[[style]]'] === "percent") {
var percentSignSymbol = ild.percentSign;
arrPush.call(result, { '[[type]]': 'literal', '[[value]]': percentSignSymbol });
}
else if (p === "currency" && internal['[[style]]'] === "currency") {
var currency = internal['[[currency]]'];
var cd = void 0;
if (internal['[[currencyDisplay]]'] === "code") {
cd = currency;
}
else if (internal['[[currencyDisplay]]'] === "symbol") {
cd = data.currencies[currency] || currency;
}
else if (internal['[[currencyDisplay]]'] === "name") {
cd = currency;
}
arrPush.call(result, { '[[type]]': 'currency', '[[value]]': cd });
}
else {
var _literal = pattern.substring(beginIndex, endIndex);
arrPush.call(result, { '[[type]]': 'literal', '[[value]]': _literal });
}
nextIndex = endIndex + 1;
beginIndex = pattern.indexOf('{', nextIndex);
}
if (nextIndex < length) {
var _literal2 = pattern.substring(nextIndex, length);
arrPush.call(result, { '[[type]]': 'literal', '[[value]]': _liter