2234 lines
67 KiB
JavaScript
2234 lines
67 KiB
JavaScript
// Metro module 16089 (f16090).
|
||
import { expBCP47Syntax, expVariantDupes, expSingletonDupes, expExtSequences } from "./Module16090";
|
||
import { createDateTimeFormats } from "./Module16091";
|
||
let locale, c11517_3, c11517_4, hasOwnProperty, defineProperty, c11517_7, c11517_8, slice, concat, push, join, shift, c11517_14, c11517_15, c11517_16, c11517_17, c11517_18, c11517_19, c11517_20, c11517_21, c11517_22, c11517_23, LookupMatcher, ResolveLocale, LookupSupportedLocales, NumberFormatConstructor, InitializeNumberFormat, GetFormatNumber, FormatNumber, c11517_32, DateTimeFormatConstructor, InitializeDateTimeFormat, c11517_35, ToDateTimeOptions, calculateScore, GetFormatDateTime, FormatDateTime, c11517_40, resolveDateString, Record, List, createRegExpRestore;
|
||
const CanonicalizeLocaleList = function CanonicalizeLocaleList(a0) {
|
||
let r7, r151, r152, r153;
|
||
if (a0 === void 0) {
|
||
const r195 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r195);
|
||
return r195;
|
||
}
|
||
const r44 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r44);
|
||
const r22 = typeof a0 === "string" ? [a0] : a0;
|
||
if (r22 == null) {
|
||
throw new TypeError("Cannot convert null or undefined to object");
|
||
}
|
||
const r28 = Object(r22);
|
||
const length = r28.length;
|
||
const r13 = 0 < length;
|
||
let r6 = 0;
|
||
if (r13) {
|
||
do {
|
||
L68: {
|
||
const r51 = String(r6);
|
||
const r52 = r51 in r28;
|
||
r7 = r6;
|
||
if (r52) {
|
||
L70: {
|
||
const r30 = r28[r51];
|
||
if (r30 != null) {
|
||
if (typeof r30 !== "string" && typeof r30 !== "object") {
|
||
break L70;
|
||
}
|
||
const r54 = String(r30);
|
||
let r60 = !!expBCP47Syntax.test(r54);
|
||
if (r60) {
|
||
const r65 = expVariantDupes.test(r54);
|
||
r60 = r65 ? !r65 : !expSingletonDupes.test(r54);
|
||
}
|
||
if (r60) {
|
||
const r81 = r54.toLowerCase().split("-");
|
||
const length2 = r81.length;
|
||
const r83 = 1 < length2;
|
||
let r1 = 1;
|
||
if (r83) {
|
||
do {
|
||
const length3 = r81[r1].length;
|
||
const r0 = r1;
|
||
if (length3 === 2) {
|
||
r81[r0] = r81[r0].toUpperCase();
|
||
} else if (r81[r0].length === 4) {
|
||
r81[r0] = r81[r0].charAt(0).toUpperCase() + r81[r0].slice(1);
|
||
} else if (r81[r0].length === 1 && r81[r0] !== "x") {
|
||
break;
|
||
}
|
||
r1 = r0 + 1;
|
||
} while (r1 < length2);
|
||
}
|
||
const call2 = join.call;
|
||
const r104 = join.call(r81, "-");
|
||
const r34 = r104.match(expExtSequences);
|
||
const r111 = r34 && r34.length > 1;
|
||
let r113 = r104;
|
||
if (r111) {
|
||
r34.sort();
|
||
const r124 = RegExp("(?:" + expExtSequences.source + ")+", "i");
|
||
const call3 = join.call;
|
||
r113 = r104.replace(r124, join.call(r34, ""));
|
||
}
|
||
const call4 = hasOwnProperty.call;
|
||
const r135 = (hasOwnProperty.call(c11517_22.tags, r113) ? c11517_22.tags[r113] : r113).split("-");
|
||
let length4 = r135.length;
|
||
const r137 = 1 < length4;
|
||
let r138 = 1;
|
||
let r139 = r135;
|
||
let r140 = r139;
|
||
if (r137) {
|
||
do {
|
||
const call5 = hasOwnProperty.call;
|
||
const subtags = c11517_22.subtags;
|
||
const r143 = r139[r138];
|
||
const r2 = r138;
|
||
const r145 = r139;
|
||
if (hasOwnProperty.call(subtags, r143)) {
|
||
r145[r2] = c11517_22.subtags[r145[r2]];
|
||
r151 = length4;
|
||
r152 = r2;
|
||
r153 = r145;
|
||
} else {
|
||
const call6 = hasOwnProperty.call;
|
||
const r150 = hasOwnProperty.call(c11517_22.extLang, r145[r2]);
|
||
r151 = length4;
|
||
r152 = r2;
|
||
r153 = r145;
|
||
if (r150) {
|
||
r145[r2] = c11517_22.extLang[r145[r2]][0];
|
||
const r158 = r2 === 1 ? c11517_22.extLang[r145[1]][1] === r145[0] : r2 === 1;
|
||
let r164 = length4;
|
||
let r4 = r2;
|
||
let r165 = r145;
|
||
if (r158) {
|
||
const call = slice.call;
|
||
const r166 = slice.call(r145, r2);
|
||
r4 = r2 + 1;
|
||
r164 = length4 - 1;
|
||
r165 = r166;
|
||
}
|
||
r151 = r164;
|
||
r152 = r4;
|
||
r153 = r165;
|
||
}
|
||
}
|
||
r138 = r152 + 1;
|
||
length4 = r151;
|
||
r139 = r153;
|
||
r140 = r139;
|
||
} while (r138 < length4);
|
||
}
|
||
const call7 = join.call;
|
||
const r172 = join.call(r140, "-");
|
||
const call8 = c11517_7.call;
|
||
if (c11517_7.call(r44, r172) !== -1) {
|
||
break L68;
|
||
}
|
||
const call9 = push.call;
|
||
if (call9 === Function.prototype.call) {
|
||
push.call(r44, r172);
|
||
break L68;
|
||
}
|
||
call9.call(push, r44, r172);
|
||
break L68;
|
||
}
|
||
throw new RangeError("'" + r54 + "' is not a structurally valid language tag");
|
||
}
|
||
}
|
||
throw new TypeError("String or Object type expected");
|
||
}
|
||
}
|
||
r6 = r7 + 1;
|
||
} while (r6 < length);
|
||
}
|
||
return r44;
|
||
};
|
||
LookupMatcher = function LookupMatcher(a0, a1) {
|
||
let r13, r14, r15;
|
||
L14: {
|
||
const length = a1.length;
|
||
const r7 = 0 < length;
|
||
let r3 = 0;
|
||
r13 = void 0;
|
||
r15 = void 0;
|
||
r14 = void 0;
|
||
if (r7) {
|
||
loop1: while (true) {
|
||
const r21 = a1[r3];
|
||
const r28 = String(r21).replace(c11517_21, "");
|
||
const r4 = r3;
|
||
let r29 = r28;
|
||
while (true) {
|
||
const call = c11517_7.call;
|
||
const r26 = r29;
|
||
const r31 = c11517_7.call(a0, r26);
|
||
let r32 = r26;
|
||
if (!(r31 > -1)) {
|
||
const r34 = r26.lastIndexOf("-");
|
||
const r35 = r34 < 0;
|
||
r32 = void 0;
|
||
if (!r35) {
|
||
r29 = r26.substring(0, r34 >= 2 && r26.charAt(r34 - 2) === "-" ? r34 - 2 : r34);
|
||
continue;
|
||
}
|
||
}
|
||
const r40 = r4 + 1;
|
||
r13 = r32;
|
||
r15 = r28;
|
||
r14 = r21;
|
||
if (!(r40 < length)) {
|
||
break L14;
|
||
}
|
||
r3 = r40;
|
||
r15 = r28;
|
||
r14 = r21;
|
||
r13 = r32;
|
||
if (!r13) {
|
||
continue loop1;
|
||
}
|
||
break L14;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const r43 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in void 0) {
|
||
let r51 = void 0 instanceof Record;
|
||
if (!r51) {
|
||
const call2 = hasOwnProperty.call;
|
||
r51 = call2 === Function.prototype.call ? hasOwnProperty(key) : call2.call(hasOwnProperty, void 0, key);
|
||
}
|
||
if (r51) {
|
||
defineProperty(r43, key, {
|
||
value: (void 0)[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
if (r13 !== void 0) {
|
||
r43["[[locale]]"] = r13;
|
||
if (String(r14) !== String(r15)) {
|
||
const r67 = r14.match(c11517_21)[0];
|
||
const r70 = r14.indexOf("-u-");
|
||
r43["[[extension]]"] = r67;
|
||
r43["[[extensionIndex]]"] = r70;
|
||
}
|
||
} else {
|
||
r43["[[locale]]"] = locale;
|
||
}
|
||
return r43;
|
||
};
|
||
ResolveLocale = function ResolveLocale(a0, a1, a2, a3, a4) {
|
||
let r2, r27, r28, r31, r32, r35;
|
||
if (a0.length === 0) {
|
||
throw new ReferenceError("No locale data has been provided for this object yet.");
|
||
}
|
||
const r42 = a2["[[localeMatcher]]"] === "lookup" ? LookupMatcher(a0, a1) : LookupMatcher(a0, a1);
|
||
const r14 = r42["[[locale]]"];
|
||
const call3 = hasOwnProperty.call;
|
||
const r47 = hasOwnProperty.call(r42, "[[extension]]");
|
||
let r22 = void 0;
|
||
let r21 = void 0;
|
||
let r13 = void 0;
|
||
if (r47) {
|
||
const r15 = r42["[[extension]]"];
|
||
const r49 = r42["[[extensionIndex]]"];
|
||
const r56 = String.prototype.split.call(r15, "-");
|
||
r22 = r56.length;
|
||
r21 = r56;
|
||
r13 = r49;
|
||
}
|
||
const r60 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in void 0) {
|
||
let r65 = void 0 instanceof Record;
|
||
if (!r65) {
|
||
const call = hasOwnProperty.call;
|
||
r65 = call === Function.prototype.call ? hasOwnProperty(key) : call.call(hasOwnProperty, void 0, key);
|
||
}
|
||
if (r65) {
|
||
defineProperty(r60, key, {
|
||
value: (void 0)[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
r60["[[dataLocale]]"] = r14;
|
||
const length = a3.length;
|
||
const r6 = 0 < length;
|
||
let r71 = "-u";
|
||
let r78 = 0;
|
||
let r79 = "-u";
|
||
if (r6) {
|
||
do {
|
||
L36: {
|
||
r28 = a3[r78];
|
||
r35 = a4[r14][r28];
|
||
const r30 = r35[0];
|
||
r2 = r78;
|
||
r27 = r71;
|
||
r32 = "";
|
||
r31 = r30;
|
||
if (r21 !== void 0) {
|
||
const call4 = c11517_7.call;
|
||
const r81 = c11517_7.call(r21, r28);
|
||
r32 = "";
|
||
r31 = r30;
|
||
if (r81 !== -1) {
|
||
if (r81 + 1 < r22 && r21[r81 + 1].length > 2) {
|
||
const r87 = r21[r81 + 1];
|
||
const call5 = c11517_7.call;
|
||
const r89 = c11517_7.call(r35, r87);
|
||
r32 = "";
|
||
r31 = r30;
|
||
if (r89 === -1) {
|
||
break L36;
|
||
}
|
||
r32 = "-" + r28 + "-" + r87;
|
||
r31 = r87;
|
||
break L36;
|
||
}
|
||
const r85 = c11517_7(r35, "true");
|
||
r32 = "";
|
||
r31 = r30;
|
||
if (r85 !== -1) {
|
||
r32 = "";
|
||
r31 = "true";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const call6 = hasOwnProperty.call;
|
||
const r96 = hasOwnProperty.call(a2, "[[" + r28 + "]]");
|
||
let r97 = r32;
|
||
let r98 = r31;
|
||
if (r96) {
|
||
const r101 = a2["[[" + r28 + "]]"];
|
||
const call2 = c11517_7.call;
|
||
const r103 = c11517_7.call(r35, r101) !== -1 && r101 !== r31;
|
||
r97 = r32;
|
||
r98 = r31;
|
||
if (r103) {
|
||
r97 = "";
|
||
r98 = r101;
|
||
}
|
||
}
|
||
r60["[[" + r28 + "]]"] = r98;
|
||
r71 = r27 + r97;
|
||
r78 = r2 + 1;
|
||
r79 = r71;
|
||
} while (r78 < length);
|
||
}
|
||
r60["[[locale]]"] = r79.length > 2 ? r14.substring(0, r13) + r79 + r14.substring(r13) : r14;
|
||
return r60;
|
||
};
|
||
LookupSupportedLocales = function LookupSupportedLocales(a0, a1) {
|
||
let r24;
|
||
L17: {
|
||
const length = a1.length;
|
||
r24 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r24);
|
||
const r7 = 0 < length;
|
||
let r3 = 0;
|
||
if (r7) {
|
||
loop1: while (true) {
|
||
const r19 = a1[r3];
|
||
let r28 = String(r19).replace(c11517_21, "");
|
||
const r4 = r3;
|
||
while (true) {
|
||
const call = c11517_7.call;
|
||
const r23 = r28;
|
||
const r31 = c11517_7.call(a0, r23);
|
||
let r32 = r23;
|
||
if (!(r31 > -1)) {
|
||
const r34 = r23.lastIndexOf("-");
|
||
const r35 = r34 < 0;
|
||
r32 = void 0;
|
||
if (!r35) {
|
||
r28 = r23.substring(0, r34 >= 2 && r23.charAt(r34 - 2) === "-" ? r34 - 2 : r34);
|
||
continue;
|
||
}
|
||
}
|
||
if (r32 !== void 0) {
|
||
const call2 = push.call;
|
||
push.call(r24, r19);
|
||
}
|
||
r3 = r4 + 1;
|
||
if (r3 < length) {
|
||
continue loop1;
|
||
}
|
||
break L17;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const call3 = slice.call;
|
||
return slice.call(r24);
|
||
};
|
||
NumberFormatConstructor = function NumberFormatConstructor(r8, r7) {
|
||
let r18;
|
||
if (this && this !== c11517_3) {
|
||
if (this == null) {
|
||
throw new TypeError("Cannot convert null or undefined to object");
|
||
}
|
||
const r22 = Object(this);
|
||
InitializeNumberFormat(r22, r8, r7);
|
||
r18 = r22;
|
||
} else {
|
||
r18 = new c11517_3.NumberFormat(r8, r7);
|
||
}
|
||
return r18;
|
||
};
|
||
InitializeNumberFormat = function InitializeNumberFormat(prototype, a1, a2) {
|
||
let r23, r135, r172, r215, r226;
|
||
const call = hasOwnProperty.call;
|
||
const r19 = hasOwnProperty.call(prototype, "__getInternalProperties") ? prototype.__getInternalProperties(c11517_16) : c11517_8(null);
|
||
let c22774_0 = r19;
|
||
const regExpRestore = createRegExpRestore();
|
||
if (r19["[[initializedIntlObject]]"] === true) {
|
||
throw new TypeError("`this` object has already been initialized as an Intl object");
|
||
}
|
||
defineProperty(prototype, "__getInternalProperties", {
|
||
value: function value() {
|
||
if (arguments[0] === c11517_16) {
|
||
return c22774_0;
|
||
}
|
||
}
|
||
});
|
||
r19["[[initializedIntlObject]]"] = true;
|
||
const r13 = CanonicalizeLocaleList(a1);
|
||
if (a2 === void 0) {
|
||
r23 = {};
|
||
} else {
|
||
if (a2 == null) {
|
||
throw new TypeError("Cannot convert null or undefined to object");
|
||
}
|
||
r23 = Object(a2);
|
||
}
|
||
const r12 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in void 0) {
|
||
let r70 = void 0 instanceof Record;
|
||
if (!r70) {
|
||
const call2 = hasOwnProperty.call;
|
||
r70 = call2 === Function.prototype.call ? hasOwnProperty(key) : call2.call(hasOwnProperty, void 0, key);
|
||
}
|
||
if (r70) {
|
||
defineProperty(r12, key, {
|
||
value: (void 0)[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
const r79 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r79, "lookup", "best fit");
|
||
const localeMatcher = r23.localeMatcher;
|
||
let r84 = "best fit";
|
||
if (localeMatcher !== void 0) {
|
||
const r87 = String(localeMatcher);
|
||
const call3 = c11517_7.call;
|
||
const r90 = c11517_7.call(r79, r87);
|
||
r84 = r87;
|
||
if (r90 === -1) {
|
||
throw new RangeError("'" + r87 + "' is not an allowed value for `localeMatcher`");
|
||
}
|
||
}
|
||
r12["[[localeMatcher]]"] = r84;
|
||
const r22 = c11517_15.NumberFormat["[[localeData]]"];
|
||
const r99 = ResolveLocale(c11517_15.NumberFormat["[[availableLocales]]"], r13, r12, c11517_15.NumberFormat["[[relevantExtensionKeys]]"], r22);
|
||
r19["[[locale]]"] = r99["[[locale]]"];
|
||
r19["[[numberingSystem]]"] = r99["[[nu]]"];
|
||
r19["[[dataLocale]]"] = r99["[[dataLocale]]"];
|
||
const r20 = r99["[[dataLocale]]"];
|
||
const r24 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r24, "decimal", "percent", "currency");
|
||
const style = r23.style;
|
||
let r21 = "decimal";
|
||
if (style !== void 0) {
|
||
const r111 = String(style);
|
||
const call4 = c11517_7.call;
|
||
const r114 = c11517_7.call(r24, r111);
|
||
r21 = r111;
|
||
if (r114 === -1) {
|
||
throw new RangeError("'" + r111 + "' is not an allowed value for `style`");
|
||
}
|
||
}
|
||
r19["[[style]]"] = r21;
|
||
const currency = r23.currency;
|
||
const r117 = currency !== void 0 ? String(currency) : void 0;
|
||
if (r117 !== void 0) {
|
||
const r26 = String(r117);
|
||
const r123 = +r26.length;
|
||
let r29 = r123 - 1;
|
||
let r25 = r26;
|
||
let r125 = r25;
|
||
if (r123) {
|
||
do {
|
||
const r34 = r25.charAt(r29);
|
||
let r127 = r34 >= "a";
|
||
const r128 = r29;
|
||
const r33 = r25;
|
||
if (r127) {
|
||
r127 = r34 <= "z";
|
||
}
|
||
const r30 = r127 ? r33.slice(0, r128) + r34.toUpperCase() + r33.slice(r128 + 1) : r33;
|
||
r135 = +r128;
|
||
r29 = r135 - 1;
|
||
r25 = r30;
|
||
r125 = r25;
|
||
} while (r135);
|
||
}
|
||
if (c11517_20.test(r125) === false) {
|
||
throw new RangeError("'" + r117 + "' is not a valid currency code");
|
||
}
|
||
}
|
||
const r149 = r21 === "currency";
|
||
if (r149 && r117 === void 0) {
|
||
throw new TypeError("Currency code is required when style is currency");
|
||
}
|
||
let r150 = void 0;
|
||
if (r149) {
|
||
const r152 = r117.toUpperCase();
|
||
r19["[[currency]]"] = r152;
|
||
r150 = c11517_23[r152] !== void 0 ? c11517_23[r152] : 2;
|
||
}
|
||
const r157 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r157, "code", "symbol", "name");
|
||
const currencyDisplay = r23.currencyDisplay;
|
||
let r162 = "symbol";
|
||
if (currencyDisplay !== void 0) {
|
||
const r165 = String(currencyDisplay);
|
||
const call5 = c11517_7.call;
|
||
const r168 = c11517_7.call(r157, r165);
|
||
r162 = r165;
|
||
if (r168 === -1) {
|
||
throw new RangeError("'" + r165 + "' is not an allowed value for `currencyDisplay`");
|
||
}
|
||
}
|
||
if (r149) {
|
||
r19["[[currencyDisplay]]"] = r162;
|
||
}
|
||
L60: {
|
||
const minimumIntegerDigits = r23.minimumIntegerDigits;
|
||
r172 = 1;
|
||
if (minimumIntegerDigits !== void 0) {
|
||
const r175 = Number(minimumIntegerDigits);
|
||
if (!isNaN(r175) && !(r175 < 1) && !(r175 > 21)) {
|
||
r172 = Math.floor(r175);
|
||
break L60;
|
||
}
|
||
throw new RangeError("Value is not a number or outside accepted range");
|
||
}
|
||
}
|
||
r19["[[minimumIntegerDigits]]"] = r172;
|
||
let r181 = r149 ? r150 : 0;
|
||
L67: {
|
||
const minimumFractionDigits = r23.minimumFractionDigits;
|
||
if (minimumFractionDigits !== void 0) {
|
||
const r185 = Number(minimumFractionDigits);
|
||
if (!isNaN(r185) && !(r185 < 0) && !(r185 > 20)) {
|
||
r181 = Math.floor(r185);
|
||
break L67;
|
||
}
|
||
throw new RangeError("Value is not a number or outside accepted range");
|
||
}
|
||
}
|
||
r19["[[minimumFractionDigits]]"] = r181;
|
||
let r195 = r149 ? Math.max(r181, r150) : r21 === "percent" ? Math.max(r181, 0) : Math.max(r181, 3);
|
||
L78: {
|
||
const maximumFractionDigits = r23.maximumFractionDigits;
|
||
if (maximumFractionDigits !== void 0) {
|
||
const r205 = Number(maximumFractionDigits);
|
||
if (!isNaN(r205) && !(r205 < r181) && !(r205 > 20)) {
|
||
r195 = Math.floor(r205);
|
||
break L78;
|
||
}
|
||
throw new RangeError("Value is not a number or outside accepted range");
|
||
}
|
||
}
|
||
r19["[[maximumFractionDigits]]"] = r195;
|
||
const { minimumSignificantDigits, maximumSignificantDigits } = r23;
|
||
if (!(minimumSignificantDigits === void 0 && maximumSignificantDigits === void 0)) {
|
||
L86: {
|
||
const minimumSignificantDigits2 = r23.minimumSignificantDigits;
|
||
r215 = 1;
|
||
if (minimumSignificantDigits2 !== void 0) {
|
||
const r218 = Number(minimumSignificantDigits2);
|
||
if (!isNaN(r218) && !(r218 < 1) && !(r218 > 21)) {
|
||
r215 = Math.floor(r218);
|
||
break L86;
|
||
}
|
||
throw new RangeError("Value is not a number or outside accepted range");
|
||
}
|
||
}
|
||
L91: {
|
||
const maximumSignificantDigits2 = r23.maximumSignificantDigits;
|
||
r226 = 21;
|
||
if (maximumSignificantDigits2 !== void 0) {
|
||
const r229 = Number(maximumSignificantDigits2);
|
||
if (!isNaN(r229) && !(r229 < r215) && !(r229 > 21)) {
|
||
r226 = Math.floor(r229);
|
||
break L91;
|
||
}
|
||
throw new RangeError("Value is not a number or outside accepted range");
|
||
}
|
||
}
|
||
r19["[[minimumSignificantDigits]]"] = r215;
|
||
r19["[[maximumSignificantDigits]]"] = r226;
|
||
}
|
||
const useGrouping = r23.useGrouping;
|
||
r19["[[useGrouping]]"] = useGrouping !== void 0 ? Boolean(useGrouping) : true;
|
||
const r252 = r22[r20].patterns[r21];
|
||
r19["[[positivePattern]]"] = r252.positivePattern;
|
||
r19["[[negativePattern]]"] = r252.negativePattern;
|
||
r19["[[boundFormat]]"] = void 0;
|
||
r19["[[initializedNumberFormat]]"] = true;
|
||
if (c11517_4) {
|
||
const call6 = GetFormatNumber.call;
|
||
prototype.format = GetFormatNumber.call(prototype);
|
||
}
|
||
regExpRestore.exp.test(regExpRestore.input);
|
||
return prototype;
|
||
};
|
||
GetFormatNumber = function GetFormatNumber() {
|
||
let r2 = this != null && typeof this === "object";
|
||
if (r2) {
|
||
const call = hasOwnProperty.call;
|
||
r2 = hasOwnProperty.call(this, "__getInternalProperties") ? this.__getInternalProperties(c11517_16) : c11517_8(null);
|
||
}
|
||
if (r2 && r2["[[initializedNumberFormat]]"]) {
|
||
if (r2["[[boundFormat]]"] === void 0) {
|
||
const call2 = c11517_14.call;
|
||
r2["[[boundFormat]]"] = c11517_14.call(function(a0) {
|
||
return FormatNumber(this, Number(a0));
|
||
}, this);
|
||
}
|
||
return r2["[[boundFormat]]"];
|
||
}
|
||
throw new TypeError("`this` value for format() is not an initialized Intl.NumberFormat object.");
|
||
};
|
||
FormatNumber = function FormatNumber(a0, a1) {
|
||
let r110, r128, r150, r178, r190, r191, r229, r250, r264, nan;
|
||
const regExpRestore = createRegExpRestore();
|
||
const call = hasOwnProperty.call;
|
||
const r13 = hasOwnProperty.call(a0, "__getInternalProperties") ? a0.__getInternalProperties(c11517_16) : c11517_8(null);
|
||
const r38 = r13["[[dataLocale]]"];
|
||
const r15 = r13["[[numberingSystem]]"];
|
||
const r42 = c11517_15.NumberFormat["[[localeData]]"][r38];
|
||
const r44 = r42.symbols[r15] || r42.symbols.latn;
|
||
if (isFinite(a1) === false) {
|
||
if (isNaN(a1)) {
|
||
nan = r44.nan;
|
||
r264 = false;
|
||
} else {
|
||
const infinity = r44.infinity;
|
||
const r314 = a1 < 0;
|
||
r264 = false;
|
||
nan = infinity;
|
||
if (r314) {
|
||
r264 = true;
|
||
nan = infinity;
|
||
}
|
||
}
|
||
} else {
|
||
const r49 = a1 < 0;
|
||
let r6 = false;
|
||
let r50 = a1;
|
||
if (r49) {
|
||
r50 = -a1;
|
||
r6 = true;
|
||
}
|
||
const r26 = r13["[[style]]"] === "percent" ? r50 * 100 : r50;
|
||
const call2 = hasOwnProperty.call;
|
||
const r53 = hasOwnProperty.call(r13, "[[minimumSignificantDigits]]");
|
||
L83: {
|
||
if (r53) {
|
||
const call3 = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(r13, "[[maximumSignificantDigits]]")) {
|
||
const r129 = r13["[[minimumSignificantDigits]]"];
|
||
const r130 = r13["[[maximumSignificantDigits]]"];
|
||
if (r26 === 0) {
|
||
const call7 = join.call;
|
||
r178 = join.call(Array(r130 + 1), "0");
|
||
r150 = 0;
|
||
} else {
|
||
const r133 = Math.abs(r26);
|
||
if (typeof Math.log10 === "function") {
|
||
r150 = Math.floor(Math.log10(r133));
|
||
} else {
|
||
const r144 = Math.round(Math.log(r133) * Math.LOG10E);
|
||
r150 = r144 - (Number("1e" + r144) > r133);
|
||
}
|
||
const r170 = Math.round(Math.exp(Math.abs(r150 - r130 + 1) * Math.LN10));
|
||
r178 = String(Math.round(r150 - r130 + 1 < 0 ? r26 * r170 : r26 / r170));
|
||
}
|
||
if (r150 >= r130) {
|
||
const call9 = join.call;
|
||
r190 = r178 + join.call(Array(r150 - r130 + 1 + 1), "0");
|
||
} else {
|
||
const r189 = r130 - 1;
|
||
r190 = r178;
|
||
if (r150 !== r189) {
|
||
if (r150 >= 0) {
|
||
r191 = r178.slice(0, r150 + 1) + "." + r178.slice(r150 + 1);
|
||
} else {
|
||
r191 = r178;
|
||
if (r150 < 0) {
|
||
const call8 = join.call;
|
||
r191 = "0." + join.call(Array(1 - (r150 + 1)), "0") + r178;
|
||
}
|
||
}
|
||
const r213 = r191.indexOf(".");
|
||
const r214 = r191;
|
||
let r215 = r214;
|
||
if (r213 >= 0) {
|
||
r215 = r214;
|
||
if (r130 > r129) {
|
||
let r216 = r130 - r129;
|
||
let r217 = r214;
|
||
if (r216 > 0) {
|
||
const r221 = r214.charAt(r214.length - 1);
|
||
let r224 = r214;
|
||
r217 = r224;
|
||
if (r221 === "0") {
|
||
do {
|
||
const r226 = r224.slice(0, -1);
|
||
const r30 = r216 - 1;
|
||
r217 = r226;
|
||
if (!(r30 > 0)) {
|
||
break;
|
||
}
|
||
r229 = r226.charAt(r226.length - 1);
|
||
r216 = r30;
|
||
r224 = r226;
|
||
r217 = r224;
|
||
} while (r229 === "0");
|
||
}
|
||
}
|
||
r215 = r217.charAt(r217.length - 1) === "." ? r217.slice(0, -1) : r217;
|
||
}
|
||
}
|
||
r190 = r215;
|
||
}
|
||
}
|
||
r128 = r190;
|
||
break L83;
|
||
}
|
||
}
|
||
const r23 = r13["[[minimumIntegerDigits]]"];
|
||
const r59 = r13["[[minimumFractionDigits]]"];
|
||
const r60 = r13["[[maximumFractionDigits]]"];
|
||
const r65 = Number.prototype.toFixed.call(r26, r60);
|
||
let length = r65.split(".")[0].length;
|
||
let r24 = r60 - r59;
|
||
const r71 = r65.indexOf("e");
|
||
const r73 = r71 > -1;
|
||
const r27 = r73 ? r65.slice(r71 + 1) : 0;
|
||
let r76 = r65;
|
||
if (r27) {
|
||
const r81 = r65.slice(0, r71).replace(".", "");
|
||
const call4 = join.call;
|
||
const r91 = join.call(Array(r27 - (r81.length - 1) + 1), "0") + ".";
|
||
const call5 = join.call;
|
||
const r100 = r81 + (r91 + join.call(Array(r60 + 1), "0"));
|
||
length = r100.length;
|
||
r76 = r100;
|
||
}
|
||
let r101 = r76;
|
||
if (r24 > 0) {
|
||
const r103 = r76.slice(-1);
|
||
let r105 = r76;
|
||
r101 = r105;
|
||
if (r103 === "0") {
|
||
do {
|
||
const r107 = r105.slice(0, -1);
|
||
const r108 = r24 - 1;
|
||
r101 = r107;
|
||
if (!(r108 > 0)) {
|
||
break;
|
||
}
|
||
r110 = r107.slice(-1);
|
||
r24 = r108;
|
||
r105 = r107;
|
||
r101 = r105;
|
||
} while (r110 === "0");
|
||
}
|
||
}
|
||
const r112 = r101.slice(-1);
|
||
const r113 = r101;
|
||
const r114 = r112 === "." ? r113.slice(0, -1) : r113;
|
||
const r116 = length < r23;
|
||
let r117 = void 0;
|
||
if (r116) {
|
||
const call6 = join.call;
|
||
r117 = join.call(Array(r23 - length + 1), "0");
|
||
}
|
||
if (!r117) {
|
||
r117 = "";
|
||
}
|
||
r128 = r117 + r114;
|
||
}
|
||
if (c11517_32[r15]) {
|
||
let c22775_0 = c11517_32[r13["[[numberingSystem]]"]];
|
||
r250 = String(r128).replace(/\d/g, function(a0) {
|
||
return c22775_0[a0];
|
||
});
|
||
} else {
|
||
r250 = String(r128);
|
||
}
|
||
const r262 = r250.replace.call(r250, /\./g, r44.decimal);
|
||
const r263 = r13["[[useGrouping]]"];
|
||
r264 = r6;
|
||
nan = r262;
|
||
if (r263 === true) {
|
||
const r268 = r262.split(r44.decimal);
|
||
const r269 = r268[0];
|
||
const r271 = r42.patterns.primaryGroupSize || 3;
|
||
const r273 = r42.patterns.secondaryGroupSize || r271;
|
||
if (r269.length > r271) {
|
||
const r277 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r277);
|
||
const r280 = r269.length - r271;
|
||
let r281 = r280 % r273;
|
||
const r283 = r269.slice(0, r281);
|
||
if (r283.length) {
|
||
const call10 = push.call;
|
||
push.call(r277, r283);
|
||
}
|
||
while (r281 < r280) {
|
||
const call11 = push.call;
|
||
const r293 = r269.slice(r281, r281 + r273);
|
||
const r294 = r281;
|
||
push.call(r277, r293);
|
||
r281 = r294 + r273;
|
||
}
|
||
const call12 = push.call;
|
||
push.call(r277, r269.slice(r280));
|
||
const call13 = join.call;
|
||
r268[0] = join.call(r277, r44.group);
|
||
}
|
||
const call14 = join.call;
|
||
nan = join.call(r268, r44.decimal);
|
||
r264 = r6;
|
||
}
|
||
}
|
||
const r320 = r13[r264 === true ? "[[negativePattern]]" : "[[positivePattern]]"].replace("{number}", nan);
|
||
const r321 = r13["[[style]]"];
|
||
let r323 = r320;
|
||
if (r321 === "currency") {
|
||
const r324 = r13["[[currency]]"];
|
||
let r326 = r42.currencies[r324];
|
||
const r327 = r13["[[currencyDisplay]]"];
|
||
let r329 = r324;
|
||
if (r327 === "symbol") {
|
||
if (!r326) {
|
||
r326 = r324;
|
||
}
|
||
r329 = r326;
|
||
}
|
||
r323 = r320.replace("{currency}", r329);
|
||
}
|
||
regExpRestore.exp.test(regExpRestore.input);
|
||
return r323;
|
||
};
|
||
DateTimeFormatConstructor = function DateTimeFormatConstructor(r8, r7) {
|
||
let r18;
|
||
if (this && this !== c11517_3) {
|
||
if (this == null) {
|
||
throw new TypeError("Cannot convert null or undefined to object");
|
||
}
|
||
const r22 = Object(this);
|
||
InitializeDateTimeFormat(r22, r8, r7);
|
||
r18 = r22;
|
||
} else {
|
||
r18 = new c11517_3.DateTimeFormat(r8, r7);
|
||
}
|
||
return r18;
|
||
};
|
||
InitializeDateTimeFormat = function InitializeDateTimeFormat(prototype, a1, a2) {
|
||
let r108, pattern12;
|
||
const call = hasOwnProperty.call;
|
||
const r15 = hasOwnProperty.call(prototype, "__getInternalProperties") ? prototype.__getInternalProperties(c11517_16) : c11517_8(null);
|
||
let c22776_0 = r15;
|
||
const regExpRestore = createRegExpRestore();
|
||
if (r15["[[initializedIntlObject]]"] === true) {
|
||
throw new TypeError("`this` object has already been initialized as an Intl object");
|
||
}
|
||
defineProperty(prototype, "__getInternalProperties", {
|
||
value: function value() {
|
||
if (arguments[0] === c11517_16) {
|
||
return c22776_0;
|
||
}
|
||
}
|
||
});
|
||
r15["[[initializedIntlObject]]"] = true;
|
||
const r22 = CanonicalizeLocaleList(a1);
|
||
const r56 = ToDateTimeOptions(a2, "any", "date");
|
||
const r21 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in void 0) {
|
||
let r62 = void 0 instanceof Record;
|
||
if (!r62) {
|
||
const call2 = hasOwnProperty.call;
|
||
r62 = call2 === Function.prototype.call ? hasOwnProperty(key) : call2.call(hasOwnProperty, void 0, key);
|
||
}
|
||
if (r62) {
|
||
defineProperty(r21, key, {
|
||
value: (void 0)[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
const r70 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r70, "lookup", "best fit");
|
||
const localeMatcher = r56.localeMatcher;
|
||
let r74 = "best fit";
|
||
if (localeMatcher !== void 0) {
|
||
const r77 = String(localeMatcher);
|
||
const call3 = c11517_7.call;
|
||
const r80 = c11517_7.call(r70, r77);
|
||
r74 = r77;
|
||
if (r80 === -1) {
|
||
throw new RangeError("'" + r77 + "' is not an allowed value for `localeMatcher`");
|
||
}
|
||
}
|
||
r21["[[localeMatcher]]"] = r74;
|
||
const DateTimeFormat = c11517_15.DateTimeFormat;
|
||
const r84 = DateTimeFormat["[[localeData]]"];
|
||
const r86 = ResolveLocale(DateTimeFormat["[[availableLocales]]"], r22, r21, DateTimeFormat["[[relevantExtensionKeys]]"], r84);
|
||
r15["[[locale]]"] = r86["[[locale]]"];
|
||
r15["[[calendar]]"] = r86["[[ca]]"];
|
||
r15["[[numberingSystem]]"] = r86["[[nu]]"];
|
||
r15["[[dataLocale]]"] = r86["[[dataLocale]]"];
|
||
const r91 = r86["[[dataLocale]]"];
|
||
const timeZone = r56.timeZone;
|
||
let r93 = timeZone;
|
||
if (r93 !== void 0) {
|
||
const r95 = +timeZone.length;
|
||
let r25 = r95 - 1;
|
||
let r97 = timeZone;
|
||
let r98 = r97;
|
||
if (r95) {
|
||
do {
|
||
const r30 = r97.charAt(r25);
|
||
let r100 = r30 >= "a";
|
||
const r101 = r25;
|
||
const r29 = r97;
|
||
if (r100) {
|
||
r100 = r30 <= "z";
|
||
}
|
||
const r26 = r100 ? r29.slice(0, r101) + r30.toUpperCase() + r29.slice(r101 + 1) : r29;
|
||
r108 = +r101;
|
||
r25 = r108 - 1;
|
||
r97 = r26;
|
||
r98 = r97;
|
||
} while (r108);
|
||
}
|
||
r93 = r98;
|
||
if (r93 !== "UTC") {
|
||
throw new RangeError("timeZone is not supported.");
|
||
}
|
||
}
|
||
r15["[[timeZone]]"] = r93;
|
||
const r111 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key2 in void 0) {
|
||
let r119 = void 0 instanceof Record;
|
||
if (!r119) {
|
||
const call4 = hasOwnProperty.call;
|
||
r119 = call4 === Function.prototype.call ? hasOwnProperty(key2) : call4.call(hasOwnProperty, void 0, key2);
|
||
}
|
||
if (r119) {
|
||
defineProperty(r111, key2, {
|
||
value: (void 0)[key2],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
for (const key3 in c11517_35) {
|
||
const call5 = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(c11517_35, key3)) {
|
||
const r140 = c11517_35[key3];
|
||
const r141 = r56[key3];
|
||
let r142 = void 0;
|
||
if (r141 !== void 0) {
|
||
const r144 = String(r141);
|
||
r142 = r144;
|
||
if (r140 !== void 0) {
|
||
const call6 = c11517_7.call;
|
||
const r147 = c11517_7.call(r140, r144);
|
||
r142 = r144;
|
||
if (r147 === -1) {
|
||
throw new RangeError("'" + r144 + "' is not an allowed value for `" + key3 + "`");
|
||
}
|
||
}
|
||
}
|
||
r111["[[" + key3 + "]]"] = r142;
|
||
}
|
||
}
|
||
const r162 = r84[r91];
|
||
const formats = r162.formats;
|
||
const formats2 = Object.prototype.toString.call(formats) !== "[object Array]" ? createDateTimeFormats(formats) : formats;
|
||
const r178 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r178, "basic", "best fit");
|
||
const formatMatcher = r56.formatMatcher;
|
||
let r182 = "best fit";
|
||
if (formatMatcher !== void 0) {
|
||
const r184 = String(formatMatcher);
|
||
const call7 = c11517_7.call;
|
||
const r187 = c11517_7.call(r178, r184);
|
||
r182 = r184;
|
||
if (r187 === -1) {
|
||
throw new RangeError("'" + r184 + "' is not an allowed value for `formatMatcher`");
|
||
}
|
||
}
|
||
r162.formats = formats2;
|
||
const r189 = r182 === "basic" ? calculateScore(r111, formats2) : calculateScore(r111, formats2, true);
|
||
for (const key4 in c11517_35) {
|
||
const r196 = key4;
|
||
const call8 = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(c11517_35, r196)) {
|
||
const call9 = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(r189, r196)) {
|
||
r15["[[" + r196 + "]]"] = r189[r196];
|
||
}
|
||
}
|
||
}
|
||
const hour12 = r56.hour12;
|
||
let r207 = hour12 !== void 0 ? Boolean(hour12) : void 0;
|
||
if (r15["[[hour]]"]) {
|
||
if (r207 === void 0) {
|
||
r207 = r162.hour12;
|
||
}
|
||
r15["[[hour12]]"] = r207;
|
||
if (r207 === true) {
|
||
r15["[[hourNo0]]"] = r162.hourNo0;
|
||
pattern12 = r189.pattern12;
|
||
} else {
|
||
pattern12 = r189.pattern;
|
||
}
|
||
} else {
|
||
pattern12 = r189.pattern;
|
||
}
|
||
r15["[[pattern]]"] = pattern12;
|
||
r15["[[boundFormat]]"] = void 0;
|
||
r15["[[initializedDateTimeFormat]]"] = true;
|
||
if (c11517_4) {
|
||
const call10 = GetFormatDateTime.call;
|
||
prototype.format = GetFormatDateTime.call(prototype);
|
||
}
|
||
regExpRestore.exp.test(regExpRestore.input);
|
||
return prototype;
|
||
};
|
||
ToDateTimeOptions = function ToDateTimeOptions(a0, a1, a2) {
|
||
let r8 = null;
|
||
if (a0 !== void 0) {
|
||
if (a0 == null) {
|
||
throw new TypeError("Cannot convert null or undefined to object");
|
||
}
|
||
const r13 = Object(a0);
|
||
const r12 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in void 0) {
|
||
let r27 = void 0 instanceof Record;
|
||
if (!r27) {
|
||
const call = hasOwnProperty.call;
|
||
r27 = call === Function.prototype.call ? hasOwnProperty(key) : call.call(hasOwnProperty, void 0, key);
|
||
}
|
||
if (r27) {
|
||
defineProperty(r12, key, {
|
||
value: (void 0)[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
r8 = r12;
|
||
for (const key2 in r13) {
|
||
r8 = r12;
|
||
r12[key2] = r13[key2];
|
||
}
|
||
r8 = r12;
|
||
}
|
||
const r47 = c11517_8(r8);
|
||
let r55 = a1 !== "date" && a1 !== "any" || r47.weekday === void 0 && r47.year === void 0 && r47.month === void 0 && r47.day === void 0 ? true : false;
|
||
if (!(a1 !== "time" && a1 !== "any" || r47.hour === void 0 && r47.minute === void 0 && r47.second === void 0)) {
|
||
r55 = false;
|
||
}
|
||
let r63 = !r55;
|
||
if (!(r55 ? a2 !== "date" && a2 !== "all" : r63)) {
|
||
r47.day = "numeric";
|
||
r47.month = "numeric";
|
||
r47.year = "numeric";
|
||
}
|
||
if (r55) {
|
||
r63 = a2 !== "time" && a2 !== "all";
|
||
}
|
||
if (!r63) {
|
||
r47.second = "numeric";
|
||
r47.minute = "numeric";
|
||
r47.hour = "numeric";
|
||
}
|
||
return r47;
|
||
};
|
||
calculateScore = function calculateScore(a0, formats2, a2) {
|
||
let r2;
|
||
const length = formats2.length;
|
||
const r24 = 0 < length;
|
||
let r13 = -Infinity;
|
||
const r26 = !a2;
|
||
let r12 = 0;
|
||
let r30 = void 0;
|
||
let r29 = void 0;
|
||
if (r24) {
|
||
do {
|
||
const r41 = formats2[r12];
|
||
const r14 = r12;
|
||
let r11 = r13;
|
||
let r40 = r30;
|
||
let r0 = 0;
|
||
let r5 = 0;
|
||
for (const key in c11517_35) {
|
||
r2 = r0;
|
||
r5 = r2;
|
||
const call = hasOwnProperty.call;
|
||
const r53 = hasOwnProperty.call(c11517_35, key);
|
||
r0 = r2;
|
||
if (r53) {
|
||
const r56 = a0["[[" + key + "]]"];
|
||
const call2 = hasOwnProperty.call;
|
||
const r59 = hasOwnProperty.call(r41, key) ? r41[key] : void 0;
|
||
if (r56 === void 0 && r59 !== void 0) {
|
||
r0 = r2 - 20;
|
||
continue;
|
||
}
|
||
if (r56 !== void 0 && r59 === void 0) {
|
||
r0 = r2 - 120;
|
||
continue;
|
||
}
|
||
const r49 = ["2-digit", "numeric", "narrow", "short", "long"];
|
||
const call3 = c11517_7.call;
|
||
const r52 = c11517_7.call(r49, r56);
|
||
const call4 = c11517_7.call;
|
||
const r68 = Math.max(Math.min(c11517_7.call(r49, r59) - r52, 2), -2);
|
||
const r1 = (a2 ? (r56 !== "numeric" && r56 !== "2-digit" || r59 === "numeric" || r59 === "2-digit") && (r56 === "numeric" || r56 === "2-digit" || r59 !== "2-digit" && r59 !== "numeric") : r26) ? r2 : r2 - 8;
|
||
r0 = r68 === 2 ? r1 - 6 : r68 === 1 ? r1 - 3 : r68 === -1 ? r1 - 6 : r68 === -2 ? r1 - 8 : r1;
|
||
}
|
||
}
|
||
r2 = r0;
|
||
r5 = r2;
|
||
if (r11 < r5) {
|
||
r11 = r5;
|
||
r40 = r41;
|
||
}
|
||
r12 = r14 + 1;
|
||
r13 = r11;
|
||
r30 = r40;
|
||
r29 = r30;
|
||
} while (r12 < length);
|
||
}
|
||
return r29;
|
||
};
|
||
GetFormatDateTime = function GetFormatDateTime() {
|
||
let r2 = this != null && typeof this === "object";
|
||
if (r2) {
|
||
const call = hasOwnProperty.call;
|
||
r2 = hasOwnProperty.call(this, "__getInternalProperties") ? this.__getInternalProperties(c11517_16) : c11517_8(null);
|
||
}
|
||
if (r2 && r2["[[initializedDateTimeFormat]]"]) {
|
||
if (r2["[[boundFormat]]"] === void 0) {
|
||
const call2 = c11517_14.call;
|
||
r2["[[boundFormat]]"] = c11517_14.call(function() {
|
||
return FormatDateTime(this, Number(arguments.length === 0 ? Date.now() : arguments[0]));
|
||
}, this);
|
||
}
|
||
return r2["[[boundFormat]]"];
|
||
}
|
||
throw new TypeError("`this` value for format() is not an initialized Intl.DateTimeFormat object.");
|
||
};
|
||
FormatDateTime = function FormatDateTime(a0, a1) {
|
||
let r42, r44, r100, r101;
|
||
let r2 = void 0;
|
||
if (isFinite(a1)) {
|
||
const r63 = a0.__getInternalProperties(c11517_16);
|
||
const regExpRestore = createRegExpRestore();
|
||
const r38 = r63["[[locale]]"];
|
||
const numberFormat2 = new c11517_3.NumberFormat([r38], {
|
||
useGrouping: false
|
||
});
|
||
const numberFormat = new c11517_3.NumberFormat([r38], {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
});
|
||
r63["[[calendar]]"];
|
||
const r35 = (function ToLocalTime(a0, a1, a2) {
|
||
let r4 = a2;
|
||
const date = new Date(a0);
|
||
if (!a2) {
|
||
r4 = "";
|
||
}
|
||
const r20 = "get" + r4;
|
||
const r7 = {
|
||
"[[weekday]]": date[r20 + "Day"](),
|
||
"[[era]]": +(date[r20 + "FullYear"]() >= 0),
|
||
"[[year]]": date[r20 + "FullYear"](),
|
||
"[[month]]": date[r20 + "Month"](),
|
||
"[[day]]": date[r20 + "Date"](),
|
||
"[[hour]]": date[r20 + "Hours"](),
|
||
"[[minute]]": date[r20 + "Minutes"](),
|
||
"[[second]]": date[r20 + "Seconds"](),
|
||
"[[inDST]]": false
|
||
};
|
||
const r54 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in r7) {
|
||
let r61 = r7 instanceof Record;
|
||
if (!r61) {
|
||
const call = hasOwnProperty.call;
|
||
r61 = hasOwnProperty.call(r7, key);
|
||
}
|
||
if (r61) {
|
||
defineProperty(r54, key, {
|
||
value: r7[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
return r54;
|
||
})(a1, 0, r63["[[timeZone]]"]);
|
||
const r79 = r63["[[pattern]]"];
|
||
const calendars = c11517_15.DateTimeFormat["[[localeData]]"][r63["[[dataLocale]]"]].calendars;
|
||
const r86 = r63["[[calendar]]"];
|
||
let r88 = void 0;
|
||
let r89 = r79;
|
||
let r90 = void 0;
|
||
let r91 = r89;
|
||
for (const key in c11517_35) {
|
||
r42 = r88;
|
||
r44 = r89;
|
||
r90 = r42;
|
||
r91 = r44;
|
||
const call = hasOwnProperty.call;
|
||
const r93 = hasOwnProperty.call(r63, "[[" + key + "]]");
|
||
r88 = r42;
|
||
r89 = r44;
|
||
if (r93) {
|
||
const r46 = r63["[[" + key + "]]"];
|
||
const r98 = r35["[[" + key + "]]"];
|
||
if (key === "year" && r98 <= 0) {
|
||
r100 = 1 - r98;
|
||
r101 = r42;
|
||
} else if (key === "month") {
|
||
r100 = r98 + 1;
|
||
r101 = r42;
|
||
} else {
|
||
const r47 = key === "hour" && r63["[[hour12]]"] === true;
|
||
r100 = r98;
|
||
r101 = r42;
|
||
if (r47) {
|
||
const r49 = r98 % 12;
|
||
const r104 = r35["[[" + key + "]]"];
|
||
const r105 = (r49 === 0 ? r63["[[hourNo0]]"] === true : r49 === 0) ? 12 : r49;
|
||
r101 = r49 !== r104;
|
||
r100 = r105;
|
||
}
|
||
}
|
||
if (r46 === "numeric") {
|
||
r2 = FormatNumber(numberFormat2, r100);
|
||
} else if (r46 === "2-digit") {
|
||
const r134 = FormatNumber(numberFormat, r100);
|
||
r2 = r134;
|
||
if (r134.length > 2) {
|
||
r2 = r2.slice(-2);
|
||
}
|
||
} else if (r46 in c11517_17) {
|
||
if (key === "month") {
|
||
r2 = resolveDateString(calendars, r86, "months", r46, r35["[[" + key + "]]"]);
|
||
} else if (key === "weekday") {
|
||
try {
|
||
r2 = resolveDateString(calendars, r86, "days", r46, r35["[[" + key + "]]"]);
|
||
} catch ($e) {
|
||
throw new Error("Could not find weekday data for locale " + r38);
|
||
}
|
||
} else {
|
||
r2 = key === "timeZoneName" ? "" : r35["[[" + key + "]]"];
|
||
}
|
||
}
|
||
r89 = r44.replace("{" + key + "}", r2);
|
||
r88 = r101;
|
||
}
|
||
}
|
||
r42 = r88;
|
||
r44 = r89;
|
||
r90 = r42;
|
||
r91 = r44;
|
||
const r144 = r63["[[hour12]]"] === true ? r91.replace("{ampm}", resolveDateString(calendars, r86, "dayPeriods", r90 ? "pm" : "am")) : r91;
|
||
regExpRestore.exp.test(regExpRestore.input);
|
||
return r144;
|
||
}
|
||
throw new RangeError("Invalid valid date passed to format");
|
||
};
|
||
resolveDateString = function resolveDateString(calendars, a1, a2, a3, a4) {
|
||
let r25;
|
||
const r10 = calendars[a1] && calendars[a1][a2] ? calendars[a1][a2] : calendars.gregory[a2];
|
||
const r14 = {
|
||
narrow: ["short", "long"],
|
||
short: ["long", "narrow"],
|
||
long: ["short", "narrow"]
|
||
};
|
||
const call = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(r10, a3)) {
|
||
r25 = r10[a3];
|
||
} else {
|
||
const call2 = hasOwnProperty.call;
|
||
const r22 = hasOwnProperty.call(r10, r14[a3][0]);
|
||
const r23 = r14[a3];
|
||
r25 = r22 ? r10[r23[0]] : r10[r23[1]];
|
||
}
|
||
return a4 != null ? r25[a4] : r25;
|
||
};
|
||
Record = function Record(a0) {
|
||
for (const key in a0) {
|
||
let r13 = a0 instanceof Record;
|
||
if (!r13) {
|
||
const call = hasOwnProperty.call;
|
||
r13 = hasOwnProperty.call(a0, key);
|
||
}
|
||
if (r13) {
|
||
defineProperty(this, key, {
|
||
value: a0[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
};
|
||
List = function List() {
|
||
defineProperty(this, "length", {
|
||
writable: true,
|
||
value: 0
|
||
});
|
||
if (arguments.length) {
|
||
const call = slice.call;
|
||
push.apply(this, slice.call(arguments));
|
||
}
|
||
};
|
||
createRegExpRestore = function createRegExpRestore() {
|
||
let r23;
|
||
const r11 = RegExp.lastMatch || "";
|
||
const r10 = RegExp.multiline ? "m" : "";
|
||
const r32 = {
|
||
input: RegExp.input
|
||
};
|
||
const r34 = {
|
||
__proto__: List.prototype
|
||
};
|
||
List.call(r34);
|
||
const r20 = {};
|
||
let r0 = 1;
|
||
let r35 = false;
|
||
while (true) {
|
||
const r14 = "$" + r0;
|
||
let r21 = RegExp[r14];
|
||
r20[r14] = r21;
|
||
const r2 = r0;
|
||
const r36 = r35;
|
||
if (!r21) {
|
||
r21 = r36;
|
||
}
|
||
r0 = r2 + 1;
|
||
r35 = r21;
|
||
if (!(r0 <= 9)) {
|
||
const r18 = /[.?*+^$[\]\\(){}|-]/g;
|
||
let r38 = r11.replace(r18, "\\$&");
|
||
let r42 = 1;
|
||
let r43 = r38;
|
||
if (r21) {
|
||
do {
|
||
const r22 = r20["$" + r42];
|
||
const r3 = r42;
|
||
const r25 = r38;
|
||
if (r22) {
|
||
const r24 = r22.replace(r18, "\\$&");
|
||
r23 = r25.replace(r24, "(" + r24 + ")");
|
||
} else {
|
||
r23 = "()" + r25;
|
||
}
|
||
const call = push.call;
|
||
push.call(r34, r23.slice(0, r23.indexOf("(") + 1));
|
||
r38 = r23.slice(r23.indexOf("(") + 1);
|
||
r42 = r3 + 1;
|
||
r43 = r38;
|
||
} while (r42 <= 9);
|
||
}
|
||
const r62 = RegExp;
|
||
const call2 = join.call;
|
||
r32.exp = new r62(join.call(r34, "") + r43, r10);
|
||
return r32;
|
||
}
|
||
}
|
||
};
|
||
c11517_3 = {};
|
||
const r3 = (function() {
|
||
let r7;
|
||
try {
|
||
const r1 = {};
|
||
Object.defineProperty(r1, "a", {});
|
||
r7 = "a" in r1;
|
||
} catch ($e) {
|
||
return false;
|
||
}
|
||
return r7;
|
||
})();
|
||
c11517_4 = r3 ? !r3 : !Object.prototype.__defineGetter__;
|
||
hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
defineProperty = r3 ? Object.defineProperty : function(a0, a1, a2) {
|
||
if ("get" in a2 && a0.__defineGetter__) {
|
||
a0.__defineGetter__(a1, a2.get);
|
||
} else {
|
||
const call = hasOwnProperty.call;
|
||
if (!(hasOwnProperty.call(a0, a1) && !("value" in a2))) {
|
||
a0[a1] = a2.value;
|
||
}
|
||
}
|
||
};
|
||
c11517_7 = Array.prototype.indexOf || function(a0) {
|
||
if (this.length) {
|
||
let r4 = arguments[1] || 0;
|
||
const length = this.length;
|
||
while (r4 < length) {
|
||
const r7 = this[r4];
|
||
const r10 = r4;
|
||
if (r7 === a0) {
|
||
return r10;
|
||
}
|
||
r4 = r10 + 1;
|
||
}
|
||
return -1;
|
||
}
|
||
return -1;
|
||
};
|
||
c11517_8 = Object.create || function(a0, a1) {
|
||
const F = function F() {};
|
||
F.prototype = a0;
|
||
const r13 = {
|
||
__proto__: F.prototype
|
||
};
|
||
for (const key in a1) {
|
||
const call = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(a1, key)) {
|
||
defineProperty(r13, key, a1[key]);
|
||
}
|
||
}
|
||
return r13;
|
||
};
|
||
slice = Array.prototype.slice;
|
||
concat = Array.prototype.concat;
|
||
push = Array.prototype.push;
|
||
join = Array.prototype.join;
|
||
shift = Array.prototype.shift;
|
||
Array.prototype.unshift;
|
||
const r19 = Function.prototype.bind || function(c22777_0) {
|
||
const _this = this;
|
||
const call = slice.call;
|
||
let c22777_2 = slice.call(arguments, 1);
|
||
return this.length === 1 ? function(a0) {
|
||
const call = concat.call;
|
||
const call2 = slice.call;
|
||
return _this.apply(c22777_0, concat.call(c22777_2, slice.call(arguments)));
|
||
} : function() {
|
||
const call = concat.call;
|
||
const call2 = slice.call;
|
||
return _this.apply(c22777_0, concat.call(c22777_2, slice.call(arguments)));
|
||
};
|
||
};
|
||
const supportedLocalesOf = function supportedLocalesOf(a0) {
|
||
const call = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(this, "[[availableLocales]]")) {
|
||
const regExpRestore = createRegExpRestore();
|
||
const r12 = arguments[1];
|
||
const r33 = this["[[availableLocales]]"];
|
||
const r35 = CanonicalizeLocaleList(a0);
|
||
regExpRestore.exp.test(regExpRestore.input);
|
||
let r40 = void 0;
|
||
if (r12 !== void 0) {
|
||
if (r12 == null) {
|
||
throw new TypeError("Cannot convert null or undefined to object");
|
||
}
|
||
const r14 = Object(r12);
|
||
const r44 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in r14) {
|
||
let r48 = r14 instanceof Record;
|
||
if (!r48) {
|
||
const call2 = hasOwnProperty.call;
|
||
r48 = hasOwnProperty.call(r14, key);
|
||
}
|
||
if (r48) {
|
||
defineProperty(r44, key, {
|
||
value: r14[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
const localeMatcher = r44.localeMatcher;
|
||
r40 = localeMatcher;
|
||
if (r40 !== void 0) {
|
||
const r56 = String(localeMatcher);
|
||
r40 = r56;
|
||
if (r56 !== "lookup") {
|
||
r40 = r56;
|
||
if (r40 !== "best fit") {
|
||
throw new RangeError("matcher should be \"lookup\" or \"best fit\"");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const r61 = r40 !== void 0 && r40 !== "best fit" ? LookupSupportedLocales(r33, r35) : LookupSupportedLocales(r33, r35);
|
||
for (const key2 in r61) {
|
||
const call3 = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(r61, key2)) {
|
||
defineProperty(r61, key2, {
|
||
writable: false,
|
||
configurable: false,
|
||
value: r61[key2]
|
||
});
|
||
}
|
||
}
|
||
defineProperty(r61, "length", {
|
||
writable: false
|
||
});
|
||
return r61;
|
||
}
|
||
throw new TypeError("supportedLocalesOf() is not a constructor");
|
||
};
|
||
c11517_14 = r19;
|
||
c11517_15 = c11517_8(null);
|
||
c11517_16 = Math.random();
|
||
c11517_17 = c11517_8(null, {
|
||
narrow: {},
|
||
short: {},
|
||
long: {}
|
||
});
|
||
c11517_18 = false;
|
||
c11517_19 = false;
|
||
c11517_20 = /^[A-Z]{3}$/;
|
||
c11517_21 = /-u(?:-[0-9a-z]{2,8})+/gi;
|
||
c11517_22 = {
|
||
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"]
|
||
}
|
||
};
|
||
c11517_23 = {
|
||
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
|
||
};
|
||
defineProperty(c11517_3, "NumberFormat", {
|
||
configurable: true,
|
||
writable: true,
|
||
value: NumberFormatConstructor
|
||
});
|
||
defineProperty(c11517_3.NumberFormat, "prototype", {
|
||
writable: false
|
||
});
|
||
c11517_15.NumberFormat = {
|
||
"[[availableLocales]]": [],
|
||
"[[relevantExtensionKeys]]": ["nu"],
|
||
"[[localeData]]": {}
|
||
};
|
||
defineProperty(c11517_3.NumberFormat, "supportedLocalesOf", {
|
||
configurable: true,
|
||
writable: true,
|
||
value: c11517_14.call(supportedLocalesOf, c11517_15.NumberFormat)
|
||
});
|
||
defineProperty(c11517_3.NumberFormat.prototype, "format", {
|
||
configurable: true,
|
||
get: GetFormatNumber
|
||
});
|
||
c11517_32 = {
|
||
arab: ["٠", "١", "٢", "٣", "٤", "٥", "٦", "٧", "٨", "٩"],
|
||
arabext: ["۰", "۱", "۲", "۳", "۴", "۵", "۶", "۷", "۸", "۹"],
|
||
bali: ["᭐", "᭑", "᭒", "᭓", "᭔", "᭕", "᭖", "᭗", "᭘", "᭙"],
|
||
beng: ["০", "১", "২", "৩", "৪", "৫", "৬", "৭", "৮", "৯"],
|
||
deva: ["०", "१", "२", "३", "४", "५", "६", "७", "८", "९"],
|
||
fullwide: ["０", "１", "２", "３", "４", "５", "６", "７", "８", "９"],
|
||
gujr: ["૦", "૧", "૨", "૩", "૪", "૫", "૬", "૭", "૮", "૯"],
|
||
guru: ["੦", "੧", "੨", "੩", "੪", "੫", "੬", "੭", "੮", "੯"],
|
||
hanidec: ["〇", "一", "二", "三", "四", "五", "六", "七", "八", "九"],
|
||
khmr: ["០", "១", "២", "៣", "៤", "៥", "៦", "៧", "៨", "៩"],
|
||
knda: ["೦", "೧", "೨", "೩", "೪", "೫", "೬", "೭", "೮", "೯"],
|
||
laoo: ["໐", "໑", "໒", "໓", "໔", "໕", "໖", "໗", "໘", "໙"],
|
||
latn: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
|
||
limb: ["᥆", "᥇", "᥈", "᥉", "᥊", "᥋", "᥌", "᥍", "᥎", "᥏"],
|
||
mlym: ["൦", "൧", "൨", "൩", "൪", "൫", "൬", "൭", "൮", "൯"],
|
||
mong: ["᠐", "᠑", "᠒", "᠓", "᠔", "᠕", "᠖", "᠗", "᠘", "᠙"],
|
||
mymr: ["၀", "၁", "၂", "၃", "၄", "၅", "၆", "၇", "၈", "၉"],
|
||
orya: ["୦", "୧", "୨", "୩", "୪", "୫", "୬", "୭", "୮", "୯"],
|
||
tamldec: ["௦", "௧", "௨", "௩", "௪", "௫", "௬", "௭", "௮", "௯"],
|
||
telu: ["౦", "౧", "౨", "౩", "౪", "౫", "౬", "౭", "౮", "౯"],
|
||
thai: ["๐", "๑", "๒", "๓", "๔", "๕", "๖", "๗", "๘", "๙"],
|
||
tibt: ["༠", "༡", "༢", "༣", "༤", "༥", "༦", "༧", "༨", "༩"]
|
||
};
|
||
defineProperty(c11517_3.NumberFormat.prototype, "resolvedOptions", {
|
||
configurable: true,
|
||
writable: true,
|
||
value: function value() {
|
||
const r8 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in void 0) {
|
||
let r22 = void 0 instanceof Record;
|
||
if (!r22) {
|
||
const call = hasOwnProperty.call;
|
||
r22 = call === Function.prototype.call ? hasOwnProperty(key) : call.call(hasOwnProperty, void 0, key);
|
||
}
|
||
if (r22) {
|
||
defineProperty(r8, key, {
|
||
value: (void 0)[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
let r29 = this != null && typeof this === "object";
|
||
if (r29) {
|
||
const call2 = hasOwnProperty.call;
|
||
r29 = hasOwnProperty.call(this, "__getInternalProperties") ? this.__getInternalProperties(c11517_16) : c11517_8(null);
|
||
}
|
||
if (r29 && r29["[[initializedNumberFormat]]"]) {
|
||
const r45 = ["locale", "numberingSystem", "style", "currency", "currencyDisplay", "minimumIntegerDigits", "minimumFractionDigits", "maximumFractionDigits", "minimumSignificantDigits", "maximumSignificantDigits", "useGrouping"];
|
||
const length = r45.length;
|
||
let r47 = 0;
|
||
while (r47 < length) {
|
||
const call3 = hasOwnProperty.call;
|
||
const r55 = "[[" + r45[r47] + "]]";
|
||
const r1 = r47;
|
||
if (hasOwnProperty.call(r29, r55)) {
|
||
r8[r45[r1]] = {
|
||
value: r29[r55],
|
||
writable: true,
|
||
configurable: true,
|
||
enumerable: true
|
||
};
|
||
}
|
||
r47 = r1 + 1;
|
||
}
|
||
return c11517_8({}, r8);
|
||
}
|
||
throw new TypeError("`this` value for resolvedOptions() is not an initialized Intl.NumberFormat object.");
|
||
}
|
||
});
|
||
defineProperty(c11517_3, "DateTimeFormat", {
|
||
configurable: true,
|
||
writable: true,
|
||
value: DateTimeFormatConstructor
|
||
});
|
||
defineProperty(DateTimeFormatConstructor, "prototype", {
|
||
writable: false
|
||
});
|
||
c11517_35 = {
|
||
weekday: ["narrow", "short", "long"],
|
||
era: ["narrow", "short", "long"],
|
||
year: ["2-digit", "numeric"],
|
||
month: ["2-digit", "numeric", "narrow", "short", "long"],
|
||
day: ["2-digit", "numeric"],
|
||
hour: ["2-digit", "numeric"],
|
||
minute: ["2-digit", "numeric"],
|
||
second: ["2-digit", "numeric"],
|
||
timeZoneName: ["short", "long"]
|
||
};
|
||
c11517_15.DateTimeFormat = {
|
||
"[[availableLocales]]": [],
|
||
"[[relevantExtensionKeys]]": ["ca", "nu"],
|
||
"[[localeData]]": {}
|
||
};
|
||
defineProperty(c11517_3.DateTimeFormat, "supportedLocalesOf", {
|
||
configurable: true,
|
||
writable: true,
|
||
value: c11517_14.call(supportedLocalesOf, c11517_15.DateTimeFormat)
|
||
});
|
||
defineProperty(c11517_3.DateTimeFormat.prototype, "format", {
|
||
configurable: true,
|
||
get: GetFormatDateTime
|
||
});
|
||
defineProperty(c11517_3.DateTimeFormat.prototype, "resolvedOptions", {
|
||
writable: true,
|
||
configurable: true,
|
||
value: function value() {
|
||
const r8 = {
|
||
__proto__: Record.prototype
|
||
};
|
||
for (const key in void 0) {
|
||
let r22 = void 0 instanceof Record;
|
||
if (!r22) {
|
||
const call = hasOwnProperty.call;
|
||
r22 = call === Function.prototype.call ? hasOwnProperty(key) : call.call(hasOwnProperty, void 0, key);
|
||
}
|
||
if (r22) {
|
||
defineProperty(r8, key, {
|
||
value: (void 0)[key],
|
||
enumerable: true,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
let r29 = this != null && typeof this === "object";
|
||
if (r29) {
|
||
const call2 = hasOwnProperty.call;
|
||
r29 = hasOwnProperty.call(this, "__getInternalProperties") ? this.__getInternalProperties(c11517_16) : c11517_8(null);
|
||
}
|
||
if (r29 && r29["[[initializedDateTimeFormat]]"]) {
|
||
const r45 = ["locale", "calendar", "numberingSystem", "timeZone", "hour12", "weekday", "era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"];
|
||
const length = r45.length;
|
||
let r47 = 0;
|
||
while (r47 < length) {
|
||
const call3 = hasOwnProperty.call;
|
||
const r55 = "[[" + r45[r47] + "]]";
|
||
const r1 = r47;
|
||
if (hasOwnProperty.call(r29, r55)) {
|
||
r8[r45[r1]] = {
|
||
value: r29[r55],
|
||
writable: true,
|
||
configurable: true,
|
||
enumerable: true
|
||
};
|
||
}
|
||
r47 = r1 + 1;
|
||
}
|
||
return c11517_8({}, r8);
|
||
}
|
||
throw new TypeError("`this` value for resolvedOptions() is not an initialized Intl.DateTimeFormat object.");
|
||
}
|
||
});
|
||
const __localeSensitiveProtos = {
|
||
Number: {},
|
||
Date: {}
|
||
};
|
||
c11517_3.__localeSensitiveProtos = __localeSensitiveProtos;
|
||
c11517_40 = __localeSensitiveProtos;
|
||
c11517_40.Number.toLocaleString = function() {
|
||
if (Object.prototype.toString.call(this) !== "[object Number]") {
|
||
throw new TypeError("`this` value must be a number for Number.prototype.toLocaleString()");
|
||
}
|
||
const r8 = arguments[0];
|
||
const r19 = arguments[1];
|
||
const r21 = {
|
||
__proto__: NumberFormatConstructor.prototype
|
||
};
|
||
const r22 = NumberFormatConstructor.call(r21, r8, r19);
|
||
return FormatNumber(r22 instanceof Object ? r22 : r21, this);
|
||
};
|
||
c11517_40.Date.toLocaleString = function() {
|
||
if (Object.prototype.toString.call(this) !== "[object Date]") {
|
||
throw new TypeError("`this` value must be a Date instance for Date.prototype.toLocaleString()");
|
||
}
|
||
const r1 = +this;
|
||
const isNaN2 = isNaN(r1);
|
||
let r23 = "Invalid Date";
|
||
if (!isNaN2) {
|
||
const r9 = arguments[0];
|
||
const r28 = ToDateTimeOptions(arguments[1], "any", "all");
|
||
const r30 = {
|
||
__proto__: DateTimeFormatConstructor.prototype
|
||
};
|
||
const r31 = DateTimeFormatConstructor.call(r30, r9, r28);
|
||
r23 = FormatDateTime(r31 instanceof Object ? r31 : r30, r1);
|
||
}
|
||
return r23;
|
||
};
|
||
c11517_40.Date.toLocaleDateString = function() {
|
||
if (Object.prototype.toString.call(this) !== "[object Date]") {
|
||
throw new TypeError("`this` value must be a Date instance for Date.prototype.toLocaleDateString()");
|
||
}
|
||
const r1 = +this;
|
||
const isNaN2 = isNaN(r1);
|
||
let r22 = "Invalid Date";
|
||
if (!isNaN2) {
|
||
const r9 = arguments[0];
|
||
const r27 = ToDateTimeOptions(arguments[1], "date", "date");
|
||
const r29 = {
|
||
__proto__: DateTimeFormatConstructor.prototype
|
||
};
|
||
const r30 = DateTimeFormatConstructor.call(r29, r9, r27);
|
||
r22 = FormatDateTime(r30 instanceof Object ? r30 : r29, r1);
|
||
}
|
||
return r22;
|
||
};
|
||
c11517_40.Date.toLocaleTimeString = function() {
|
||
if (Object.prototype.toString.call(this) !== "[object Date]") {
|
||
throw new TypeError("`this` value must be a Date instance for Date.prototype.toLocaleTimeString()");
|
||
}
|
||
const r1 = +this;
|
||
const isNaN2 = isNaN(r1);
|
||
let r22 = "Invalid Date";
|
||
if (!isNaN2) {
|
||
const r9 = arguments[0];
|
||
const r27 = ToDateTimeOptions(arguments[1], "time", "time");
|
||
const r29 = {
|
||
__proto__: DateTimeFormatConstructor.prototype
|
||
};
|
||
const r30 = DateTimeFormatConstructor.call(r29, r9, r27);
|
||
r22 = FormatDateTime(r30 instanceof Object ? r30 : r29, r1);
|
||
}
|
||
return r22;
|
||
};
|
||
defineProperty(c11517_3, "__applyLocaleSensitivePrototypes", {
|
||
writable: true,
|
||
configurable: true,
|
||
value: function value() {
|
||
defineProperty(Number.prototype, "toLocaleString", {
|
||
writable: true,
|
||
configurable: true,
|
||
value: c11517_40.Number.toLocaleString
|
||
});
|
||
defineProperty(Date.prototype, "toLocaleString", {
|
||
writable: true,
|
||
configurable: true,
|
||
value: c11517_40.Date.toLocaleString
|
||
});
|
||
const Date2 = c11517_40.Date;
|
||
for (const key in Date2) {
|
||
const call = hasOwnProperty.call;
|
||
if (hasOwnProperty.call(c11517_40.Date, key)) {
|
||
defineProperty(Date.prototype, key, {
|
||
writable: true,
|
||
configurable: true,
|
||
value: c11517_40.Date[key]
|
||
});
|
||
}
|
||
}
|
||
}
|
||
});
|
||
defineProperty(c11517_3, "__addLocaleData", {
|
||
value: function value(a0) {
|
||
const locale2 = a0.locale;
|
||
let r21 = !!expBCP47Syntax.test(locale2);
|
||
if (r21) {
|
||
const r26 = expVariantDupes.test(locale2);
|
||
r21 = r26 ? !r26 : !expSingletonDupes.test(locale2);
|
||
}
|
||
if (r21) {
|
||
const locale3 = a0.locale;
|
||
if (a0.number) {
|
||
const r46 = [locale3];
|
||
const r48 = locale3.split("-");
|
||
if (r48.length > 2 && r48[1].length === 4) {
|
||
const call2 = push.call;
|
||
push.call(r46, r48[0] + "-" + r48[2]);
|
||
}
|
||
const call3 = shift.call;
|
||
let r63 = shift.call(r46);
|
||
while (r63) {
|
||
const call = push.call;
|
||
const r67 = c11517_15.NumberFormat["[[availableLocales]]"];
|
||
const r68 = r63;
|
||
push.call(r67, r68);
|
||
c11517_15.NumberFormat["[[localeData]]"][r68] = a0.number;
|
||
if (a0.date) {
|
||
a0.date.nu = a0.number.nu;
|
||
const call4 = push.call;
|
||
push.call(c11517_15.DateTimeFormat["[[availableLocales]]"], r68);
|
||
c11517_15.DateTimeFormat["[[localeData]]"][r68] = a0.date;
|
||
}
|
||
const call5 = shift.call;
|
||
r63 = shift.call(r46);
|
||
}
|
||
if (locale === void 0) {
|
||
locale = locale3;
|
||
}
|
||
if (!c11517_18) {
|
||
InitializeNumberFormat(c11517_3.NumberFormat.prototype);
|
||
c11517_18 = true;
|
||
}
|
||
if (a0.date && !c11517_19) {
|
||
InitializeDateTimeFormat(c11517_3.DateTimeFormat.prototype);
|
||
c11517_19 = true;
|
||
}
|
||
return void 0;
|
||
}
|
||
throw new Error("Object passed doesn't contain locale data for Intl.NumberFormat");
|
||
}
|
||
throw new Error("Object passed doesn't identify itself with a valid language tag");
|
||
}
|
||
});
|
||
Record.prototype = c11517_8(null);
|
||
List.prototype = c11517_8(null);
|
||
export default c11517_3;
|