'use strict';
var fs = require('fs');
var path = require('path');
var promises = require('fs/promises');
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol */
var __assign = function() {
__assign = Object.assign || function __assign(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);
};
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
var ErrorKind;
(function (ErrorKind) {
/** Argument is unclosed (e.g. `{0`) */
ErrorKind[ErrorKind["EXPECT_ARGUMENT_CLOSING_BRACE"] = 1] = "EXPECT_ARGUMENT_CLOSING_BRACE";
/** Argument is empty (e.g. `{}`). */
ErrorKind[ErrorKind["EMPTY_ARGUMENT"] = 2] = "EMPTY_ARGUMENT";
/** Argument is malformed (e.g. `{foo!}``) */
ErrorKind[ErrorKind["MALFORMED_ARGUMENT"] = 3] = "MALFORMED_ARGUMENT";
/** Expect an argument type (e.g. `{foo,}`) */
ErrorKind[ErrorKind["EXPECT_ARGUMENT_TYPE"] = 4] = "EXPECT_ARGUMENT_TYPE";
/** Unsupported argument type (e.g. `{foo,foo}`) */
ErrorKind[ErrorKind["INVALID_ARGUMENT_TYPE"] = 5] = "INVALID_ARGUMENT_TYPE";
/** Expect an argument style (e.g. `{foo, number, }`) */
ErrorKind[ErrorKind["EXPECT_ARGUMENT_STYLE"] = 6] = "EXPECT_ARGUMENT_STYLE";
/** The number skeleton is invalid. */
ErrorKind[ErrorKind["INVALID_NUMBER_SKELETON"] = 7] = "INVALID_NUMBER_SKELETON";
/** The date time skeleton is invalid. */
ErrorKind[ErrorKind["INVALID_DATE_TIME_SKELETON"] = 8] = "INVALID_DATE_TIME_SKELETON";
/** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */
ErrorKind[ErrorKind["EXPECT_NUMBER_SKELETON"] = 9] = "EXPECT_NUMBER_SKELETON";
/** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */
ErrorKind[ErrorKind["EXPECT_DATE_TIME_SKELETON"] = 10] = "EXPECT_DATE_TIME_SKELETON";
/** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */
ErrorKind[ErrorKind["UNCLOSED_QUOTE_IN_ARGUMENT_STYLE"] = 11] = "UNCLOSED_QUOTE_IN_ARGUMENT_STYLE";
/** Missing select argument options (e.g. `{foo, select}`) */
ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_OPTIONS"] = 12] = "EXPECT_SELECT_ARGUMENT_OPTIONS";
/** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */
ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE"] = 13] = "EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE";
/** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */
ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_OFFSET_VALUE"] = 14] = "INVALID_PLURAL_ARGUMENT_OFFSET_VALUE";
/** Expecting a selector in `select` argument (e.g `{foo, select}`) */
ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR"] = 15] = "EXPECT_SELECT_ARGUMENT_SELECTOR";
/** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */
ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR"] = 16] = "EXPECT_PLURAL_ARGUMENT_SELECTOR";
/** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */
ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT"] = 17] = "EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT";
/**
* Expecting a message fragment after the `plural` or `selectordinal` selector
* (e.g. `{foo, plural, one}`)
*/
ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT"] = 18] = "EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT";
/** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */
ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_SELECTOR"] = 19] = "INVALID_PLURAL_ARGUMENT_SELECTOR";
/**
* Duplicate selectors in `plural` or `selectordinal` argument.
* (e.g. {foo, plural, one {#} one {#}})
*/
ErrorKind[ErrorKind["DUPLICATE_PLURAL_ARGUMENT_SELECTOR"] = 20] = "DUPLICATE_PLURAL_ARGUMENT_SELECTOR";
/** Duplicate selectors in `select` argument.
* (e.g. {foo, select, apple {apple} apple {apple}})
*/
ErrorKind[ErrorKind["DUPLICATE_SELECT_ARGUMENT_SELECTOR"] = 21] = "DUPLICATE_SELECT_ARGUMENT_SELECTOR";
/** Plural or select argument option must have `other` clause. */
ErrorKind[ErrorKind["MISSING_OTHER_CLAUSE"] = 22] = "MISSING_OTHER_CLAUSE";
/** The tag is malformed. (e.g. `foo) */
ErrorKind[ErrorKind["INVALID_TAG"] = 23] = "INVALID_TAG";
/** The tag name is invalid. (e.g. `<123>foo`) */
ErrorKind[ErrorKind["INVALID_TAG_NAME"] = 25] = "INVALID_TAG_NAME";
/** The closing tag does not match the opening tag. (e.g. `foo`) */
ErrorKind[ErrorKind["UNMATCHED_CLOSING_TAG"] = 26] = "UNMATCHED_CLOSING_TAG";
/** The opening tag has unmatched closing tag. (e.g. `foo`) */
ErrorKind[ErrorKind["UNCLOSED_TAG"] = 27] = "UNCLOSED_TAG";
})(ErrorKind || (ErrorKind = {}));
var TYPE;
(function (TYPE) {
/**
* Raw text
*/
TYPE[TYPE["literal"] = 0] = "literal";
/**
* Variable w/o any format, e.g `var` in `this is a {var}`
*/
TYPE[TYPE["argument"] = 1] = "argument";
/**
* Variable w/ number format
*/
TYPE[TYPE["number"] = 2] = "number";
/**
* Variable w/ date format
*/
TYPE[TYPE["date"] = 3] = "date";
/**
* Variable w/ time format
*/
TYPE[TYPE["time"] = 4] = "time";
/**
* Variable w/ select format
*/
TYPE[TYPE["select"] = 5] = "select";
/**
* Variable w/ plural format
*/
TYPE[TYPE["plural"] = 6] = "plural";
/**
* Only possible within plural argument.
* This is the `#` symbol that will be substituted with the count.
*/
TYPE[TYPE["pound"] = 7] = "pound";
/**
* XML-like tag
*/
TYPE[TYPE["tag"] = 8] = "tag";
})(TYPE || (TYPE = {}));
var SKELETON_TYPE;
(function (SKELETON_TYPE) {
SKELETON_TYPE[SKELETON_TYPE["number"] = 0] = "number";
SKELETON_TYPE[SKELETON_TYPE["dateTime"] = 1] = "dateTime";
})(SKELETON_TYPE || (SKELETON_TYPE = {}));
function isNumberElement(el) {
return el.type === TYPE.number;
}
function isDateElement(el) {
return el.type === TYPE.date;
}
function isTimeElement(el) {
return el.type === TYPE.time;
}
function isSelectElement(el) {
return el.type === TYPE.select;
}
function isPluralElement(el) {
return el.type === TYPE.plural;
}
function isTagElement(el) {
return el.type === TYPE.tag;
}
function isNumberSkeleton(el) {
return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.number);
}
function isDateTimeSkeleton(el) {
return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.dateTime);
}
// @generated from regex-gen.ts
var SPACE_SEPARATOR_REGEX = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
/**
* https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
* Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js
* with some tweaks
*/
var DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
/**
* Parse Date time skeleton into Intl.DateTimeFormatOptions
* Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
* @public
* @param skeleton skeleton string
*/
function parseDateTimeSkeleton(skeleton) {
var result = {};
skeleton.replace(DATE_TIME_REGEX, function (match) {
var len = match.length;
switch (match[0]) {
// Era
case 'G':
result.era = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';
break;
// Year
case 'y':
result.year = len === 2 ? '2-digit' : 'numeric';
break;
case 'Y':
case 'u':
case 'U':
case 'r':
throw new RangeError('`Y/u/U/r` (year) patterns are not supported, use `y` instead');
// Quarter
case 'q':
case 'Q':
throw new RangeError('`q/Q` (quarter) patterns are not supported');
// Month
case 'M':
case 'L':
result.month = ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1];
break;
// Week
case 'w':
case 'W':
throw new RangeError('`w/W` (week) patterns are not supported');
case 'd':
result.day = ['numeric', '2-digit'][len - 1];
break;
case 'D':
case 'F':
case 'g':
throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');
// Weekday
case 'E':
result.weekday = len === 4 ? 'short' : len === 5 ? 'narrow' : 'short';
break;
case 'e':
if (len < 4) {
throw new RangeError('`e..eee` (weekday) patterns are not supported');
}
result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];
break;
case 'c':
if (len < 4) {
throw new RangeError('`c..ccc` (weekday) patterns are not supported');
}
result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];
break;
// Period
case 'a': // AM, PM
result.hour12 = true;
break;
case 'b': // am, pm, noon, midnight
case 'B': // flexible day periods
throw new RangeError('`b/B` (period) patterns are not supported, use `a` instead');
// Hour
case 'h':
result.hourCycle = 'h12';
result.hour = ['numeric', '2-digit'][len - 1];
break;
case 'H':
result.hourCycle = 'h23';
result.hour = ['numeric', '2-digit'][len - 1];
break;
case 'K':
result.hourCycle = 'h11';
result.hour = ['numeric', '2-digit'][len - 1];
break;
case 'k':
result.hourCycle = 'h24';
result.hour = ['numeric', '2-digit'][len - 1];
break;
case 'j':
case 'J':
case 'C':
throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');
// Minute
case 'm':
result.minute = ['numeric', '2-digit'][len - 1];
break;
// Second
case 's':
result.second = ['numeric', '2-digit'][len - 1];
break;
case 'S':
case 'A':
throw new RangeError('`S/A` (second) patterns are not supported, use `s` instead');
// Zone
case 'z': // 1..3, 4: specific non-location format
result.timeZoneName = len < 4 ? 'short' : 'long';
break;
case 'Z': // 1..3, 4, 5: The ISO8601 varios formats
case 'O': // 1, 4: miliseconds in day short, long
case 'v': // 1, 4: generic non-location format
case 'V': // 1, 2, 3, 4: time zone ID or city
case 'X': // 1, 2, 3, 4: The ISO8601 varios formats
case 'x': // 1, 2, 3, 4: The ISO8601 varios formats
throw new RangeError('`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead');
}
return '';
});
return result;
}
// @generated from regex-gen.ts
var WHITE_SPACE_REGEX = /[\t-\r \x85\u200E\u200F\u2028\u2029]/i;
function parseNumberSkeletonFromString(skeleton) {
if (skeleton.length === 0) {
throw new Error('Number skeleton cannot be empty');
}
// Parse the skeleton
var stringTokens = skeleton
.split(WHITE_SPACE_REGEX)
.filter(function (x) { return x.length > 0; });
var tokens = [];
for (var _i = 0, stringTokens_1 = stringTokens; _i < stringTokens_1.length; _i++) {
var stringToken = stringTokens_1[_i];
var stemAndOptions = stringToken.split('/');
if (stemAndOptions.length === 0) {
throw new Error('Invalid number skeleton');
}
var stem = stemAndOptions[0], options = stemAndOptions.slice(1);
for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {
var option = options_1[_a];
if (option.length === 0) {
throw new Error('Invalid number skeleton');
}
}
tokens.push({ stem: stem, options: options });
}
return tokens;
}
function icuUnitToEcma(unit) {
return unit.replace(/^(.*?)-/, '');
}
var FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/g;
var SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\+|#+)?[rs]?$/g;
var INTEGER_WIDTH_REGEX = /(\*)(0+)|(#+)(0+)|(0+)/g;
var CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;
function parseSignificantPrecision(str) {
var result = {};
if (str[str.length - 1] === 'r') {
result.roundingPriority = 'morePrecision';
}
else if (str[str.length - 1] === 's') {
result.roundingPriority = 'lessPrecision';
}
str.replace(SIGNIFICANT_PRECISION_REGEX, function (_, g1, g2) {
// @@@ case
if (typeof g2 !== 'string') {
result.minimumSignificantDigits = g1.length;
result.maximumSignificantDigits = g1.length;
}
// @@@+ case
else if (g2 === '+') {
result.minimumSignificantDigits = g1.length;
}
// .### case
else if (g1[0] === '#') {
result.maximumSignificantDigits = g1.length;
}
// .@@## or .@@@ case
else {
result.minimumSignificantDigits = g1.length;
result.maximumSignificantDigits =
g1.length + (typeof g2 === 'string' ? g2.length : 0);
}
return '';
});
return result;
}
function parseSign(str) {
switch (str) {
case 'sign-auto':
return {
signDisplay: 'auto',
};
case 'sign-accounting':
case '()':
return {
currencySign: 'accounting',
};
case 'sign-always':
case '+!':
return {
signDisplay: 'always',
};
case 'sign-accounting-always':
case '()!':
return {
signDisplay: 'always',
currencySign: 'accounting',
};
case 'sign-except-zero':
case '+?':
return {
signDisplay: 'exceptZero',
};
case 'sign-accounting-except-zero':
case '()?':
return {
signDisplay: 'exceptZero',
currencySign: 'accounting',
};
case 'sign-never':
case '+_':
return {
signDisplay: 'never',
};
}
}
function parseConciseScientificAndEngineeringStem(stem) {
// Engineering
var result;
if (stem[0] === 'E' && stem[1] === 'E') {
result = {
notation: 'engineering',
};
stem = stem.slice(2);
}
else if (stem[0] === 'E') {
result = {
notation: 'scientific',
};
stem = stem.slice(1);
}
if (result) {
var signDisplay = stem.slice(0, 2);
if (signDisplay === '+!') {
result.signDisplay = 'always';
stem = stem.slice(2);
}
else if (signDisplay === '+?') {
result.signDisplay = 'exceptZero';
stem = stem.slice(2);
}
if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) {
throw new Error('Malformed concise eng/scientific notation');
}
result.minimumIntegerDigits = stem.length;
}
return result;
}
function parseNotationOptions(opt) {
var result = {};
var signOpts = parseSign(opt);
if (signOpts) {
return signOpts;
}
return result;
}
/**
* https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#skeleton-stems-and-options
*/
function parseNumberSkeleton(tokens) {
var result = {};
for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
var token = tokens_1[_i];
switch (token.stem) {
case 'percent':
case '%':
result.style = 'percent';
continue;
case '%x100':
result.style = 'percent';
result.scale = 100;
continue;
case 'currency':
result.style = 'currency';
result.currency = token.options[0];
continue;
case 'group-off':
case ',_':
result.useGrouping = false;
continue;
case 'precision-integer':
case '.':
result.maximumFractionDigits = 0;
continue;
case 'measure-unit':
case 'unit':
result.style = 'unit';
result.unit = icuUnitToEcma(token.options[0]);
continue;
case 'compact-short':
case 'K':
result.notation = 'compact';
result.compactDisplay = 'short';
continue;
case 'compact-long':
case 'KK':
result.notation = 'compact';
result.compactDisplay = 'long';
continue;
case 'scientific':
result = __assign(__assign(__assign({}, result), { notation: 'scientific' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));
continue;
case 'engineering':
result = __assign(__assign(__assign({}, result), { notation: 'engineering' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));
continue;
case 'notation-simple':
result.notation = 'standard';
continue;
// https://github.com/unicode-org/icu/blob/master/icu4c/source/i18n/unicode/unumberformatter.h
case 'unit-width-narrow':
result.currencyDisplay = 'narrowSymbol';
result.unitDisplay = 'narrow';
continue;
case 'unit-width-short':
result.currencyDisplay = 'code';
result.unitDisplay = 'short';
continue;
case 'unit-width-full-name':
result.currencyDisplay = 'name';
result.unitDisplay = 'long';
continue;
case 'unit-width-iso-code':
result.currencyDisplay = 'symbol';
continue;
case 'scale':
result.scale = parseFloat(token.options[0]);
continue;
// https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width
case 'integer-width':
if (token.options.length > 1) {
throw new RangeError('integer-width stems only accept a single optional option');
}
token.options[0].replace(INTEGER_WIDTH_REGEX, function (_, g1, g2, g3, g4, g5) {
if (g1) {
result.minimumIntegerDigits = g2.length;
}
else if (g3 && g4) {
throw new Error('We currently do not support maximum integer digits');
}
else if (g5) {
throw new Error('We currently do not support exact integer digits');
}
return '';
});
continue;
}
// https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width
if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {
result.minimumIntegerDigits = token.stem.length;
continue;
}
if (FRACTION_PRECISION_REGEX.test(token.stem)) {
// Precision
// https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#fraction-precision
// precision-integer case
if (token.options.length > 1) {
throw new RangeError('Fraction-precision stems only accept a single optional option');
}
token.stem.replace(FRACTION_PRECISION_REGEX, function (_, g1, g2, g3, g4, g5) {
// .000* case (before ICU67 it was .000+)
if (g2 === '*') {
result.minimumFractionDigits = g1.length;
}
// .### case
else if (g3 && g3[0] === '#') {
result.maximumFractionDigits = g3.length;
}
// .00## case
else if (g4 && g5) {
result.minimumFractionDigits = g4.length;
result.maximumFractionDigits = g4.length + g5.length;
}
else {
result.minimumFractionDigits = g1.length;
result.maximumFractionDigits = g1.length;
}
return '';
});
var opt = token.options[0];
// https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#trailing-zero-display
if (opt === 'w') {
result = __assign(__assign({}, result), { trailingZeroDisplay: 'stripIfInteger' });
}
else if (opt) {
result = __assign(__assign({}, result), parseSignificantPrecision(opt));
}
continue;
}
// https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#significant-digits-precision
if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {
result = __assign(__assign({}, result), parseSignificantPrecision(token.stem));
continue;
}
var signOpts = parseSign(token.stem);
if (signOpts) {
result = __assign(__assign({}, result), signOpts);
}
var conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);
if (conciseScientificAndEngineeringOpts) {
result = __assign(__assign({}, result), conciseScientificAndEngineeringOpts);
}
}
return result;
}
// @generated from time-data-gen.ts
// prettier-ignore
var timeData = {
"001": [
"H",
"h"
],
"AC": [
"H",
"h",
"hb",
"hB"
],
"AD": [
"H",
"hB"
],
"AE": [
"h",
"hB",
"hb",
"H"
],
"AF": [
"H",
"hb",
"hB",
"h"
],
"AG": [
"h",
"hb",
"H",
"hB"
],
"AI": [
"H",
"h",
"hb",
"hB"
],
"AL": [
"h",
"H",
"hB"
],
"AM": [
"H",
"hB"
],
"AO": [
"H",
"hB"
],
"AR": [
"H",
"h",
"hB",
"hb"
],
"AS": [
"h",
"H"
],
"AT": [
"H",
"hB"
],
"AU": [
"h",
"hb",
"H",
"hB"
],
"AW": [
"H",
"hB"
],
"AX": [
"H"
],
"AZ": [
"H",
"hB",
"h"
],
"BA": [
"H",
"hB",
"h"
],
"BB": [
"h",
"hb",
"H",
"hB"
],
"BD": [
"h",
"hB",
"H"
],
"BE": [
"H",
"hB"
],
"BF": [
"H",
"hB"
],
"BG": [
"H",
"hB",
"h"
],
"BH": [
"h",
"hB",
"hb",
"H"
],
"BJ": [
"H",
"hB"
],
"BL": [
"H",
"hB"
],
"BM": [
"h",
"hb",
"H",
"hB"
],
"BN": [
"hb",
"hB",
"h",
"H"
],
"BO": [
"H",
"hB",
"h",
"hb"
],
"BQ": [
"H"
],
"BR": [
"H",
"hB"
],
"BS": [
"h",
"hb",
"H",
"hB"
],
"BT": [
"h",
"H"
],
"BW": [
"H",
"h",
"hb",
"hB"
],
"BZ": [
"H",
"h",
"hb",
"hB"
],
"CA": [
"h",
"hb",
"H",
"hB"
],
"CC": [
"H",
"h",
"hb",
"hB"
],
"CD": [
"hB",
"H"
],
"CF": [
"H",
"h",
"hB"
],
"CG": [
"H",
"hB"
],
"CH": [
"H",
"hB",
"h"
],
"CI": [
"H",
"hB"
],
"CK": [
"H",
"h",
"hb",
"hB"
],
"CL": [
"H",
"h",
"hB",
"hb"
],
"CM": [
"H",
"h",
"hB"
],
"CN": [
"H",
"hB",
"hb",
"h"
],
"CO": [
"h",
"H",
"hB",
"hb"
],
"CP": [
"H"
],
"CR": [
"H",
"h",
"hB",
"hb"
],
"CU": [
"H",
"h",
"hB",
"hb"
],
"CV": [
"H",
"hB"
],
"CX": [
"H",
"h",
"hb",
"hB"
],
"CY": [
"h",
"H",
"hb",
"hB"
],
"CZ": [
"H"
],
"DE": [
"H",
"hB"
],
"DG": [
"H",
"h",
"hb",
"hB"
],
"DJ": [
"h",
"H"
],
"DK": [
"H"
],
"DM": [
"h",
"hb",
"H",
"hB"
],
"DO": [
"h",
"H",
"hB",
"hb"
],
"DZ": [
"h",
"hB",
"hb",
"H"
],
"EA": [
"H",
"h",
"hB",
"hb"
],
"EC": [
"H",
"hB",
"h",
"hb"
],
"EE": [
"H",
"hB"
],
"EG": [
"h",
"hB",
"hb",
"H"
],
"EH": [
"h",
"hB",
"hb",
"H"
],
"ER": [
"h",
"H"
],
"ES": [
"H",
"hB",
"h",
"hb"
],
"ET": [
"hB",
"hb",
"h",
"H"
],
"FI": [
"H"
],
"FJ": [
"h",
"hb",
"H",
"hB"
],
"FK": [
"H",
"h",
"hb",
"hB"
],
"FM": [
"h",
"hb",
"H",
"hB"
],
"FR": [
"H",
"hB"
],
"GA": [
"H",
"hB"
],
"GB": [
"H",
"h",
"hb",
"hB"
],
"GD": [
"h",
"hb",
"H",
"hB"
],
"GE": [
"H",
"hB",
"h"
],
"GF": [
"H",
"hB"
],
"GG": [
"H",
"h",
"hb",
"hB"
],
"GH": [
"h",
"H"
],
"GI": [
"H",
"h",
"hb",
"hB"
],
"GM": [
"h",
"hb",
"H",
"hB"
],
"GN": [
"H",
"hB"
],
"GP": [
"H",
"hB"
],
"GQ": [
"H",
"hB",
"h",
"hb"
],
"GR": [
"h",
"H",
"hb",
"hB"
],
"GT": [
"H",
"h",
"hB",
"hb"
],
"GU": [
"h",
"hb",
"H",
"hB"
],
"GW": [
"H",
"hB"
],
"GY": [
"h",
"hb",
"H",
"hB"
],
"HK": [
"h",
"hB",
"hb",
"H"
],
"HN": [
"H",
"h",
"hB",
"hb"
],
"HR": [
"H",
"hB"
],
"IC": [
"H",
"h",
"hB",
"hb"
],
"ID": [
"H"
],
"IE": [
"H",
"h",
"hb",
"hB"
],
"IL": [
"H",
"hB"
],
"IM": [
"H",
"h",
"hb",
"hB"
],
"IN": [
"h",
"H"
],
"IO": [
"H",
"h",
"hb",
"hB"
],
"IQ": [
"h",
"hB",
"hb",
"H"
],
"IR": [
"hB",
"H"
],
"IS": [
"H"
],
"IT": [
"H",
"hB"
],
"JE": [
"H",
"h",
"hb",
"hB"
],
"JM": [
"h",
"hb",
"H",
"hB"
],
"JO": [
"h",
"hB",
"hb",
"H"
],
"JP": [
"H",
"h",
"K"
],
"KE": [
"hB",
"hb",
"H",
"h"
],
"KG": [
"H",
"h",
"hB",
"hb"
],
"KH": [
"hB",
"h",
"H",
"hb"
],
"KI": [
"h",
"hb",
"H",
"hB"
],
"KM": [
"H",
"h",
"hB",
"hb"
],
"KN": [
"h",
"hb",
"H",
"hB"
],
"KP": [
"h",
"H",
"hB",
"hb"
],
"KR": [
"h",
"H",
"hB",
"hb"
],
"KW": [
"h",
"hB",
"hb",
"H"
],
"KY": [
"h",
"hb",
"H",
"hB"
],
"KZ": [
"H",
"hB"
],
"LA": [
"H",
"hb",
"hB",
"h"
],
"LB": [
"h",
"hB",
"hb",
"H"
],
"LC": [
"h",
"hb",
"H",
"hB"
],
"LI": [
"H",
"hB",
"h"
],
"LK": [
"H",
"h",
"hB",
"hb"
],
"LR": [
"h",
"hb",
"H",
"hB"
],
"LS": [
"h",
"H"
],
"LT": [
"H",
"h",
"hb",
"hB"
],
"LU": [
"H",
"h",
"hB"
],
"LV": [
"H",
"hB",
"hb",
"h"
],
"LY": [
"h",
"hB",
"hb",
"H"
],
"MA": [
"H",
"h",
"hB",
"hb"
],
"MC": [
"H",
"hB"
],
"MD": [
"H",
"hB"
],
"ME": [
"H",
"hB",
"h"
],
"MF": [
"H",
"hB"
],
"MH": [
"h",
"hb",
"H",
"hB"
],
"MK": [
"H",
"h",
"hb",
"hB"
],
"ML": [
"H"
],
"MM": [
"hB",
"hb",
"H",
"h"
],
"MN": [
"H",
"h",
"hb",
"hB"
],
"MO": [
"h",
"hB",
"hb",
"H"
],
"MP": [
"h",
"hb",
"H",
"hB"
],
"MQ": [
"H",
"hB"
],
"MR": [
"h",
"hB",
"hb",
"H"
],
"MS": [
"H",
"h",
"hb",
"hB"
],
"MW": [
"h",
"hb",
"H",
"hB"
],
"MX": [
"H",
"h",
"hB",
"hb"
],
"MY": [
"hb",
"hB",
"h",
"H"
],
"MZ": [
"H",
"hB"
],
"NA": [
"h",
"H",
"hB",
"hb"
],
"NC": [
"H",
"hB"
],
"NE": [
"H"
],
"NF": [
"H",
"h",
"hb",
"hB"
],
"NG": [
"H",
"h",
"hb",
"hB"
],
"NI": [
"H",
"h",
"hB",
"hb"
],
"NL": [
"H",
"hB"
],
"NP": [
"H",
"h",
"hB"
],
"NR": [
"H",
"h",
"hb",
"hB"
],
"NU": [
"H",
"h",
"hb",
"hB"
],
"NZ": [
"h",
"hb",
"H",
"hB"
],
"OM": [
"h",
"hB",
"hb",
"H"
],
"PA": [
"h",
"H",
"hB",
"hb"
],
"PE": [
"H",
"hB",
"h",
"hb"
],
"PF": [
"H",
"h",
"hB"
],
"PG": [
"h",
"H"
],
"PH": [
"h",
"hB",
"hb",
"H"
],
"PK": [
"h",
"hB",
"H"
],
"PM": [
"H",
"hB"
],
"PN": [
"H",
"h",
"hb",
"hB"
],
"PR": [
"h",
"H",
"hB",
"hb"
],
"PS": [
"h",
"hB",
"hb",
"H"
],
"PT": [
"H",
"hB"
],
"PW": [
"h",
"H"
],
"PY": [
"H",
"h",
"hB",
"hb"
],
"QA": [
"h",
"hB",
"hb",
"H"
],
"RE": [
"H",
"hB"
],
"RO": [
"H",
"hB"
],
"RS": [
"H",
"hB",
"h"
],
"RU": [
"H"
],
"SA": [
"h",
"hB",
"hb",
"H"
],
"SB": [
"h",
"hb",
"H",
"hB"
],
"SC": [
"H",
"h",
"hB"
],
"SD": [
"h",
"hB",
"hb",
"H"
],
"SE": [
"H"
],
"SG": [
"h",
"hb",
"H",
"hB"
],
"SH": [
"H",
"h",
"hb",
"hB"
],
"SI": [
"H",
"hB"
],
"SJ": [
"H"
],
"SK": [
"H"
],
"SL": [
"h",
"hb",
"H",
"hB"
],
"SM": [
"H",
"h",
"hB"
],
"SN": [
"H",
"h",
"hB"
],
"SO": [
"h",
"H"
],
"SR": [
"H",
"hB"
],
"SS": [
"h",
"hb",
"H",
"hB"
],
"ST": [
"H",
"hB"
],
"SV": [
"H",
"h",
"hB",
"hb"
],
"SX": [
"H",
"h",
"hb",
"hB"
],
"SY": [
"h",
"hB",
"hb",
"H"
],
"SZ": [
"h",
"hb",
"H",
"hB"
],
"TA": [
"H",
"h",
"hb",
"hB"
],
"TC": [
"h",
"hb",
"H",
"hB"
],
"TD": [
"h",
"H",
"hB"
],
"TF": [
"H",
"h",
"hB"
],
"TG": [
"H",
"hB"
],
"TL": [
"H",
"hB",
"hb",
"h"
],
"TN": [
"h",
"hB",
"hb",
"H"
],
"TO": [
"h",
"H"
],
"TR": [
"H",
"hB"
],
"TT": [
"h",
"hb",
"H",
"hB"
],
"TW": [
"hB",
"hb",
"h",
"H"
],
"TZ": [
"hB",
"hb",
"H",
"h"
],
"UA": [
"H",
"hB",
"h"
],
"UG": [
"hB",
"hb",
"H",
"h"
],
"UM": [
"h",
"hb",
"H",
"hB"
],
"US": [
"h",
"hb",
"H",
"hB"
],
"UY": [
"H",
"h",
"hB",
"hb"
],
"UZ": [
"H",
"hB",
"h"
],
"VA": [
"H",
"h",
"hB"
],
"VC": [
"h",
"hb",
"H",
"hB"
],
"VE": [
"h",
"H",
"hB",
"hb"
],
"VG": [
"h",
"hb",
"H",
"hB"
],
"VI": [
"h",
"hb",
"H",
"hB"
],
"VU": [
"h",
"H"
],
"WF": [
"H",
"hB"
],
"WS": [
"h",
"H"
],
"XK": [
"H",
"hB",
"h"
],
"YE": [
"h",
"hB",
"hb",
"H"
],
"YT": [
"H",
"hB"
],
"ZA": [
"H",
"h",
"hb",
"hB"
],
"ZM": [
"h",
"hb",
"H",
"hB"
],
"af-ZA": [
"H",
"h",
"hB",
"hb"
],
"ar-001": [
"h",
"hB",
"hb",
"H"
],
"ca-ES": [
"H",
"h",
"hB"
],
"en-001": [
"h",
"hb",
"H",
"hB"
],
"es-BO": [
"H",
"h",
"hB",
"hb"
],
"es-BR": [
"H",
"h",
"hB",
"hb"
],
"es-EC": [
"H",
"h",
"hB",
"hb"
],
"es-ES": [
"H",
"h",
"hB",
"hb"
],
"es-GQ": [
"H",
"h",
"hB",
"hb"
],
"es-PE": [
"H",
"h",
"hB",
"hb"
],
"fr-CA": [
"H",
"h",
"hB"
],
"gl-ES": [
"H",
"h",
"hB"
],
"gu-IN": [
"hB",
"hb",
"h",
"H"
],
"hi-IN": [
"hB",
"h",
"H"
],
"it-CH": [
"H",
"h",
"hB"
],
"it-IT": [
"H",
"h",
"hB"
],
"kn-IN": [
"hB",
"h",
"H"
],
"ml-IN": [
"hB",
"h",
"H"
],
"mr-IN": [
"hB",
"hb",
"h",
"H"
],
"pa-IN": [
"hB",
"hb",
"h",
"H"
],
"ta-IN": [
"hB",
"h",
"hb",
"H"
],
"te-IN": [
"hB",
"h",
"H"
],
"zu-ZA": [
"H",
"hB",
"hb",
"h"
]
};
/**
* Returns the best matching date time pattern if a date time skeleton
* pattern is provided with a locale. Follows the Unicode specification:
* https://www.unicode.org/reports/tr35/tr35-dates.html#table-mapping-requested-time-skeletons-to-patterns
* @param skeleton date time skeleton pattern that possibly includes j, J or C
* @param locale
*/
function getBestPattern(skeleton, locale) {
var skeletonCopy = '';
for (var patternPos = 0; patternPos < skeleton.length; patternPos++) {
var patternChar = skeleton.charAt(patternPos);
if (patternChar === 'j') {
var extraLength = 0;
while (patternPos + 1 < skeleton.length &&
skeleton.charAt(patternPos + 1) === patternChar) {
extraLength++;
patternPos++;
}
var hourLen = 1 + (extraLength & 1);
var dayPeriodLen = extraLength < 2 ? 1 : 3 + (extraLength >> 1);
var dayPeriodChar = 'a';
var hourChar = getDefaultHourSymbolFromLocale(locale);
if (hourChar == 'H' || hourChar == 'k') {
dayPeriodLen = 0;
}
while (dayPeriodLen-- > 0) {
skeletonCopy += dayPeriodChar;
}
while (hourLen-- > 0) {
skeletonCopy = hourChar + skeletonCopy;
}
}
else if (patternChar === 'J') {
skeletonCopy += 'H';
}
else {
skeletonCopy += patternChar;
}
}
return skeletonCopy;
}
/**
* Maps the [hour cycle type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle)
* of the given `locale` to the corresponding time pattern.
* @param locale
*/
function getDefaultHourSymbolFromLocale(locale) {
var hourCycle = locale.hourCycle;
if (hourCycle === undefined &&
// @ts-ignore hourCycle(s) is not identified yet
locale.hourCycles &&
// @ts-ignore
locale.hourCycles.length) {
// @ts-ignore
hourCycle = locale.hourCycles[0];
}
if (hourCycle) {
switch (hourCycle) {
case 'h24':
return 'k';
case 'h23':
return 'H';
case 'h12':
return 'h';
case 'h11':
return 'K';
default:
throw new Error('Invalid hourCycle');
}
}
// TODO: Once hourCycle is fully supported remove the following with data generation
var languageTag = locale.language;
var regionTag;
if (languageTag !== 'root') {
regionTag = locale.maximize().region;
}
var hourCycles = timeData[regionTag || ''] ||
timeData[languageTag || ''] ||
timeData["".concat(languageTag, "-001")] ||
timeData['001'];
return hourCycles[0];
}
var _a;
var SPACE_SEPARATOR_START_REGEX = new RegExp("^".concat(SPACE_SEPARATOR_REGEX.source, "*"));
var SPACE_SEPARATOR_END_REGEX = new RegExp("".concat(SPACE_SEPARATOR_REGEX.source, "*$"));
function createLocation(start, end) {
return { start: start, end: end };
}
// #region Ponyfills
// Consolidate these variables up top for easier toggling during debugging
var hasNativeStartsWith = !!String.prototype.startsWith && '_a'.startsWith('a', 1);
var hasNativeFromCodePoint = !!String.fromCodePoint;
var hasNativeFromEntries = !!Object.fromEntries;
var hasNativeCodePointAt = !!String.prototype.codePointAt;
var hasTrimStart = !!String.prototype.trimStart;
var hasTrimEnd = !!String.prototype.trimEnd;
var hasNativeIsSafeInteger = !!Number.isSafeInteger;
var isSafeInteger = hasNativeIsSafeInteger
? Number.isSafeInteger
: function (n) {
return (typeof n === 'number' &&
isFinite(n) &&
Math.floor(n) === n &&
Math.abs(n) <= 0x1fffffffffffff);
};
// IE11 does not support y and u.
var REGEX_SUPPORTS_U_AND_Y = true;
try {
var re = RE('([^\\p{White_Space}\\p{Pattern_Syntax}]*)', 'yu');
/**
* legacy Edge or Xbox One browser
* Unicode flag support: supported
* Pattern_Syntax support: not supported
* See https://github.com/formatjs/formatjs/issues/2822
*/
REGEX_SUPPORTS_U_AND_Y = ((_a = re.exec('a')) === null || _a === void 0 ? void 0 : _a[0]) === 'a';
}
catch (_) {
REGEX_SUPPORTS_U_AND_Y = false;
}
var startsWith = hasNativeStartsWith
? // Native
function startsWith(s, search, position) {
return s.startsWith(search, position);
}
: // For IE11
function startsWith(s, search, position) {
return s.slice(position, position + search.length) === search;
};
var fromCodePoint = hasNativeFromCodePoint
? String.fromCodePoint
: // IE11
function fromCodePoint() {
var codePoints = [];
for (var _i = 0; _i < arguments.length; _i++) {
codePoints[_i] = arguments[_i];
}
var elements = '';
var length = codePoints.length;
var i = 0;
var code;
while (length > i) {
code = codePoints[i++];
if (code > 0x10ffff)
throw RangeError(code + ' is not a valid code point');
elements +=
code < 0x10000
? String.fromCharCode(code)
: String.fromCharCode(((code -= 0x10000) >> 10) + 0xd800, (code % 0x400) + 0xdc00);
}
return elements;
};
var fromEntries =
// native
hasNativeFromEntries
? Object.fromEntries
: // Ponyfill
function fromEntries(entries) {
var obj = {};
for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
var _a = entries_1[_i], k = _a[0], v = _a[1];
obj[k] = v;
}
return obj;
};
var codePointAt = hasNativeCodePointAt
? // Native
function codePointAt(s, index) {
return s.codePointAt(index);
}
: // IE 11
function codePointAt(s, index) {
var size = s.length;
if (index < 0 || index >= size) {
return undefined;
}
var first = s.charCodeAt(index);
var second;
return first < 0xd800 ||
first > 0xdbff ||
index + 1 === size ||
(second = s.charCodeAt(index + 1)) < 0xdc00 ||
second > 0xdfff
? first
: ((first - 0xd800) << 10) + (second - 0xdc00) + 0x10000;
};
var trimStart = hasTrimStart
? // Native
function trimStart(s) {
return s.trimStart();
}
: // Ponyfill
function trimStart(s) {
return s.replace(SPACE_SEPARATOR_START_REGEX, '');
};
var trimEnd = hasTrimEnd
? // Native
function trimEnd(s) {
return s.trimEnd();
}
: // Ponyfill
function trimEnd(s) {
return s.replace(SPACE_SEPARATOR_END_REGEX, '');
};
// Prevent minifier to translate new RegExp to literal form that might cause syntax error on IE11.
function RE(s, flag) {
return new RegExp(s, flag);
}
// #endregion
var matchIdentifierAtIndex;
if (REGEX_SUPPORTS_U_AND_Y) {
// Native
var IDENTIFIER_PREFIX_RE_1 = RE('([^\\p{White_Space}\\p{Pattern_Syntax}]*)', 'yu');
matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {
var _a;
IDENTIFIER_PREFIX_RE_1.lastIndex = index;
var match = IDENTIFIER_PREFIX_RE_1.exec(s);
return (_a = match[1]) !== null && _a !== void 0 ? _a : '';
};
}
else {
// IE11
matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {
var match = [];
while (true) {
var c = codePointAt(s, index);
if (c === undefined || _isWhiteSpace(c) || _isPatternSyntax(c)) {
break;
}
match.push(c);
index += c >= 0x10000 ? 2 : 1;
}
return fromCodePoint.apply(void 0, match);
};
}
var Parser = /** @class */ (function () {
function Parser(message, options) {
if (options === void 0) { options = {}; }
this.message = message;
this.position = { offset: 0, line: 1, column: 1 };
this.ignoreTag = !!options.ignoreTag;
this.locale = options.locale;
this.requiresOtherClause = !!options.requiresOtherClause;
this.shouldParseSkeletons = !!options.shouldParseSkeletons;
}
Parser.prototype.parse = function () {
if (this.offset() !== 0) {
throw Error('parser can only be used once');
}
return this.parseMessage(0, '', false);
};
Parser.prototype.parseMessage = function (nestingLevel, parentArgType, expectingCloseTag) {
var elements = [];
while (!this.isEOF()) {
var char = this.char();
if (char === 123 /* `{` */) {
var result = this.parseArgument(nestingLevel, expectingCloseTag);
if (result.err) {
return result;
}
elements.push(result.val);
}
else if (char === 125 /* `}` */ && nestingLevel > 0) {
break;
}
else if (char === 35 /* `#` */ &&
(parentArgType === 'plural' || parentArgType === 'selectordinal')) {
var position = this.clonePosition();
this.bump();
elements.push({
type: TYPE.pound,
location: createLocation(position, this.clonePosition()),
});
}
else if (char === 60 /* `<` */ &&
!this.ignoreTag &&
this.peek() === 47 // char code for '/'
) {
if (expectingCloseTag) {
break;
}
else {
return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));
}
}
else if (char === 60 /* `<` */ &&
!this.ignoreTag &&
_isAlpha(this.peek() || 0)) {
var result = this.parseTag(nestingLevel, parentArgType);
if (result.err) {
return result;
}
elements.push(result.val);
}
else {
var result = this.parseLiteral(nestingLevel, parentArgType);
if (result.err) {
return result;
}
elements.push(result.val);
}
}
return { val: elements, err: null };
};
/**
* A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
* [custom element name][] except that a dash is NOT always mandatory and uppercase letters
* are accepted:
*
* ```
* tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message ""
* tagName ::= [a-z] (PENChar)*
* PENChar ::=
* "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
* [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
* [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
* ```
*
* [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
* NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
* since other tag-based engines like React allow it
*/
Parser.prototype.parseTag = function (nestingLevel, parentArgType) {
var startPosition = this.clonePosition();
this.bump(); // `<`
var tagName = this.parseTagName();
this.bumpSpace();
if (this.bumpIf('/>')) {
// Self closing tag
return {
val: {
type: TYPE.literal,
value: "<".concat(tagName, "/>"),
location: createLocation(startPosition, this.clonePosition()),
},
err: null,
};
}
else if (this.bumpIf('>')) {
var childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);
if (childrenResult.err) {
return childrenResult;
}
var children = childrenResult.val;
// Expecting a close tag
var endTagStartPosition = this.clonePosition();
if (this.bumpIf('')) {
return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
}
return {
val: {
type: TYPE.tag,
value: tagName,
children: children,
location: createLocation(startPosition, this.clonePosition()),
},
err: null,
};
}
else {
return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));
}
}
else {
return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));
}
};
/**
* This method assumes that the caller has peeked ahead for the first tag character.
*/
Parser.prototype.parseTagName = function () {
var startOffset = this.offset();
this.bump(); // the first tag name character
while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {
this.bump();
}
return this.message.slice(startOffset, this.offset());
};
Parser.prototype.parseLiteral = function (nestingLevel, parentArgType) {
var start = this.clonePosition();
var value = '';
while (true) {
var parseQuoteResult = this.tryParseQuote(parentArgType);
if (parseQuoteResult) {
value += parseQuoteResult;
continue;
}
var parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);
if (parseUnquotedResult) {
value += parseUnquotedResult;
continue;
}
var parseLeftAngleResult = this.tryParseLeftAngleBracket();
if (parseLeftAngleResult) {
value += parseLeftAngleResult;
continue;
}
break;
}
var location = createLocation(start, this.clonePosition());
return {
val: { type: TYPE.literal, value: value, location: location },
err: null,
};
};
Parser.prototype.tryParseLeftAngleBracket = function () {
if (!this.isEOF() &&
this.char() === 60 /* `<` */ &&
(this.ignoreTag ||
// If at the opening tag or closing tag position, bail.
!_isAlphaOrSlash(this.peek() || 0))) {
this.bump(); // `<`
return '<';
}
return null;
};
/**
* Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
* a character that requires quoting (that is, "only where needed"), and works the same in
* nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
*/
Parser.prototype.tryParseQuote = function (parentArgType) {
if (this.isEOF() || this.char() !== 39 /* `'` */) {
return null;
}
// Parse escaped char following the apostrophe, or early return if there is no escaped char.
// Check if is valid escaped character
switch (this.peek()) {
case 39 /* `'` */:
// double quote, should return as a single quote.
this.bump();
this.bump();
return "'";
// '{', '<', '>', '}'
case 123:
case 60:
case 62:
case 125:
break;
case 35: // '#'
if (parentArgType === 'plural' || parentArgType === 'selectordinal') {
break;
}
return null;
default:
return null;
}
this.bump(); // apostrophe
var codePoints = [this.char()]; // escaped char
this.bump();
// read chars until the optional closing apostrophe is found
while (!this.isEOF()) {
var ch = this.char();
if (ch === 39 /* `'` */) {
if (this.peek() === 39 /* `'` */) {
codePoints.push(39);
// Bump one more time because we need to skip 2 characters.
this.bump();
}
else {
// Optional closing apostrophe.
this.bump();
break;
}
}
else {
codePoints.push(ch);
}
this.bump();
}
return fromCodePoint.apply(void 0, codePoints);
};
Parser.prototype.tryParseUnquoted = function (nestingLevel, parentArgType) {
if (this.isEOF()) {
return null;
}
var ch = this.char();
if (ch === 60 /* `<` */ ||
ch === 123 /* `{` */ ||
(ch === 35 /* `#` */ &&
(parentArgType === 'plural' || parentArgType === 'selectordinal')) ||
(ch === 125 /* `}` */ && nestingLevel > 0)) {
return null;
}
else {
this.bump();
return fromCodePoint(ch);
}
};
Parser.prototype.parseArgument = function (nestingLevel, expectingCloseTag) {
var openingBracePosition = this.clonePosition();
this.bump(); // `{`
this.bumpSpace();
if (this.isEOF()) {
return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
}
if (this.char() === 125 /* `}` */) {
this.bump();
return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
}
// argument name
var value = this.parseIdentifierIfPossible().value;
if (!value) {
return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
}
this.bumpSpace();
if (this.isEOF()) {
return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
}
switch (this.char()) {
// Simple argument: `{name}`
case 125 /* `}` */: {
this.bump(); // `}`
return {
val: {
type: TYPE.argument,
// value does not include the opening and closing braces.
value: value,
location: createLocation(openingBracePosition, this.clonePosition()),
},
err: null,
};
}
// Argument with options: `{name, format, ...}`
case 44 /* `,` */: {
this.bump(); // `,`
this.bumpSpace();
if (this.isEOF()) {
return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
}
return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);
}
default:
return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
}
};
/**
* Advance the parser until the end of the identifier, if it is currently on
* an identifier character. Return an empty string otherwise.
*/
Parser.prototype.parseIdentifierIfPossible = function () {
var startingPosition = this.clonePosition();
var startOffset = this.offset();
var value = matchIdentifierAtIndex(this.message, startOffset);
var endOffset = startOffset + value.length;
this.bumpTo(endOffset);
var endPosition = this.clonePosition();
var location = createLocation(startingPosition, endPosition);
return { value: value, location: location };
};
Parser.prototype.parseArgumentOptions = function (nestingLevel, expectingCloseTag, value, openingBracePosition) {
var _a;
// Parse this range:
// {name, type, style}
// ^---^
var typeStartPosition = this.clonePosition();
var argType = this.parseIdentifierIfPossible().value;
var typeEndPosition = this.clonePosition();
switch (argType) {
case '':
// Expecting a style string number, date, time, plural, selectordinal, or select.
return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
case 'number':
case 'date':
case 'time': {
// Parse this range:
// {name, number, style}
// ^-------^
this.bumpSpace();
var styleAndLocation = null;
if (this.bumpIf(',')) {
this.bumpSpace();
var styleStartPosition = this.clonePosition();
var result = this.parseSimpleArgStyleIfPossible();
if (result.err) {
return result;
}
var style = trimEnd(result.val);
if (style.length === 0) {
return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));
}
var styleLocation = createLocation(styleStartPosition, this.clonePosition());
styleAndLocation = { style: style, styleLocation: styleLocation };
}
var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
if (argCloseResult.err) {
return argCloseResult;
}
var location_1 = createLocation(openingBracePosition, this.clonePosition());
// Extract style or skeleton
if (styleAndLocation && startsWith(styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style, '::', 0)) {
// Skeleton starts with `::`.
var skeleton = trimStart(styleAndLocation.style.slice(2));
if (argType === 'number') {
var result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);
if (result.err) {
return result;
}
return {
val: { type: TYPE.number, value: value, location: location_1, style: result.val },
err: null,
};
}
else {
if (skeleton.length === 0) {
return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);
}
var dateTimePattern = skeleton;
// Get "best match" pattern only if locale is passed, if not, let it
// pass as-is where `parseDateTimeSkeleton()` will throw an error
// for unsupported patterns.
if (this.locale) {
dateTimePattern = getBestPattern(skeleton, this.locale);
}
var style = {
type: SKELETON_TYPE.dateTime,
pattern: dateTimePattern,
location: styleAndLocation.styleLocation,
parsedOptions: this.shouldParseSkeletons
? parseDateTimeSkeleton(dateTimePattern)
: {},
};
var type = argType === 'date' ? TYPE.date : TYPE.time;
return {
val: { type: type, value: value, location: location_1, style: style },
err: null,
};
}
}
// Regular style or no style.
return {
val: {
type: argType === 'number'
? TYPE.number
: argType === 'date'
? TYPE.date
: TYPE.time,
value: value,
location: location_1,
style: (_a = styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style) !== null && _a !== void 0 ? _a : null,
},
err: null,
};
}
case 'plural':
case 'selectordinal':
case 'select': {
// Parse this range:
// {name, plural, options}
// ^---------^
var typeEndPosition_1 = this.clonePosition();
this.bumpSpace();
if (!this.bumpIf(',')) {
return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition_1, __assign({}, typeEndPosition_1)));
}
this.bumpSpace();
// Parse offset:
// {name, plural, offset:1, options}
// ^-----^
//
// or the first option:
//
// {name, plural, one {...} other {...}}
// ^--^
var identifierAndLocation = this.parseIdentifierIfPossible();
var pluralOffset = 0;
if (argType !== 'select' && identifierAndLocation.value === 'offset') {
if (!this.bumpIf(':')) {
return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));
}
this.bumpSpace();
var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);
if (result.err) {
return result;
}
// Parse another identifier for option parsing
this.bumpSpace();
identifierAndLocation = this.parseIdentifierIfPossible();
pluralOffset = result.val;
}
var optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);
if (optionsResult.err) {
return optionsResult;
}
var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
if (argCloseResult.err) {
return argCloseResult;
}
var location_2 = createLocation(openingBracePosition, this.clonePosition());
if (argType === 'select') {
return {
val: {
type: TYPE.select,
value: value,
options: fromEntries(optionsResult.val),
location: location_2,
},
err: null,
};
}
else {
return {
val: {
type: TYPE.plural,
value: value,
options: fromEntries(optionsResult.val),
offset: pluralOffset,
pluralType: argType === 'plural' ? 'cardinal' : 'ordinal',
location: location_2,
},
err: null,
};
}
}
default:
return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
}
};
Parser.prototype.tryParseArgumentClose = function (openingBracePosition) {
// Parse: {value, number, ::currency/GBP }
//
if (this.isEOF() || this.char() !== 125 /* `}` */) {
return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
}
this.bump(); // `}`
return { val: true, err: null };
};
/**
* See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
*/
Parser.prototype.parseSimpleArgStyleIfPossible = function () {
var nestedBraces = 0;
var startPosition = this.clonePosition();
while (!this.isEOF()) {
var ch = this.char();
switch (ch) {
case 39 /* `'` */: {
// Treat apostrophe as quoting but include it in the style part.
// Find the end of the quoted literal text.
this.bump();
var apostrophePosition = this.clonePosition();
if (!this.bumpUntil("'")) {
return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));
}
this.bump();
break;
}
case 123 /* `{` */: {
nestedBraces += 1;
this.bump();
break;
}
case 125 /* `}` */: {
if (nestedBraces > 0) {
nestedBraces -= 1;
}
else {
return {
val: this.message.slice(startPosition.offset, this.offset()),
err: null,
};
}
break;
}
default:
this.bump();
break;
}
}
return {
val: this.message.slice(startPosition.offset, this.offset()),
err: null,
};
};
Parser.prototype.parseNumberSkeletonFromString = function (skeleton, location) {
var tokens = [];
try {
tokens = parseNumberSkeletonFromString(skeleton);
}
catch (e) {
return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);
}
return {
val: {
type: SKELETON_TYPE.number,
tokens: tokens,
location: location,
parsedOptions: this.shouldParseSkeletons
? parseNumberSkeleton(tokens)
: {},
},
err: null,
};
};
/**
* @param nesting_level The current nesting level of messages.
* This can be positive when parsing message fragment in select or plural argument options.
* @param parent_arg_type The parent argument's type.
* @param parsed_first_identifier If provided, this is the first identifier-like selector of
* the argument. It is a by-product of a previous parsing attempt.
* @param expecting_close_tag If true, this message is directly or indirectly nested inside
* between a pair of opening and closing tags. The nested message will not parse beyond
* the closing tag boundary.
*/
Parser.prototype.tryParsePluralOrSelectOptions = function (nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {
var _a;
var hasOtherClause = false;
var options = [];
var parsedSelectors = new Set();
var selector = parsedFirstIdentifier.value, selectorLocation = parsedFirstIdentifier.location;
// Parse:
// one {one apple}
// ^--^
while (true) {
if (selector.length === 0) {
var startPosition = this.clonePosition();
if (parentArgType !== 'select' && this.bumpIf('=')) {
// Try parse `={number}` selector
var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);
if (result.err) {
return result;
}
selectorLocation = createLocation(startPosition, this.clonePosition());
selector = this.message.slice(startPosition.offset, this.offset());
}
else {
break;
}
}
// Duplicate selector clauses
if (parsedSelectors.has(selector)) {
return this.error(parentArgType === 'select'
? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR
: ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);
}
if (selector === 'other') {
hasOtherClause = true;
}
// Parse:
// one {one apple}
// ^----------^
this.bumpSpace();
var openingBracePosition = this.clonePosition();
if (!this.bumpIf('{')) {
return this.error(parentArgType === 'select'
? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT
: ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));
}
var fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);
if (fragmentResult.err) {
return fragmentResult;
}
var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
if (argCloseResult.err) {
return argCloseResult;
}
options.push([
selector,
{
value: fragmentResult.val,
location: createLocation(openingBracePosition, this.clonePosition()),
},
]);
// Keep track of the existing selectors
parsedSelectors.add(selector);
// Prep next selector clause.
this.bumpSpace();
(_a = this.parseIdentifierIfPossible(), selector = _a.value, selectorLocation = _a.location);
}
if (options.length === 0) {
return this.error(parentArgType === 'select'
? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR
: ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));
}
if (this.requiresOtherClause && !hasOtherClause) {
return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));
}
return { val: options, err: null };
};
Parser.prototype.tryParseDecimalInteger = function (expectNumberError, invalidNumberError) {
var sign = 1;
var startingPosition = this.clonePosition();
if (this.bumpIf('+')) ;
else if (this.bumpIf('-')) {
sign = -1;
}
var hasDigits = false;
var decimal = 0;
while (!this.isEOF()) {
var ch = this.char();
if (ch >= 48 /* `0` */ && ch <= 57 /* `9` */) {
hasDigits = true;
decimal = decimal * 10 + (ch - 48);
this.bump();
}
else {
break;
}
}
var location = createLocation(startingPosition, this.clonePosition());
if (!hasDigits) {
return this.error(expectNumberError, location);
}
decimal *= sign;
if (!isSafeInteger(decimal)) {
return this.error(invalidNumberError, location);
}
return { val: decimal, err: null };
};
Parser.prototype.offset = function () {
return this.position.offset;
};
Parser.prototype.isEOF = function () {
return this.offset() === this.message.length;
};
Parser.prototype.clonePosition = function () {
// This is much faster than `Object.assign` or spread.
return {
offset: this.position.offset,
line: this.position.line,
column: this.position.column,
};
};
/**
* Return the code point at the current position of the parser.
* Throws if the index is out of bound.
*/
Parser.prototype.char = function () {
var offset = this.position.offset;
if (offset >= this.message.length) {
throw Error('out of bound');
}
var code = codePointAt(this.message, offset);
if (code === undefined) {
throw Error("Offset ".concat(offset, " is at invalid UTF-16 code unit boundary"));
}
return code;
};
Parser.prototype.error = function (kind, location) {
return {
val: null,
err: {
kind: kind,
message: this.message,
location: location,
},
};
};
/** Bump the parser to the next UTF-16 code unit. */
Parser.prototype.bump = function () {
if (this.isEOF()) {
return;
}
var code = this.char();
if (code === 10 /* '\n' */) {
this.position.line += 1;
this.position.column = 1;
this.position.offset += 1;
}
else {
this.position.column += 1;
// 0 ~ 0x10000 -> unicode BMP, otherwise skip the surrogate pair.
this.position.offset += code < 0x10000 ? 1 : 2;
}
};
/**
* If the substring starting at the current position of the parser has
* the given prefix, then bump the parser to the character immediately
* following the prefix and return true. Otherwise, don't bump the parser
* and return false.
*/
Parser.prototype.bumpIf = function (prefix) {
if (startsWith(this.message, prefix, this.offset())) {
for (var i = 0; i < prefix.length; i++) {
this.bump();
}
return true;
}
return false;
};
/**
* Bump the parser until the pattern character is found and return `true`.
* Otherwise bump to the end of the file and return `false`.
*/
Parser.prototype.bumpUntil = function (pattern) {
var currentOffset = this.offset();
var index = this.message.indexOf(pattern, currentOffset);
if (index >= 0) {
this.bumpTo(index);
return true;
}
else {
this.bumpTo(this.message.length);
return false;
}
};
/**
* Bump the parser to the target offset.
* If target offset is beyond the end of the input, bump the parser to the end of the input.
*/
Parser.prototype.bumpTo = function (targetOffset) {
if (this.offset() > targetOffset) {
throw Error("targetOffset ".concat(targetOffset, " must be greater than or equal to the current offset ").concat(this.offset()));
}
targetOffset = Math.min(targetOffset, this.message.length);
while (true) {
var offset = this.offset();
if (offset === targetOffset) {
break;
}
if (offset > targetOffset) {
throw Error("targetOffset ".concat(targetOffset, " is at invalid UTF-16 code unit boundary"));
}
this.bump();
if (this.isEOF()) {
break;
}
}
};
/** advance the parser through all whitespace to the next non-whitespace code unit. */
Parser.prototype.bumpSpace = function () {
while (!this.isEOF() && _isWhiteSpace(this.char())) {
this.bump();
}
};
/**
* Peek at the *next* Unicode codepoint in the input without advancing the parser.
* If the input has been exhausted, then this returns null.
*/
Parser.prototype.peek = function () {
if (this.isEOF()) {
return null;
}
var code = this.char();
var offset = this.offset();
var nextCode = this.message.charCodeAt(offset + (code >= 0x10000 ? 2 : 1));
return nextCode !== null && nextCode !== void 0 ? nextCode : null;
};
return Parser;
}());
/**
* This check if codepoint is alphabet (lower & uppercase)
* @param codepoint
* @returns
*/
function _isAlpha(codepoint) {
return ((codepoint >= 97 && codepoint <= 122) ||
(codepoint >= 65 && codepoint <= 90));
}
function _isAlphaOrSlash(codepoint) {
return _isAlpha(codepoint) || codepoint === 47; /* '/' */
}
/** See `parseTag` function docs. */
function _isPotentialElementNameChar(c) {
return (c === 45 /* '-' */ ||
c === 46 /* '.' */ ||
(c >= 48 && c <= 57) /* 0..9 */ ||
c === 95 /* '_' */ ||
(c >= 97 && c <= 122) /** a..z */ ||
(c >= 65 && c <= 90) /* A..Z */ ||
c == 0xb7 ||
(c >= 0xc0 && c <= 0xd6) ||
(c >= 0xd8 && c <= 0xf6) ||
(c >= 0xf8 && c <= 0x37d) ||
(c >= 0x37f && c <= 0x1fff) ||
(c >= 0x200c && c <= 0x200d) ||
(c >= 0x203f && c <= 0x2040) ||
(c >= 0x2070 && c <= 0x218f) ||
(c >= 0x2c00 && c <= 0x2fef) ||
(c >= 0x3001 && c <= 0xd7ff) ||
(c >= 0xf900 && c <= 0xfdcf) ||
(c >= 0xfdf0 && c <= 0xfffd) ||
(c >= 0x10000 && c <= 0xeffff));
}
/**
* Code point equivalent of regex `\p{White_Space}`.
* From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
*/
function _isWhiteSpace(c) {
return ((c >= 0x0009 && c <= 0x000d) ||
c === 0x0020 ||
c === 0x0085 ||
(c >= 0x200e && c <= 0x200f) ||
c === 0x2028 ||
c === 0x2029);
}
/**
* Code point equivalent of regex `\p{Pattern_Syntax}`.
* See https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
*/
function _isPatternSyntax(c) {
return ((c >= 0x0021 && c <= 0x0023) ||
c === 0x0024 ||
(c >= 0x0025 && c <= 0x0027) ||
c === 0x0028 ||
c === 0x0029 ||
c === 0x002a ||
c === 0x002b ||
c === 0x002c ||
c === 0x002d ||
(c >= 0x002e && c <= 0x002f) ||
(c >= 0x003a && c <= 0x003b) ||
(c >= 0x003c && c <= 0x003e) ||
(c >= 0x003f && c <= 0x0040) ||
c === 0x005b ||
c === 0x005c ||
c === 0x005d ||
c === 0x005e ||
c === 0x0060 ||
c === 0x007b ||
c === 0x007c ||
c === 0x007d ||
c === 0x007e ||
c === 0x00a1 ||
(c >= 0x00a2 && c <= 0x00a5) ||
c === 0x00a6 ||
c === 0x00a7 ||
c === 0x00a9 ||
c === 0x00ab ||
c === 0x00ac ||
c === 0x00ae ||
c === 0x00b0 ||
c === 0x00b1 ||
c === 0x00b6 ||
c === 0x00bb ||
c === 0x00bf ||
c === 0x00d7 ||
c === 0x00f7 ||
(c >= 0x2010 && c <= 0x2015) ||
(c >= 0x2016 && c <= 0x2017) ||
c === 0x2018 ||
c === 0x2019 ||
c === 0x201a ||
(c >= 0x201b && c <= 0x201c) ||
c === 0x201d ||
c === 0x201e ||
c === 0x201f ||
(c >= 0x2020 && c <= 0x2027) ||
(c >= 0x2030 && c <= 0x2038) ||
c === 0x2039 ||
c === 0x203a ||
(c >= 0x203b && c <= 0x203e) ||
(c >= 0x2041 && c <= 0x2043) ||
c === 0x2044 ||
c === 0x2045 ||
c === 0x2046 ||
(c >= 0x2047 && c <= 0x2051) ||
c === 0x2052 ||
c === 0x2053 ||
(c >= 0x2055 && c <= 0x205e) ||
(c >= 0x2190 && c <= 0x2194) ||
(c >= 0x2195 && c <= 0x2199) ||
(c >= 0x219a && c <= 0x219b) ||
(c >= 0x219c && c <= 0x219f) ||
c === 0x21a0 ||
(c >= 0x21a1 && c <= 0x21a2) ||
c === 0x21a3 ||
(c >= 0x21a4 && c <= 0x21a5) ||
c === 0x21a6 ||
(c >= 0x21a7 && c <= 0x21ad) ||
c === 0x21ae ||
(c >= 0x21af && c <= 0x21cd) ||
(c >= 0x21ce && c <= 0x21cf) ||
(c >= 0x21d0 && c <= 0x21d1) ||
c === 0x21d2 ||
c === 0x21d3 ||
c === 0x21d4 ||
(c >= 0x21d5 && c <= 0x21f3) ||
(c >= 0x21f4 && c <= 0x22ff) ||
(c >= 0x2300 && c <= 0x2307) ||
c === 0x2308 ||
c === 0x2309 ||
c === 0x230a ||
c === 0x230b ||
(c >= 0x230c && c <= 0x231f) ||
(c >= 0x2320 && c <= 0x2321) ||
(c >= 0x2322 && c <= 0x2328) ||
c === 0x2329 ||
c === 0x232a ||
(c >= 0x232b && c <= 0x237b) ||
c === 0x237c ||
(c >= 0x237d && c <= 0x239a) ||
(c >= 0x239b && c <= 0x23b3) ||
(c >= 0x23b4 && c <= 0x23db) ||
(c >= 0x23dc && c <= 0x23e1) ||
(c >= 0x23e2 && c <= 0x2426) ||
(c >= 0x2427 && c <= 0x243f) ||
(c >= 0x2440 && c <= 0x244a) ||
(c >= 0x244b && c <= 0x245f) ||
(c >= 0x2500 && c <= 0x25b6) ||
c === 0x25b7 ||
(c >= 0x25b8 && c <= 0x25c0) ||
c === 0x25c1 ||
(c >= 0x25c2 && c <= 0x25f7) ||
(c >= 0x25f8 && c <= 0x25ff) ||
(c >= 0x2600 && c <= 0x266e) ||
c === 0x266f ||
(c >= 0x2670 && c <= 0x2767) ||
c === 0x2768 ||
c === 0x2769 ||
c === 0x276a ||
c === 0x276b ||
c === 0x276c ||
c === 0x276d ||
c === 0x276e ||
c === 0x276f ||
c === 0x2770 ||
c === 0x2771 ||
c === 0x2772 ||
c === 0x2773 ||
c === 0x2774 ||
c === 0x2775 ||
(c >= 0x2794 && c <= 0x27bf) ||
(c >= 0x27c0 && c <= 0x27c4) ||
c === 0x27c5 ||
c === 0x27c6 ||
(c >= 0x27c7 && c <= 0x27e5) ||
c === 0x27e6 ||
c === 0x27e7 ||
c === 0x27e8 ||
c === 0x27e9 ||
c === 0x27ea ||
c === 0x27eb ||
c === 0x27ec ||
c === 0x27ed ||
c === 0x27ee ||
c === 0x27ef ||
(c >= 0x27f0 && c <= 0x27ff) ||
(c >= 0x2800 && c <= 0x28ff) ||
(c >= 0x2900 && c <= 0x2982) ||
c === 0x2983 ||
c === 0x2984 ||
c === 0x2985 ||
c === 0x2986 ||
c === 0x2987 ||
c === 0x2988 ||
c === 0x2989 ||
c === 0x298a ||
c === 0x298b ||
c === 0x298c ||
c === 0x298d ||
c === 0x298e ||
c === 0x298f ||
c === 0x2990 ||
c === 0x2991 ||
c === 0x2992 ||
c === 0x2993 ||
c === 0x2994 ||
c === 0x2995 ||
c === 0x2996 ||
c === 0x2997 ||
c === 0x2998 ||
(c >= 0x2999 && c <= 0x29d7) ||
c === 0x29d8 ||
c === 0x29d9 ||
c === 0x29da ||
c === 0x29db ||
(c >= 0x29dc && c <= 0x29fb) ||
c === 0x29fc ||
c === 0x29fd ||
(c >= 0x29fe && c <= 0x2aff) ||
(c >= 0x2b00 && c <= 0x2b2f) ||
(c >= 0x2b30 && c <= 0x2b44) ||
(c >= 0x2b45 && c <= 0x2b46) ||
(c >= 0x2b47 && c <= 0x2b4c) ||
(c >= 0x2b4d && c <= 0x2b73) ||
(c >= 0x2b74 && c <= 0x2b75) ||
(c >= 0x2b76 && c <= 0x2b95) ||
c === 0x2b96 ||
(c >= 0x2b97 && c <= 0x2bff) ||
(c >= 0x2e00 && c <= 0x2e01) ||
c === 0x2e02 ||
c === 0x2e03 ||
c === 0x2e04 ||
c === 0x2e05 ||
(c >= 0x2e06 && c <= 0x2e08) ||
c === 0x2e09 ||
c === 0x2e0a ||
c === 0x2e0b ||
c === 0x2e0c ||
c === 0x2e0d ||
(c >= 0x2e0e && c <= 0x2e16) ||
c === 0x2e17 ||
(c >= 0x2e18 && c <= 0x2e19) ||
c === 0x2e1a ||
c === 0x2e1b ||
c === 0x2e1c ||
c === 0x2e1d ||
(c >= 0x2e1e && c <= 0x2e1f) ||
c === 0x2e20 ||
c === 0x2e21 ||
c === 0x2e22 ||
c === 0x2e23 ||
c === 0x2e24 ||
c === 0x2e25 ||
c === 0x2e26 ||
c === 0x2e27 ||
c === 0x2e28 ||
c === 0x2e29 ||
(c >= 0x2e2a && c <= 0x2e2e) ||
c === 0x2e2f ||
(c >= 0x2e30 && c <= 0x2e39) ||
(c >= 0x2e3a && c <= 0x2e3b) ||
(c >= 0x2e3c && c <= 0x2e3f) ||
c === 0x2e40 ||
c === 0x2e41 ||
c === 0x2e42 ||
(c >= 0x2e43 && c <= 0x2e4f) ||
(c >= 0x2e50 && c <= 0x2e51) ||
c === 0x2e52 ||
(c >= 0x2e53 && c <= 0x2e7f) ||
(c >= 0x3001 && c <= 0x3003) ||
c === 0x3008 ||
c === 0x3009 ||
c === 0x300a ||
c === 0x300b ||
c === 0x300c ||
c === 0x300d ||
c === 0x300e ||
c === 0x300f ||
c === 0x3010 ||
c === 0x3011 ||
(c >= 0x3012 && c <= 0x3013) ||
c === 0x3014 ||
c === 0x3015 ||
c === 0x3016 ||
c === 0x3017 ||
c === 0x3018 ||
c === 0x3019 ||
c === 0x301a ||
c === 0x301b ||
c === 0x301c ||
c === 0x301d ||
(c >= 0x301e && c <= 0x301f) ||
c === 0x3020 ||
c === 0x3030 ||
c === 0xfd3e ||
c === 0xfd3f ||
(c >= 0xfe45 && c <= 0xfe46));
}
function pruneLocation(els) {
els.forEach(function (el) {
delete el.location;
if (isSelectElement(el) || isPluralElement(el)) {
for (var k in el.options) {
delete el.options[k].location;
pruneLocation(el.options[k].value);
}
}
else if (isNumberElement(el) && isNumberSkeleton(el.style)) {
delete el.style.location;
}
else if ((isDateElement(el) || isTimeElement(el)) &&
isDateTimeSkeleton(el.style)) {
delete el.style.location;
}
else if (isTagElement(el)) {
pruneLocation(el.children);
}
});
}
function parse(message, opts) {
if (opts === void 0) { opts = {}; }
opts = __assign({ shouldParseSkeletons: true, requiresOtherClause: true }, opts);
var result = new Parser(message, opts).parse();
if (result.err) {
var error = SyntaxError(ErrorKind[result.err.kind]);
// @ts-expect-error Assign to error object
error.location = result.err.location;
// @ts-expect-error Assign to error object
error.originalMessage = result.err.message;
throw error;
}
if (!(opts === null || opts === void 0 ? void 0 : opts.captureLocation)) {
pruneLocation(result.val);
}
return result.val;
}
function sanitizeInputText(text, ignoreTransTag) {
if (!ignoreTransTag) {
return text;
}
// The regex matches <0><1><2> etc
return text.replace(/<\/?(\d+)>/g, function (match, number) {
// As both & are matched
// With the split we retrieve either < or ");
});
}
function sanitizeOutputText(text, ignoreTransTag) {
if (!ignoreTransTag) {
return text;
}
// The regex matches etc
return text.replace(/<\/?Trans(\d+)>/g, function (match, number) {
// As both & are matched
// With the split we retrieve either < or ");
});
}
function isStringValidationResult(obj) {
return (obj !== null && typeof obj === 'object' && '__icu_validator_error' in obj);
}
function isInvalidAtAnyLevel(obj, key) {
for (var prop in obj) {
if (obj.hasOwnProperty(prop)) {
if (prop === key && obj[prop] === true) {
return true;
}
if (typeof obj[prop] === 'object' && obj[prop] !== null) {
// Recursively check the nested object
if (isInvalidAtAnyLevel(obj[prop], key)) {
return true; // Key found and its value is true in the nested object
}
}
}
}
return false; // Key not found or its value is not true at any level
}
function validateString(text, options, ignoreTransTag) {
if (ignoreTransTag === void 0) { ignoreTransTag = false; }
try {
// Try to parse the string using format js parser after input sanitization
// If successful then it's a valid ICU string
parse(sanitizeInputText(text, ignoreTransTag), options);
return {
__icu_validator_error: false
};
}
catch (error) {
// @ts-expect-error
var _a = error, message = _a.message, location_1 = _a.location;
return {
__icu_validator_error: true,
result: {
errorMessage: message,
originalMessage: sanitizeOutputText(text, ignoreTransTag),
location: location_1
}
};
}
}
function validateObject(source, options, ignoreTransTag) {
if (ignoreTransTag === void 0) { ignoreTransTag = false; }
if (typeof source === 'object') {
var transformedObj = {};
for (var _i = 0, _a = Object.entries(source); _i < _a.length; _i++) {
var _b = _a[_i], key = _b[0], value = _b[1];
transformedObj[key] = validateObject(value, options, ignoreTransTag);
}
return transformedObj;
}
else if (typeof source === 'string') {
return validateString(source, options, ignoreTransTag);
}
else {
throw new Error('Translation source must either be string or an object');
}
}
function validateJsonFileSync(filePath, options, ignoreTransTag) {
if (ignoreTransTag === void 0) { ignoreTransTag = false; }
if (!filePath.endsWith('.json')) {
throw new Error('Only JSON file can be validated');
}
var fileContent = fs.readFileSync(filePath, 'utf8');
var validationResult = validateObject(JSON.parse(fileContent), options, ignoreTransTag);
return {
isValid: !isInvalidAtAnyLevel(validationResult, '__icu_validator_error'),
fileName: filePath,
validationResult: validationResult
};
}
function validateJsonFile(filePath, options, ignoreTransTag) {
if (ignoreTransTag === void 0) { ignoreTransTag = false; }
return __awaiter(this, void 0, void 0, function () {
var fileContent, validationResult;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!filePath.endsWith('.json')) {
throw new Error('Only JSON file can be validated');
}
return [4 /*yield*/, promises.readFile(filePath, 'utf8')];
case 1:
fileContent = _a.sent();
validationResult = validateObject(JSON.parse(fileContent), options, ignoreTransTag);
return [2 /*return*/, {
isValid: !isInvalidAtAnyLevel(validationResult, '__icu_validator_error'),
fileName: filePath,
validationResult: validationResult
}];
}
});
});
}
function validateDirectorySync(directoryPath, options, ignoreTransTag) {
if (ignoreTransTag === void 0) { ignoreTransTag = false; }
var files = fs.readdirSync(directoryPath, 'utf8').filter(function (file) {
return file.endsWith('.json');
});
return files.map(function (file) {
return validateJsonFileSync(path.resolve(directoryPath, file), options, ignoreTransTag);
});
}
function validateDirectory$1(directoryPath, options, ignoreTransTag) {
if (ignoreTransTag === void 0) { ignoreTransTag = false; }
return __awaiter(this, void 0, void 0, function () {
var files;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, promises.readdir(directoryPath, 'utf8')];
case 1:
files = _a.sent();
return [2 /*return*/, Promise.all(files
.filter(function (file) { return file.endsWith('.json'); })
.map(function (file) {
return validateJsonFile(path.resolve(directoryPath, file), options, ignoreTransTag);
}))];
}
});
});
}
let FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, isTTY=true;
if (typeof process !== 'undefined') {
({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
isTTY = process.stdout && process.stdout.isTTY;
}
const $ = {
enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== 'dumb' && (
FORCE_COLOR != null && FORCE_COLOR !== '0' || isTTY
),
// modifiers
reset: init(0, 0),
bold: init(1, 22),
dim: init(2, 22),
italic: init(3, 23),
underline: init(4, 24),
inverse: init(7, 27),
hidden: init(8, 28),
strikethrough: init(9, 29),
// colors
black: init(30, 39),
red: init(31, 39),
green: init(32, 39),
yellow: init(33, 39),
blue: init(34, 39),
magenta: init(35, 39),
cyan: init(36, 39),
white: init(37, 39),
gray: init(90, 39),
grey: init(90, 39),
// background colors
bgBlack: init(40, 49),
bgRed: init(41, 49),
bgGreen: init(42, 49),
bgYellow: init(43, 49),
bgBlue: init(44, 49),
bgMagenta: init(45, 49),
bgCyan: init(46, 49),
bgWhite: init(47, 49)
};
function run(arr, str) {
let i=0, tmp, beg='', end='';
for (; i < arr.length; i++) {
tmp = arr[i];
beg += tmp.open;
end += tmp.close;
if (!!~str.indexOf(tmp.close)) {
str = str.replace(tmp.rgx, tmp.close + tmp.open);
}
}
return beg + str + end;
}
function chain(has, keys) {
let ctx = { has, keys };
ctx.reset = $.reset.bind(ctx);
ctx.bold = $.bold.bind(ctx);
ctx.dim = $.dim.bind(ctx);
ctx.italic = $.italic.bind(ctx);
ctx.underline = $.underline.bind(ctx);
ctx.inverse = $.inverse.bind(ctx);
ctx.hidden = $.hidden.bind(ctx);
ctx.strikethrough = $.strikethrough.bind(ctx);
ctx.black = $.black.bind(ctx);
ctx.red = $.red.bind(ctx);
ctx.green = $.green.bind(ctx);
ctx.yellow = $.yellow.bind(ctx);
ctx.blue = $.blue.bind(ctx);
ctx.magenta = $.magenta.bind(ctx);
ctx.cyan = $.cyan.bind(ctx);
ctx.white = $.white.bind(ctx);
ctx.gray = $.gray.bind(ctx);
ctx.grey = $.grey.bind(ctx);
ctx.bgBlack = $.bgBlack.bind(ctx);
ctx.bgRed = $.bgRed.bind(ctx);
ctx.bgGreen = $.bgGreen.bind(ctx);
ctx.bgYellow = $.bgYellow.bind(ctx);
ctx.bgBlue = $.bgBlue.bind(ctx);
ctx.bgMagenta = $.bgMagenta.bind(ctx);
ctx.bgCyan = $.bgCyan.bind(ctx);
ctx.bgWhite = $.bgWhite.bind(ctx);
return ctx;
}
function init(open, close) {
let blk = {
open: `\x1b[${open}m`,
close: `\x1b[${close}m`,
rgx: new RegExp(`\\x1b\\[${close}m`, 'g')
};
return function (txt) {
if (this !== void 0 && this.has !== void 0) {
!!~this.has.indexOf(open) || (this.has.push(open),this.keys.push(blk));
return txt === void 0 ? this : $.enabled ? run(this.keys, txt+'') : txt+'';
}
return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt+'') : txt+'';
};
}
function printStringValidation(text, validationResult) {
if (!validationResult.__icu_validator_error) {
console.log($.green("Valid ICU string :- ".concat(text)));
return;
}
console.log($.bgRed("Invalid ICU string :- ".concat(text)));
if (validationResult.result) {
console.log("Error :- ".concat($.red(validationResult.result.errorMessage)));
console.log("Location :- ".concat(JSON.stringify(validationResult.result.location)));
}
}
function _printObjectValidationRec(source, path) {
var _a, _b, _c, _d;
// Print message only for individual string and also only for error
// Skip other validation results
if (isStringValidationResult(source)) {
if (source.__icu_validator_error) {
console.log($.bgRed("Invalid ICU string :- ".concat((_a = source.result) === null || _a === void 0 ? void 0 : _a.originalMessage)));
console.log($.magenta("Object path :- ".concat(path)));
console.log("Error :- ".concat(((_b = source.result) === null || _b === void 0 ? void 0 : _b.errorMessage) && $.red((_c = source.result) === null || _c === void 0 ? void 0 : _c.errorMessage)));
console.log("Location :- ".concat(JSON.stringify((_d = source.result) === null || _d === void 0 ? void 0 : _d.location), "\n"));
}
}
else {
// For object, iterate over and check string validation result
// Update the path to show proper error path in a nested object
for (var _i = 0, _e = Object.entries(source); _i < _e.length; _i++) {
var _f = _e[_i], key = _f[0], value = _f[1];
_printObjectValidationRec(value, "".concat(path, ".").concat(key));
}
}
}
function printObjectValidation(validationResult) {
for (var _i = 0, _a = Object.entries(validationResult); _i < _a.length; _i++) {
var _b = _a[_i], key = _b[0], value = _b[1];
_printObjectValidationRec(value, key);
}
}
function printFileValidation(fileValidationResult, verbose) {
if (verbose === void 0) { verbose = false; }
if (fileValidationResult.isValid && !verbose) {
return;
}
console.log($.black().bgGreen("Validating file :- ".concat(fileValidationResult.fileName)));
console.log('\n');
printObjectValidation(fileValidationResult.validationResult);
console.log($.black().bgGreen("Done!!!"));
console.log('\n');
}
function printDirectoryValidation(directoryValidationResult, verbose) {
if (verbose === void 0) { verbose = false; }
directoryValidationResult.forEach(function (value) { return printFileValidation(value, verbose); });
}
/**
* Validate if a data source conforms to ICU standard
* The source can be either -
* 1) a text
* 2) an object of key and texts
* 3) a JSON file containing keys and ICU texts
* 4) directory containing JSON files
* @param {string | object} source Validation source - it can be a single ICU string, an object of key value pair, a JSON file path or a directory path containing JSON files
* @param {ValidationOptions} [options] options to customize the output and validation rules
* @param {boolean} [options.prettyPrint=false] if the output should be printed on console
* @param {boolean} [options.verbose=false] if all scanned files should be printed on console, only works if prettyPrint is enabled
* @param {boolean} [options.ignoreTransTag=false] special handling for i18next Trans component generated output
* @param {ParserOptions} [options.parseOptions] options to customize the validation rule
* @param {boolean} [options.parseOptions.ignoreTag=false] Whether to treat HTML/XML tags as string literal
* @param {boolean} [options.parseOptions.requiresOtherClause=false] Should `select`, `selectordinal`, and `plural` arguments always include the `other` case clause
* @param {boolean} [options.parseOptions.shouldParseSkeletons=false] Whether to parse number/datetime skeleton into Intl.NumberFormatOptions and Intl.DateTimeFormatOptions, respectively.
* @param {boolean} [options.parseOptions.captureLocation=false] Capture location info in AST
* @param {Intl.Locale} [options.parseOptions.locale] Instance of Intl.Locale to resolve locale-dependent skeleton
* @returns
*/
function validate(source, options) {
if (typeof source === 'object') {
var objectValidationResult = validateObject(source, options === null || options === void 0 ? void 0 : options.parseOptions, options === null || options === void 0 ? void 0 : options.ignoreTransTag);
if (options === null || options === void 0 ? void 0 : options.prettyPrint) {
printObjectValidation(objectValidationResult);
}
return objectValidationResult;
}
var fsStat;
try {
fsStat = fs.statSync(source);
if (fsStat.isFile()) {
var fileValidationResult = validateJsonFileSync(source, options === null || options === void 0 ? void 0 : options.parseOptions, options === null || options === void 0 ? void 0 : options.ignoreTransTag);
if (options === null || options === void 0 ? void 0 : options.prettyPrint) {
printFileValidation(fileValidationResult, options === null || options === void 0 ? void 0 : options.verbose);
}
return fileValidationResult;
}
else if (fsStat.isDirectory()) {
var directoryValidationResult = validateDirectorySync(source, options === null || options === void 0 ? void 0 : options.parseOptions, options === null || options === void 0 ? void 0 : options.ignoreTransTag);
if (options === null || options === void 0 ? void 0 : options.prettyPrint) {
printDirectoryValidation(directoryValidationResult, options === null || options === void 0 ? void 0 : options.verbose);
}
return directoryValidationResult;
}
}
catch (_a) {
// The source is an ICU string, validate the string
var stringValidationResult = validateString(source, options === null || options === void 0 ? void 0 : options.parseOptions, options === null || options === void 0 ? void 0 : options.ignoreTransTag);
if (options === null || options === void 0 ? void 0 : options.prettyPrint) {
printStringValidation(source, stringValidationResult);
}
return stringValidationResult;
}
}
/**
* Check if all strings in a JSON file conforms to ICU standard
* Typically the JSON file is an externalized translation file
* @param {string} filePath Path of the JSON file
* @param {ValidationOptions} [options] options to customize the output and validation rules
* @param {boolean} [options.prettyPrint=false] if the output should be printed on console
* @param {boolean} [options.verbose=false] if valid file output should also be printed on console, only works if prettyPrint is enabled
* @param {boolean} [options.ignoreTransTag=false] special handling for i18next Trans component generated output
* @param {ParserOptions} [options.parseOptions] options to customize the validation rule
* @param {boolean} [options.parseOptions.ignoreTag=false] Whether to treat HTML/XML tags as string literal
* @param {boolean} [options.parseOptions.requiresOtherClause=false] Should `select`, `selectordinal`, and `plural` arguments always include the `other` case clause
* @param {boolean} [options.parseOptions.shouldParseSkeletons=false] Whether to parse number/datetime skeleton into Intl.NumberFormatOptions and Intl.DateTimeFormatOptions, respectively.
* @param {boolean} [options.parseOptions.captureLocation=false] Capture location info in AST
* @param {Intl.Locale} [options.parseOptions.locale] Instance of Intl.Locale to resolve locale-dependent skeleton
* @returns {Promise}
*/
function validateFile(filePath, options) {
return __awaiter(this, void 0, void 0, function () {
var fileValidationResult;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, validateJsonFile(filePath, options === null || options === void 0 ? void 0 : options.parseOptions, options === null || options === void 0 ? void 0 : options.ignoreTransTag)];
case 1:
fileValidationResult = _a.sent();
if (options === null || options === void 0 ? void 0 : options.prettyPrint) {
printFileValidation(fileValidationResult, options === null || options === void 0 ? void 0 : options.verbose);
}
return [2 /*return*/, fileValidationResult];
}
});
});
}
/**
* Check if all strings inside all the JSON files of a directory conforms to ICU standard
* @param {string} directoryPath Path of the directory containing locale JSON files
* @param {ValidationOptions} [options] options to customize the output and validation rules
* @param {boolean} [options.prettyPrint=false] if the output should be printed on console
* @param {boolean} [options.verbose=false] if all scanned files should be printed on console, only works if prettyPrint is enabled
* @param {boolean} [options.ignoreTransTag=false] special handling for i18next Trans component generated output
* @param {ParserOptions} [options.parseOptions] options to customize the validation rule
* @param {boolean} [options.parseOptions.ignoreTag=false] Whether to treat HTML/XML tags as string literal
* @param {boolean} [options.parseOptions.requiresOtherClause=false] Should `select`, `selectordinal`, and `plural` arguments always include the `other` case clause
* @param {boolean} [options.parseOptions.shouldParseSkeletons=false] Whether to parse number/datetime skeleton into Intl.NumberFormatOptions and Intl.DateTimeFormatOptions, respectively.
* @param {boolean} [options.parseOptions.captureLocation=false] Capture location info in AST
* @param {Intl.Locale} [options.parseOptions.locale] Instance of Intl.Locale to resolve locale-dependent skeleton
* @returns {Promise}
*/
function validateDirectory(directoryPath, options) {
return __awaiter(this, void 0, void 0, function () {
var directoryValidationResult;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, validateDirectory$1(directoryPath, options === null || options === void 0 ? void 0 : options.parseOptions, options === null || options === void 0 ? void 0 : options.ignoreTransTag)];
case 1:
directoryValidationResult = _a.sent();
if (options === null || options === void 0 ? void 0 : options.prettyPrint) {
printDirectoryValidation(directoryValidationResult, options === null || options === void 0 ? void 0 : options.verbose);
}
return [2 /*return*/, directoryValidationResult];
}
});
});
}
exports.validate = validate;
exports.validateDirectory = validateDirectory;
exports.validateFile = validateFile;