e8fbfb14c1
Add coexistence checks to all enqueue methods to prevent loading both React and Grid.js assets simultaneously. Changes: - ReactAdmin.php: Only enqueue React assets when ?react=1 - Init.php: Skip Grid.js when React active on admin pages - Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0 - Customer.php, Product.php, License.php: Add coexistence checks Now the toggle between Classic and React versions works correctly. Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
1985 lines
61 KiB
JavaScript
1985 lines
61 KiB
JavaScript
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
|
(global = global || self, factory(global.IntlMessageFormat = {}));
|
|
}(this, function (exports) { 'use strict';
|
|
|
|
var parser = /*
|
|
* Generated by PEG.js 0.10.0.
|
|
*
|
|
* http://pegjs.org/
|
|
*/
|
|
(function() {
|
|
|
|
function peg$subclass(child, parent) {
|
|
function ctor() { this.constructor = child; }
|
|
ctor.prototype = parent.prototype;
|
|
child.prototype = new ctor();
|
|
}
|
|
|
|
function peg$SyntaxError(message, expected, found, location) {
|
|
this.message = message;
|
|
this.expected = expected;
|
|
this.found = found;
|
|
this.location = location;
|
|
this.name = "SyntaxError";
|
|
|
|
if (typeof Error.captureStackTrace === "function") {
|
|
Error.captureStackTrace(this, peg$SyntaxError);
|
|
}
|
|
}
|
|
|
|
peg$subclass(peg$SyntaxError, Error);
|
|
|
|
peg$SyntaxError.buildMessage = function(expected, found) {
|
|
var DESCRIBE_EXPECTATION_FNS = {
|
|
literal: function(expectation) {
|
|
return "\"" + literalEscape(expectation.text) + "\"";
|
|
},
|
|
|
|
"class": function(expectation) {
|
|
var escapedParts = "",
|
|
i;
|
|
|
|
for (i = 0; i < expectation.parts.length; i++) {
|
|
escapedParts += expectation.parts[i] instanceof Array
|
|
? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
|
|
: classEscape(expectation.parts[i]);
|
|
}
|
|
|
|
return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
|
|
},
|
|
|
|
any: function(expectation) {
|
|
return "any character";
|
|
},
|
|
|
|
end: function(expectation) {
|
|
return "end of input";
|
|
},
|
|
|
|
other: function(expectation) {
|
|
return expectation.description;
|
|
}
|
|
};
|
|
|
|
function hex(ch) {
|
|
return ch.charCodeAt(0).toString(16).toUpperCase();
|
|
}
|
|
|
|
function literalEscape(s) {
|
|
return s
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/"/g, '\\"')
|
|
.replace(/\0/g, '\\0')
|
|
.replace(/\t/g, '\\t')
|
|
.replace(/\n/g, '\\n')
|
|
.replace(/\r/g, '\\r')
|
|
.replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
|
|
.replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
|
|
}
|
|
|
|
function classEscape(s) {
|
|
return s
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/\]/g, '\\]')
|
|
.replace(/\^/g, '\\^')
|
|
.replace(/-/g, '\\-')
|
|
.replace(/\0/g, '\\0')
|
|
.replace(/\t/g, '\\t')
|
|
.replace(/\n/g, '\\n')
|
|
.replace(/\r/g, '\\r')
|
|
.replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
|
|
.replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
|
|
}
|
|
|
|
function describeExpectation(expectation) {
|
|
return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
|
|
}
|
|
|
|
function describeExpected(expected) {
|
|
var descriptions = new Array(expected.length),
|
|
i, j;
|
|
|
|
for (i = 0; i < expected.length; i++) {
|
|
descriptions[i] = describeExpectation(expected[i]);
|
|
}
|
|
|
|
descriptions.sort();
|
|
|
|
if (descriptions.length > 0) {
|
|
for (i = 1, j = 1; i < descriptions.length; i++) {
|
|
if (descriptions[i - 1] !== descriptions[i]) {
|
|
descriptions[j] = descriptions[i];
|
|
j++;
|
|
}
|
|
}
|
|
descriptions.length = j;
|
|
}
|
|
|
|
switch (descriptions.length) {
|
|
case 1:
|
|
return descriptions[0];
|
|
|
|
case 2:
|
|
return descriptions[0] + " or " + descriptions[1];
|
|
|
|
default:
|
|
return descriptions.slice(0, -1).join(", ")
|
|
+ ", or "
|
|
+ descriptions[descriptions.length - 1];
|
|
}
|
|
}
|
|
|
|
function describeFound(found) {
|
|
return found ? "\"" + literalEscape(found) + "\"" : "end of input";
|
|
}
|
|
|
|
return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
|
|
};
|
|
|
|
function peg$parse(input, options) {
|
|
options = options !== void 0 ? options : {};
|
|
|
|
var peg$FAILED = {},
|
|
|
|
peg$startRuleFunctions = { start: peg$parsestart },
|
|
peg$startRuleFunction = peg$parsestart,
|
|
|
|
peg$c0 = function(elements) {
|
|
return {
|
|
type : 'messageFormatPattern',
|
|
elements: elements,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c1 = function(chunks) {
|
|
return chunks.reduce(function (all, chunk) {
|
|
return all.concat(chunk)
|
|
}, []).join('')
|
|
},
|
|
peg$c2 = function(messageText) {
|
|
return {
|
|
type : 'messageTextElement',
|
|
value: messageText,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c3 = function(chars) { return chars.join(''); },
|
|
peg$c4 = "{",
|
|
peg$c5 = peg$literalExpectation("{", false),
|
|
peg$c6 = ",",
|
|
peg$c7 = peg$literalExpectation(",", false),
|
|
peg$c8 = "}",
|
|
peg$c9 = peg$literalExpectation("}", false),
|
|
peg$c10 = function(id, format) {
|
|
return {
|
|
type : 'argumentElement',
|
|
id : id,
|
|
format: format && format[2],
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c11 = "number",
|
|
peg$c12 = peg$literalExpectation("number", false),
|
|
peg$c13 = "date",
|
|
peg$c14 = peg$literalExpectation("date", false),
|
|
peg$c15 = "time",
|
|
peg$c16 = peg$literalExpectation("time", false),
|
|
peg$c17 = function(type, style) {
|
|
return {
|
|
type : type + 'Format',
|
|
style: style && style[2],
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c18 = "plural",
|
|
peg$c19 = peg$literalExpectation("plural", false),
|
|
peg$c20 = function(pluralStyle) {
|
|
return {
|
|
type : pluralStyle.type,
|
|
ordinal: false,
|
|
offset : pluralStyle.offset || 0,
|
|
options: pluralStyle.options,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c21 = "selectordinal",
|
|
peg$c22 = peg$literalExpectation("selectordinal", false),
|
|
peg$c23 = function(pluralStyle) {
|
|
return {
|
|
type : pluralStyle.type,
|
|
ordinal: true,
|
|
offset : pluralStyle.offset || 0,
|
|
options: pluralStyle.options,
|
|
location: location()
|
|
}
|
|
},
|
|
peg$c24 = "select",
|
|
peg$c25 = peg$literalExpectation("select", false),
|
|
peg$c26 = function(options) {
|
|
return {
|
|
type : 'selectFormat',
|
|
options: options,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c27 = "=",
|
|
peg$c28 = peg$literalExpectation("=", false),
|
|
peg$c29 = function(selector, pattern) {
|
|
return {
|
|
type : 'optionalFormatPattern',
|
|
selector: selector,
|
|
value : pattern,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c30 = "offset:",
|
|
peg$c31 = peg$literalExpectation("offset:", false),
|
|
peg$c32 = function(number) {
|
|
return number;
|
|
},
|
|
peg$c33 = function(offset, options) {
|
|
return {
|
|
type : 'pluralFormat',
|
|
offset : offset,
|
|
options: options,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c34 = peg$otherExpectation("whitespace"),
|
|
peg$c35 = /^[ \t\n\r]/,
|
|
peg$c36 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false),
|
|
peg$c37 = peg$otherExpectation("optionalWhitespace"),
|
|
peg$c38 = /^[0-9]/,
|
|
peg$c39 = peg$classExpectation([["0", "9"]], false, false),
|
|
peg$c40 = /^[0-9a-f]/i,
|
|
peg$c41 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true),
|
|
peg$c42 = "0",
|
|
peg$c43 = peg$literalExpectation("0", false),
|
|
peg$c44 = /^[1-9]/,
|
|
peg$c45 = peg$classExpectation([["1", "9"]], false, false),
|
|
peg$c46 = function(digits) {
|
|
return parseInt(digits, 10);
|
|
},
|
|
peg$c47 = "'",
|
|
peg$c48 = peg$literalExpectation("'", false),
|
|
peg$c49 = /^[ \t\n\r,.+={}#]/,
|
|
peg$c50 = peg$classExpectation([" ", "\t", "\n", "\r", ",", ".", "+", "=", "{", "}", "#"], false, false),
|
|
peg$c51 = peg$anyExpectation(),
|
|
peg$c52 = function(char) { return char; },
|
|
peg$c53 = function(sequence) { return sequence; },
|
|
peg$c54 = /^[^{}\\\0-\x1F\x7F \t\n\r]/,
|
|
peg$c55 = peg$classExpectation(["{", "}", "\\", ["\0", "\x1F"], "\x7F", " ", "\t", "\n", "\r"], true, false),
|
|
peg$c56 = "\\\\",
|
|
peg$c57 = peg$literalExpectation("\\\\", false),
|
|
peg$c58 = function() { return '\\'; },
|
|
peg$c59 = "\\#",
|
|
peg$c60 = peg$literalExpectation("\\#", false),
|
|
peg$c61 = function() { return '\\#'; },
|
|
peg$c62 = "\\{",
|
|
peg$c63 = peg$literalExpectation("\\{", false),
|
|
peg$c64 = function() { return '\u007B'; },
|
|
peg$c65 = "\\}",
|
|
peg$c66 = peg$literalExpectation("\\}", false),
|
|
peg$c67 = function() { return '\u007D'; },
|
|
peg$c68 = "\\u",
|
|
peg$c69 = peg$literalExpectation("\\u", false),
|
|
peg$c70 = function(digits) {
|
|
return String.fromCharCode(parseInt(digits, 16));
|
|
},
|
|
|
|
peg$currPos = 0,
|
|
peg$savedPos = 0,
|
|
peg$posDetailsCache = [{ line: 1, column: 1 }],
|
|
peg$maxFailPos = 0,
|
|
peg$maxFailExpected = [],
|
|
peg$silentFails = 0,
|
|
|
|
peg$result;
|
|
|
|
if ("startRule" in options) {
|
|
if (!(options.startRule in peg$startRuleFunctions)) {
|
|
throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
|
|
}
|
|
|
|
peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
|
|
}
|
|
|
|
function location() {
|
|
return peg$computeLocation(peg$savedPos, peg$currPos);
|
|
}
|
|
|
|
function peg$literalExpectation(text, ignoreCase) {
|
|
return { type: "literal", text: text, ignoreCase: ignoreCase };
|
|
}
|
|
|
|
function peg$classExpectation(parts, inverted, ignoreCase) {
|
|
return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
|
|
}
|
|
|
|
function peg$anyExpectation() {
|
|
return { type: "any" };
|
|
}
|
|
|
|
function peg$endExpectation() {
|
|
return { type: "end" };
|
|
}
|
|
|
|
function peg$otherExpectation(description) {
|
|
return { type: "other", description: description };
|
|
}
|
|
|
|
function peg$computePosDetails(pos) {
|
|
var details = peg$posDetailsCache[pos], p;
|
|
|
|
if (details) {
|
|
return details;
|
|
} else {
|
|
p = pos - 1;
|
|
while (!peg$posDetailsCache[p]) {
|
|
p--;
|
|
}
|
|
|
|
details = peg$posDetailsCache[p];
|
|
details = {
|
|
line: details.line,
|
|
column: details.column
|
|
};
|
|
|
|
while (p < pos) {
|
|
if (input.charCodeAt(p) === 10) {
|
|
details.line++;
|
|
details.column = 1;
|
|
} else {
|
|
details.column++;
|
|
}
|
|
|
|
p++;
|
|
}
|
|
|
|
peg$posDetailsCache[pos] = details;
|
|
return details;
|
|
}
|
|
}
|
|
|
|
function peg$computeLocation(startPos, endPos) {
|
|
var startPosDetails = peg$computePosDetails(startPos),
|
|
endPosDetails = peg$computePosDetails(endPos);
|
|
|
|
return {
|
|
start: {
|
|
offset: startPos,
|
|
line: startPosDetails.line,
|
|
column: startPosDetails.column
|
|
},
|
|
end: {
|
|
offset: endPos,
|
|
line: endPosDetails.line,
|
|
column: endPosDetails.column
|
|
}
|
|
};
|
|
}
|
|
|
|
function peg$fail(expected) {
|
|
if (peg$currPos < peg$maxFailPos) { return; }
|
|
|
|
if (peg$currPos > peg$maxFailPos) {
|
|
peg$maxFailPos = peg$currPos;
|
|
peg$maxFailExpected = [];
|
|
}
|
|
|
|
peg$maxFailExpected.push(expected);
|
|
}
|
|
|
|
function peg$buildStructuredError(expected, found, location) {
|
|
return new peg$SyntaxError(
|
|
peg$SyntaxError.buildMessage(expected, found),
|
|
expected,
|
|
found,
|
|
location
|
|
);
|
|
}
|
|
|
|
function peg$parsestart() {
|
|
var s0;
|
|
|
|
s0 = peg$parsemessageFormatPattern();
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageFormatPattern() {
|
|
var s0, s1, s2;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$parsemessageFormatElement();
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$parsemessageFormatElement();
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c0(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageFormatElement() {
|
|
var s0;
|
|
|
|
s0 = peg$parsemessageTextElement();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parseargumentElement();
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageText() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$currPos;
|
|
s3 = peg$parse_();
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parsechars();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parse_();
|
|
if (s5 !== peg$FAILED) {
|
|
s3 = [s3, s4, s5];
|
|
s2 = s3;
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$currPos;
|
|
s3 = peg$parse_();
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parsechars();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parse_();
|
|
if (s5 !== peg$FAILED) {
|
|
s3 = [s3, s4, s5];
|
|
s2 = s3;
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c1(s1);
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
s1 = peg$parsews();
|
|
if (s1 !== peg$FAILED) {
|
|
s0 = input.substring(s0, peg$currPos);
|
|
} else {
|
|
s0 = s1;
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageTextElement() {
|
|
var s0, s1;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$parsemessageText();
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c2(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseargument() {
|
|
var s0, s1, s2;
|
|
|
|
s0 = peg$parsenumber();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$parsequoteEscapedChar();
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$parsequoteEscapedChar();
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c3(s1);
|
|
}
|
|
s0 = s1;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseargumentElement() {
|
|
var s0, s1, s2, s3, s4, s5, s6, s7, s8;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
s1 = peg$c4;
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c5); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parseargument();
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s6 = peg$c6;
|
|
peg$currPos++;
|
|
} else {
|
|
s6 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c7); }
|
|
}
|
|
if (s6 !== peg$FAILED) {
|
|
s7 = peg$parse_();
|
|
if (s7 !== peg$FAILED) {
|
|
s8 = peg$parseelementFormat();
|
|
if (s8 !== peg$FAILED) {
|
|
s6 = [s6, s7, s8];
|
|
s5 = s6;
|
|
} else {
|
|
peg$currPos = s5;
|
|
s5 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s5;
|
|
s5 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s5;
|
|
s5 = peg$FAILED;
|
|
}
|
|
if (s5 === peg$FAILED) {
|
|
s5 = null;
|
|
}
|
|
if (s5 !== peg$FAILED) {
|
|
s6 = peg$parse_();
|
|
if (s6 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
s7 = peg$c8;
|
|
peg$currPos++;
|
|
} else {
|
|
s7 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c9); }
|
|
}
|
|
if (s7 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c10(s3, s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseelementFormat() {
|
|
var s0;
|
|
|
|
s0 = peg$parsesimpleFormat();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parsepluralFormat();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parseselectOrdinalFormat();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parseselectFormat();
|
|
}
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsesimpleFormat() {
|
|
var s0, s1, s2, s3, s4, s5, s6;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 6) === peg$c11) {
|
|
s1 = peg$c11;
|
|
peg$currPos += 6;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c12); }
|
|
}
|
|
if (s1 === peg$FAILED) {
|
|
if (input.substr(peg$currPos, 4) === peg$c13) {
|
|
s1 = peg$c13;
|
|
peg$currPos += 4;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c14); }
|
|
}
|
|
if (s1 === peg$FAILED) {
|
|
if (input.substr(peg$currPos, 4) === peg$c15) {
|
|
s1 = peg$c15;
|
|
peg$currPos += 4;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c16); }
|
|
}
|
|
}
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s4 = peg$c6;
|
|
peg$currPos++;
|
|
} else {
|
|
s4 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c7); }
|
|
}
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parse_();
|
|
if (s5 !== peg$FAILED) {
|
|
s6 = peg$parsechars();
|
|
if (s6 !== peg$FAILED) {
|
|
s4 = [s4, s5, s6];
|
|
s3 = s4;
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
if (s3 === peg$FAILED) {
|
|
s3 = null;
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c17(s1, s3);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsepluralFormat() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 6) === peg$c18) {
|
|
s1 = peg$c18;
|
|
peg$currPos += 6;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c19); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s3 = peg$c6;
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c7); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsepluralStyle();
|
|
if (s5 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c20(s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseselectOrdinalFormat() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 13) === peg$c21) {
|
|
s1 = peg$c21;
|
|
peg$currPos += 13;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c22); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s3 = peg$c6;
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c7); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsepluralStyle();
|
|
if (s5 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c23(s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseselectFormat() {
|
|
var s0, s1, s2, s3, s4, s5, s6;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 6) === peg$c24) {
|
|
s1 = peg$c24;
|
|
peg$currPos += 6;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c25); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s3 = peg$c6;
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c7); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = [];
|
|
s6 = peg$parseoptionalFormatPattern();
|
|
if (s6 !== peg$FAILED) {
|
|
while (s6 !== peg$FAILED) {
|
|
s5.push(s6);
|
|
s6 = peg$parseoptionalFormatPattern();
|
|
}
|
|
} else {
|
|
s5 = peg$FAILED;
|
|
}
|
|
if (s5 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c26(s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseselector() {
|
|
var s0, s1, s2, s3;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 61) {
|
|
s2 = peg$c27;
|
|
peg$currPos++;
|
|
} else {
|
|
s2 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c28); }
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parsenumber();
|
|
if (s3 !== peg$FAILED) {
|
|
s2 = [s2, s3];
|
|
s1 = s2;
|
|
} else {
|
|
peg$currPos = s1;
|
|
s1 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s1;
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s0 = input.substring(s0, peg$currPos);
|
|
} else {
|
|
s0 = s1;
|
|
}
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parsechars();
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseoptionalFormatPattern() {
|
|
var s0, s1, s2, s3, s4, s5, s6;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$parse_();
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parseselector();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parse_();
|
|
if (s3 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
s4 = peg$c4;
|
|
peg$currPos++;
|
|
} else {
|
|
s4 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c5); }
|
|
}
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsemessageFormatPattern();
|
|
if (s5 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
s6 = peg$c8;
|
|
peg$currPos++;
|
|
} else {
|
|
s6 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c9); }
|
|
}
|
|
if (s6 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c29(s2, s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseoffset() {
|
|
var s0, s1, s2, s3;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 7) === peg$c30) {
|
|
s1 = peg$c30;
|
|
peg$currPos += 7;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c31); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parsenumber();
|
|
if (s3 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c32(s3);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsepluralStyle() {
|
|
var s0, s1, s2, s3, s4;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$parseoffset();
|
|
if (s1 === peg$FAILED) {
|
|
s1 = null;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = [];
|
|
s4 = peg$parseoptionalFormatPattern();
|
|
if (s4 !== peg$FAILED) {
|
|
while (s4 !== peg$FAILED) {
|
|
s3.push(s4);
|
|
s4 = peg$parseoptionalFormatPattern();
|
|
}
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c33(s1, s3);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsews() {
|
|
var s0, s1;
|
|
|
|
peg$silentFails++;
|
|
s0 = [];
|
|
if (peg$c35.test(input.charAt(peg$currPos))) {
|
|
s1 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c36); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
while (s1 !== peg$FAILED) {
|
|
s0.push(s1);
|
|
if (peg$c35.test(input.charAt(peg$currPos))) {
|
|
s1 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c36); }
|
|
}
|
|
}
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
}
|
|
peg$silentFails--;
|
|
if (s0 === peg$FAILED) {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c34); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parse_() {
|
|
var s0, s1, s2;
|
|
|
|
peg$silentFails++;
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$parsews();
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$parsews();
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s0 = input.substring(s0, peg$currPos);
|
|
} else {
|
|
s0 = s1;
|
|
}
|
|
peg$silentFails--;
|
|
if (s0 === peg$FAILED) {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c37); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsedigit() {
|
|
var s0;
|
|
|
|
if (peg$c38.test(input.charAt(peg$currPos))) {
|
|
s0 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c39); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsehexDigit() {
|
|
var s0;
|
|
|
|
if (peg$c40.test(input.charAt(peg$currPos))) {
|
|
s0 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c41); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsenumber() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 48) {
|
|
s1 = peg$c42;
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c43); }
|
|
}
|
|
if (s1 === peg$FAILED) {
|
|
s1 = peg$currPos;
|
|
s2 = peg$currPos;
|
|
if (peg$c44.test(input.charAt(peg$currPos))) {
|
|
s3 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c45); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = [];
|
|
s5 = peg$parsedigit();
|
|
while (s5 !== peg$FAILED) {
|
|
s4.push(s5);
|
|
s5 = peg$parsedigit();
|
|
}
|
|
if (s4 !== peg$FAILED) {
|
|
s3 = [s3, s4];
|
|
s2 = s3;
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
s1 = input.substring(s1, peg$currPos);
|
|
} else {
|
|
s1 = s2;
|
|
}
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c46(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsequoteEscapedChar() {
|
|
var s0, s1, s2;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$currPos;
|
|
peg$silentFails++;
|
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
s2 = peg$c47;
|
|
peg$currPos++;
|
|
} else {
|
|
s2 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c48); }
|
|
}
|
|
if (s2 === peg$FAILED) {
|
|
if (peg$c49.test(input.charAt(peg$currPos))) {
|
|
s2 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s2 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c50); }
|
|
}
|
|
}
|
|
peg$silentFails--;
|
|
if (s2 === peg$FAILED) {
|
|
s1 = void 0;
|
|
} else {
|
|
peg$currPos = s1;
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
if (input.length > peg$currPos) {
|
|
s2 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s2 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c51); }
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c52(s2);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
s1 = peg$c47;
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c48); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parseescape();
|
|
if (s2 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c53(s2);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseapostrophe() {
|
|
var s0;
|
|
|
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
s0 = peg$c47;
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c48); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseescape() {
|
|
var s0;
|
|
|
|
if (peg$c49.test(input.charAt(peg$currPos))) {
|
|
s0 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c50); }
|
|
}
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parseapostrophe();
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsechar() {
|
|
var s0, s1, s2, s3, s4, s5, s6, s7;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
s1 = peg$c47;
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c48); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parseapostrophe();
|
|
if (s2 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c53(s2);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
if (s0 === peg$FAILED) {
|
|
if (peg$c54.test(input.charAt(peg$currPos))) {
|
|
s0 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c55); }
|
|
}
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c56) {
|
|
s1 = peg$c56;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c57); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c58();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c59) {
|
|
s1 = peg$c59;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c60); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c61();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c62) {
|
|
s1 = peg$c62;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c63); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c64();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c65) {
|
|
s1 = peg$c65;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c66); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c67();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c68) {
|
|
s1 = peg$c68;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c69); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$currPos;
|
|
s3 = peg$currPos;
|
|
s4 = peg$parsehexDigit();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsehexDigit();
|
|
if (s5 !== peg$FAILED) {
|
|
s6 = peg$parsehexDigit();
|
|
if (s6 !== peg$FAILED) {
|
|
s7 = peg$parsehexDigit();
|
|
if (s7 !== peg$FAILED) {
|
|
s4 = [s4, s5, s6, s7];
|
|
s3 = s4;
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s2 = input.substring(s2, peg$currPos);
|
|
} else {
|
|
s2 = s3;
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c70(s2);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsechars() {
|
|
var s0, s1, s2;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$parsechar();
|
|
if (s2 !== peg$FAILED) {
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$parsechar();
|
|
}
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c3(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
peg$result = peg$startRuleFunction();
|
|
|
|
if (peg$result !== peg$FAILED && peg$currPos === input.length) {
|
|
return peg$result;
|
|
} else {
|
|
if (peg$result !== peg$FAILED && peg$currPos < input.length) {
|
|
peg$fail(peg$endExpectation());
|
|
}
|
|
|
|
throw peg$buildStructuredError(
|
|
peg$maxFailExpected,
|
|
peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
|
|
peg$maxFailPos < input.length
|
|
? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
|
|
: peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
|
|
);
|
|
}
|
|
}
|
|
|
|
return {
|
|
SyntaxError: peg$SyntaxError,
|
|
parse: peg$parse
|
|
};
|
|
})();
|
|
|
|
/*
|
|
Copyright (c) 2014, Yahoo! Inc. All rights reserved.
|
|
Copyrights licensed under the New BSD License.
|
|
See the accompanying LICENSE file for terms.
|
|
*/
|
|
var __extends = (undefined && undefined.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var Compiler = /** @class */ (function () {
|
|
function Compiler(locales, formats, formatters) {
|
|
this.locales = [];
|
|
this.formats = {
|
|
number: {},
|
|
date: {},
|
|
time: {}
|
|
};
|
|
this.pluralNumberFormat = null;
|
|
this.currentPlural = null;
|
|
this.pluralStack = [];
|
|
this.locales = locales;
|
|
this.formats = formats;
|
|
this.formatters = formatters;
|
|
}
|
|
Compiler.prototype.compile = function (ast) {
|
|
this.pluralStack = [];
|
|
this.currentPlural = null;
|
|
this.pluralNumberFormat = null;
|
|
return this.compileMessage(ast);
|
|
};
|
|
Compiler.prototype.compileMessage = function (ast) {
|
|
var _this = this;
|
|
if (!(ast && ast.type === 'messageFormatPattern')) {
|
|
throw new Error('Message AST is not of type: "messageFormatPattern"');
|
|
}
|
|
var elements = ast.elements;
|
|
var pattern = elements
|
|
.filter(function (el) {
|
|
return el.type === 'messageTextElement' || el.type === 'argumentElement';
|
|
})
|
|
.map(function (el) {
|
|
return el.type === 'messageTextElement'
|
|
? _this.compileMessageText(el)
|
|
: _this.compileArgument(el);
|
|
});
|
|
if (pattern.length !== elements.length) {
|
|
throw new Error('Message element does not have a valid type');
|
|
}
|
|
return pattern;
|
|
};
|
|
Compiler.prototype.compileMessageText = function (element) {
|
|
// When this `element` is part of plural sub-pattern and its value contains
|
|
// an unescaped '#', use a `PluralOffsetString` helper to properly output
|
|
// the number with the correct offset in the string.
|
|
if (this.currentPlural && /(^|[^\\])#/g.test(element.value)) {
|
|
// Create a cache a NumberFormat instance that can be reused for any
|
|
// PluralOffsetString instance in this message.
|
|
if (!this.pluralNumberFormat) {
|
|
this.pluralNumberFormat = new Intl.NumberFormat(this.locales);
|
|
}
|
|
return new PluralOffsetString(this.currentPlural.id, this.currentPlural.format.offset, this.pluralNumberFormat, element.value);
|
|
}
|
|
// Unescape the escaped '#'s in the message text.
|
|
return element.value.replace(/\\#/g, '#');
|
|
};
|
|
Compiler.prototype.compileArgument = function (element) {
|
|
var format = element.format, id = element.id;
|
|
var formatters = this.formatters;
|
|
if (!format) {
|
|
return new StringFormat(id);
|
|
}
|
|
var _a = this, formats = _a.formats, locales = _a.locales;
|
|
switch (format.type) {
|
|
case 'numberFormat':
|
|
return {
|
|
id: id,
|
|
format: formatters.getNumberFormat(locales, formats.number[format.style]).format
|
|
};
|
|
case 'dateFormat':
|
|
return {
|
|
id: id,
|
|
format: formatters.getDateTimeFormat(locales, formats.date[format.style]).format
|
|
};
|
|
case 'timeFormat':
|
|
return {
|
|
id: id,
|
|
format: formatters.getDateTimeFormat(locales, formats.time[format.style]).format
|
|
};
|
|
case 'pluralFormat':
|
|
return new PluralFormat(id, format.offset, this.compileOptions(element), formatters.getPluralRules(locales, {
|
|
type: format.ordinal ? 'ordinal' : 'cardinal'
|
|
}));
|
|
case 'selectFormat':
|
|
return new SelectFormat(id, this.compileOptions(element));
|
|
default:
|
|
throw new Error('Message element does not have a valid format type');
|
|
}
|
|
};
|
|
Compiler.prototype.compileOptions = function (element) {
|
|
var _this = this;
|
|
var format = element.format;
|
|
var options = format.options;
|
|
// Save the current plural element, if any, then set it to a new value when
|
|
// compiling the options sub-patterns. This conforms the spec's algorithm
|
|
// for handling `"#"` syntax in message text.
|
|
this.pluralStack.push(this.currentPlural);
|
|
this.currentPlural = format.type === 'pluralFormat' ? element : null;
|
|
var optionsHash = options.reduce(function (all, option) {
|
|
// Compile the sub-pattern and save it under the options's selector.
|
|
all[option.selector] = _this.compileMessage(option.value);
|
|
return all;
|
|
}, {});
|
|
// Pop the plural stack to put back the original current plural value.
|
|
this.currentPlural = this.pluralStack.pop();
|
|
return optionsHash;
|
|
};
|
|
return Compiler;
|
|
}());
|
|
// -- Compiler Helper Classes --------------------------------------------------
|
|
var Formatter = /** @class */ (function () {
|
|
function Formatter(id) {
|
|
this.id = id;
|
|
}
|
|
return Formatter;
|
|
}());
|
|
var StringFormat = /** @class */ (function (_super) {
|
|
__extends(StringFormat, _super);
|
|
function StringFormat() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
StringFormat.prototype.format = function (value) {
|
|
if (!value && typeof value !== 'number') {
|
|
return '';
|
|
}
|
|
return typeof value === 'string' ? value : String(value);
|
|
};
|
|
return StringFormat;
|
|
}(Formatter));
|
|
var PluralFormat = /** @class */ (function () {
|
|
function PluralFormat(id, offset, options, pluralRules) {
|
|
this.id = id;
|
|
this.offset = offset;
|
|
this.options = options;
|
|
this.pluralRules = pluralRules;
|
|
}
|
|
PluralFormat.prototype.getOption = function (value) {
|
|
var options = this.options;
|
|
var option = options['=' + value] ||
|
|
options[this.pluralRules.select(value - this.offset)];
|
|
return option || options.other;
|
|
};
|
|
return PluralFormat;
|
|
}());
|
|
var PluralOffsetString = /** @class */ (function (_super) {
|
|
__extends(PluralOffsetString, _super);
|
|
function PluralOffsetString(id, offset, numberFormat, string) {
|
|
var _this = _super.call(this, id) || this;
|
|
_this.offset = offset;
|
|
_this.numberFormat = numberFormat;
|
|
_this.string = string;
|
|
return _this;
|
|
}
|
|
PluralOffsetString.prototype.format = function (value) {
|
|
var number = this.numberFormat.format(value - this.offset);
|
|
return this.string
|
|
.replace(/(^|[^\\])#/g, '$1' + number)
|
|
.replace(/\\#/g, '#');
|
|
};
|
|
return PluralOffsetString;
|
|
}(Formatter));
|
|
var SelectFormat = /** @class */ (function () {
|
|
function SelectFormat(id, options) {
|
|
this.id = id;
|
|
this.options = options;
|
|
}
|
|
SelectFormat.prototype.getOption = function (value) {
|
|
var options = this.options;
|
|
return options[value] || options.other;
|
|
};
|
|
return SelectFormat;
|
|
}());
|
|
function isSelectOrPluralFormat(f) {
|
|
return !!f.options;
|
|
}
|
|
|
|
/*
|
|
Copyright (c) 2014, Yahoo! Inc. All rights reserved.
|
|
Copyrights licensed under the New BSD License.
|
|
See the accompanying LICENSE file for terms.
|
|
*/
|
|
var __extends$1 = (undefined && undefined.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __assign = (undefined && undefined.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
// -- MessageFormat --------------------------------------------------------
|
|
function resolveLocale(locales) {
|
|
if (typeof locales === 'string') {
|
|
locales = [locales];
|
|
}
|
|
try {
|
|
return Intl.NumberFormat.supportedLocalesOf(locales, {
|
|
// IE11 localeMatcher `lookup` seems to convert `en` -> `en-US`
|
|
// but not other browsers,
|
|
localeMatcher: 'best fit'
|
|
})[0];
|
|
}
|
|
catch (e) {
|
|
return IntlMessageFormat.defaultLocale;
|
|
}
|
|
}
|
|
function formatPatterns(pattern, values) {
|
|
var result = '';
|
|
for (var _i = 0, pattern_1 = pattern; _i < pattern_1.length; _i++) {
|
|
var part = pattern_1[_i];
|
|
// Exist early for string parts.
|
|
if (typeof part === 'string') {
|
|
result += part;
|
|
continue;
|
|
}
|
|
var id = part.id;
|
|
// Enforce that all required values are provided by the caller.
|
|
if (!(values && id in values)) {
|
|
throw new FormatError("A value must be provided for: " + id, id);
|
|
}
|
|
var value = values[id];
|
|
// Recursively format plural and select parts' option — which can be a
|
|
// nested pattern structure. The choosing of the option to use is
|
|
// abstracted-by and delegated-to the part helper object.
|
|
if (isSelectOrPluralFormat(part)) {
|
|
result += formatPatterns(part.getOption(value), values);
|
|
}
|
|
else {
|
|
result += part.format(value);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mergeConfig(c1, c2) {
|
|
if (!c2) {
|
|
return c1;
|
|
}
|
|
return __assign({}, (c1 || {}), (c2 || {}), Object.keys(c1).reduce(function (all, k) {
|
|
all[k] = __assign({}, c1[k], (c2[k] || {}));
|
|
return all;
|
|
}, {}));
|
|
}
|
|
function mergeConfigs(defaultConfig, configs) {
|
|
if (!configs) {
|
|
return defaultConfig;
|
|
}
|
|
return Object.keys(defaultConfig).reduce(function (all, k) {
|
|
all[k] = mergeConfig(defaultConfig[k], configs[k]);
|
|
return all;
|
|
}, __assign({}, defaultConfig));
|
|
}
|
|
var FormatError = /** @class */ (function (_super) {
|
|
__extends$1(FormatError, _super);
|
|
function FormatError(msg, variableId) {
|
|
var _this = _super.call(this, msg) || this;
|
|
_this.variableId = variableId;
|
|
return _this;
|
|
}
|
|
return FormatError;
|
|
}(Error));
|
|
function createDefaultFormatters() {
|
|
return {
|
|
getNumberFormat: function () {
|
|
var _a;
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
return new ((_a = Intl.NumberFormat).bind.apply(_a, [void 0].concat(args)))();
|
|
},
|
|
getDateTimeFormat: function () {
|
|
var _a;
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
return new ((_a = Intl.DateTimeFormat).bind.apply(_a, [void 0].concat(args)))();
|
|
},
|
|
getPluralRules: function () {
|
|
var _a;
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
return new ((_a = Intl.PluralRules).bind.apply(_a, [void 0].concat(args)))();
|
|
}
|
|
};
|
|
}
|
|
var IntlMessageFormat = /** @class */ (function () {
|
|
function IntlMessageFormat(message, locales, overrideFormats, opts) {
|
|
var _this = this;
|
|
if (locales === void 0) { locales = IntlMessageFormat.defaultLocale; }
|
|
this.format = function (values) {
|
|
try {
|
|
return formatPatterns(_this.pattern, values);
|
|
}
|
|
catch (e) {
|
|
if (e.variableId) {
|
|
throw new Error("The intl string context variable '" + e.variableId + "' was not provided to the string '" + _this.message + "'");
|
|
}
|
|
else {
|
|
throw e;
|
|
}
|
|
}
|
|
};
|
|
if (typeof message === 'string') {
|
|
if (!IntlMessageFormat.__parse) {
|
|
throw new TypeError('IntlMessageFormat.__parse must be set to process `message` of type `string`');
|
|
}
|
|
// Parse string messages into an AST.
|
|
this.ast = IntlMessageFormat.__parse(message);
|
|
}
|
|
else {
|
|
this.ast = message;
|
|
}
|
|
this.message = message;
|
|
if (!(this.ast && this.ast.type === 'messageFormatPattern')) {
|
|
throw new TypeError('A message must be provided as a String or AST.');
|
|
}
|
|
// Creates a new object with the specified `formats` merged with the default
|
|
// formats.
|
|
var formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats);
|
|
// Defined first because it's used to build the format pattern.
|
|
this.locale = resolveLocale(locales || []);
|
|
var formatters = (opts && opts.formatters) || createDefaultFormatters();
|
|
// Compile the `ast` to a pattern that is highly optimized for repeated
|
|
// `format()` invocations. **Note:** This passes the `locales` set provided
|
|
// to the constructor instead of just the resolved locale.
|
|
this.pattern = new Compiler(locales, formats, formatters).compile(this.ast);
|
|
// "Bind" `format()` method to `this` so it can be passed by reference like
|
|
// the other `Intl` APIs.
|
|
}
|
|
IntlMessageFormat.prototype.resolvedOptions = function () {
|
|
return { locale: this.locale };
|
|
};
|
|
IntlMessageFormat.prototype.getAst = function () {
|
|
return this.ast;
|
|
};
|
|
IntlMessageFormat.defaultLocale = 'en';
|
|
IntlMessageFormat.__parse = undefined;
|
|
// Default format options used as the prototype of the `formats` provided to the
|
|
// constructor. These are used when constructing the internal Intl.NumberFormat
|
|
// and Intl.DateTimeFormat instances.
|
|
IntlMessageFormat.formats = {
|
|
number: {
|
|
currency: {
|
|
style: 'currency'
|
|
},
|
|
percent: {
|
|
style: 'percent'
|
|
}
|
|
},
|
|
date: {
|
|
short: {
|
|
month: 'numeric',
|
|
day: 'numeric',
|
|
year: '2-digit'
|
|
},
|
|
medium: {
|
|
month: 'short',
|
|
day: 'numeric',
|
|
year: 'numeric'
|
|
},
|
|
long: {
|
|
month: 'long',
|
|
day: 'numeric',
|
|
year: 'numeric'
|
|
},
|
|
full: {
|
|
weekday: 'long',
|
|
month: 'long',
|
|
day: 'numeric',
|
|
year: 'numeric'
|
|
}
|
|
},
|
|
time: {
|
|
short: {
|
|
hour: 'numeric',
|
|
minute: 'numeric'
|
|
},
|
|
medium: {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
second: 'numeric'
|
|
},
|
|
long: {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
second: 'numeric',
|
|
timeZoneName: 'short'
|
|
},
|
|
full: {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
second: 'numeric',
|
|
timeZoneName: 'short'
|
|
}
|
|
}
|
|
};
|
|
return IntlMessageFormat;
|
|
}());
|
|
|
|
/*
|
|
Copyright (c) 2014, Yahoo! Inc. All rights reserved.
|
|
Copyrights licensed under the New BSD License.
|
|
See the accompanying LICENSE file for terms.
|
|
*/
|
|
IntlMessageFormat.__parse = parser.parse;
|
|
|
|
exports.IntlMessageFormat = IntlMessageFormat;
|
|
exports.createDefaultFormatters = createDefaultFormatters;
|
|
exports.default = IntlMessageFormat;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
}));
|
|
//# sourceMappingURL=intl-messageformat.js.map
|