2064 lines
62 KiB
JavaScript
2064 lines
62 KiB
JavaScript
/*!
|
|
* @intlify/shared v9.1.10
|
|
* (c) 2022 kazuya kawaguchi
|
|
* Released under the MIT License.
|
|
*/
|
|
const hasSymbol = typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol";
|
|
const makeSymbol = (name) => hasSymbol ? Symbol(name) : name;
|
|
const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
|
|
const friendlyJSONstringify = (json) => JSON.stringify(json).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/\u0027/g, "\\u0027");
|
|
const isNumber = (val) => typeof val === "number" && isFinite(val);
|
|
const isDate = (val) => toTypeString(val) === "[object Date]";
|
|
const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
|
|
const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
|
|
function warn(msg, err) {
|
|
if (typeof console !== "undefined") {
|
|
console.warn(`[intlify] ` + msg);
|
|
if (err) {
|
|
console.warn(err.stack);
|
|
}
|
|
}
|
|
}
|
|
const assign = Object.assign;
|
|
let _globalThis;
|
|
const getGlobalThis = () => {
|
|
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
|
|
};
|
|
function escapeHtml(rawText) {
|
|
return rawText.replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """).replace(/'/g, "'");
|
|
}
|
|
const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
|
|
function hasOwn$1(obj, key) {
|
|
return hasOwnProperty$1.call(obj, key);
|
|
}
|
|
const isArray = Array.isArray;
|
|
const isFunction = (val) => typeof val === "function";
|
|
const isString = (val) => typeof val === "string";
|
|
const isBoolean = (val) => typeof val === "boolean";
|
|
const isObject$1 = (val) => val !== null && typeof val === "object";
|
|
const objectToString = Object.prototype.toString;
|
|
const toTypeString = (value) => objectToString.call(value);
|
|
const isPlainObject = (val) => toTypeString(val) === "[object Object]";
|
|
const toDisplayString = (val) => {
|
|
return val == null ? "" : isArray(val) || isPlainObject(val) && val.toString === objectToString ? JSON.stringify(val, null, 2) : String(val);
|
|
};
|
|
/*!
|
|
* @intlify/message-resolver v9.1.10
|
|
* (c) 2022 kazuya kawaguchi
|
|
* Released under the MIT License.
|
|
*/
|
|
const hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function hasOwn(obj, key) {
|
|
return hasOwnProperty.call(obj, key);
|
|
}
|
|
const isObject = (val) => val !== null && typeof val === "object";
|
|
const pathStateMachine = [];
|
|
pathStateMachine[0] = {
|
|
["w"]: [0],
|
|
["i"]: [3, 0],
|
|
["["]: [4],
|
|
["o"]: [7]
|
|
};
|
|
pathStateMachine[1] = {
|
|
["w"]: [1],
|
|
["."]: [2],
|
|
["["]: [4],
|
|
["o"]: [7]
|
|
};
|
|
pathStateMachine[2] = {
|
|
["w"]: [2],
|
|
["i"]: [3, 0],
|
|
["0"]: [3, 0]
|
|
};
|
|
pathStateMachine[3] = {
|
|
["i"]: [3, 0],
|
|
["0"]: [3, 0],
|
|
["w"]: [1, 1],
|
|
["."]: [2, 1],
|
|
["["]: [4, 1],
|
|
["o"]: [7, 1]
|
|
};
|
|
pathStateMachine[4] = {
|
|
["'"]: [5, 0],
|
|
['"']: [6, 0],
|
|
["["]: [
|
|
4,
|
|
2
|
|
],
|
|
["]"]: [1, 3],
|
|
["o"]: 8,
|
|
["l"]: [4, 0]
|
|
};
|
|
pathStateMachine[5] = {
|
|
["'"]: [4, 0],
|
|
["o"]: 8,
|
|
["l"]: [5, 0]
|
|
};
|
|
pathStateMachine[6] = {
|
|
['"']: [4, 0],
|
|
["o"]: 8,
|
|
["l"]: [6, 0]
|
|
};
|
|
const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
|
|
function isLiteral(exp) {
|
|
return literalValueRE.test(exp);
|
|
}
|
|
function stripQuotes(str) {
|
|
const a = str.charCodeAt(0);
|
|
const b = str.charCodeAt(str.length - 1);
|
|
return a === b && (a === 34 || a === 39) ? str.slice(1, -1) : str;
|
|
}
|
|
function getPathCharType(ch) {
|
|
if (ch === void 0 || ch === null) {
|
|
return "o";
|
|
}
|
|
const code = ch.charCodeAt(0);
|
|
switch (code) {
|
|
case 91:
|
|
case 93:
|
|
case 46:
|
|
case 34:
|
|
case 39:
|
|
return ch;
|
|
case 95:
|
|
case 36:
|
|
case 45:
|
|
return "i";
|
|
case 9:
|
|
case 10:
|
|
case 13:
|
|
case 160:
|
|
case 65279:
|
|
case 8232:
|
|
case 8233:
|
|
return "w";
|
|
}
|
|
return "i";
|
|
}
|
|
function formatSubPath(path) {
|
|
const trimmed = path.trim();
|
|
if (path.charAt(0) === "0" && isNaN(parseInt(path))) {
|
|
return false;
|
|
}
|
|
return isLiteral(trimmed) ? stripQuotes(trimmed) : "*" + trimmed;
|
|
}
|
|
function parse(path) {
|
|
const keys = [];
|
|
let index = -1;
|
|
let mode = 0;
|
|
let subPathDepth = 0;
|
|
let c;
|
|
let key;
|
|
let newChar;
|
|
let type;
|
|
let transition;
|
|
let action;
|
|
let typeMap;
|
|
const actions = [];
|
|
actions[0] = () => {
|
|
if (key === void 0) {
|
|
key = newChar;
|
|
} else {
|
|
key += newChar;
|
|
}
|
|
};
|
|
actions[1] = () => {
|
|
if (key !== void 0) {
|
|
keys.push(key);
|
|
key = void 0;
|
|
}
|
|
};
|
|
actions[2] = () => {
|
|
actions[0]();
|
|
subPathDepth++;
|
|
};
|
|
actions[3] = () => {
|
|
if (subPathDepth > 0) {
|
|
subPathDepth--;
|
|
mode = 4;
|
|
actions[0]();
|
|
} else {
|
|
subPathDepth = 0;
|
|
if (key === void 0) {
|
|
return false;
|
|
}
|
|
key = formatSubPath(key);
|
|
if (key === false) {
|
|
return false;
|
|
} else {
|
|
actions[1]();
|
|
}
|
|
}
|
|
};
|
|
function maybeUnescapeQuote() {
|
|
const nextChar = path[index + 1];
|
|
if (mode === 5 && nextChar === "'" || mode === 6 && nextChar === '"') {
|
|
index++;
|
|
newChar = "\\" + nextChar;
|
|
actions[0]();
|
|
return true;
|
|
}
|
|
}
|
|
while (mode !== null) {
|
|
index++;
|
|
c = path[index];
|
|
if (c === "\\" && maybeUnescapeQuote()) {
|
|
continue;
|
|
}
|
|
type = getPathCharType(c);
|
|
typeMap = pathStateMachine[mode];
|
|
transition = typeMap[type] || typeMap["l"] || 8;
|
|
if (transition === 8) {
|
|
return;
|
|
}
|
|
mode = transition[0];
|
|
if (transition[1] !== void 0) {
|
|
action = actions[transition[1]];
|
|
if (action) {
|
|
newChar = c;
|
|
if (action() === false) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (mode === 7) {
|
|
return keys;
|
|
}
|
|
}
|
|
}
|
|
const cache = /* @__PURE__ */ new Map();
|
|
function resolveValue(obj, path) {
|
|
if (!isObject(obj)) {
|
|
return null;
|
|
}
|
|
let hit = cache.get(path);
|
|
if (!hit) {
|
|
hit = parse(path);
|
|
if (hit) {
|
|
cache.set(path, hit);
|
|
}
|
|
}
|
|
if (!hit) {
|
|
return null;
|
|
}
|
|
const len = hit.length;
|
|
let last = obj;
|
|
let i = 0;
|
|
while (i < len) {
|
|
const val = last[hit[i]];
|
|
if (val === void 0) {
|
|
return null;
|
|
}
|
|
last = val;
|
|
i++;
|
|
}
|
|
return last;
|
|
}
|
|
function handleFlatJson(obj) {
|
|
if (!isObject(obj)) {
|
|
return obj;
|
|
}
|
|
for (const key in obj) {
|
|
if (!hasOwn(obj, key)) {
|
|
continue;
|
|
}
|
|
if (!key.includes(".")) {
|
|
if (isObject(obj[key])) {
|
|
handleFlatJson(obj[key]);
|
|
}
|
|
} else {
|
|
const subKeys = key.split(".");
|
|
const lastIndex = subKeys.length - 1;
|
|
let currentObj = obj;
|
|
for (let i = 0; i < lastIndex; i++) {
|
|
if (!(subKeys[i] in currentObj)) {
|
|
currentObj[subKeys[i]] = {};
|
|
}
|
|
currentObj = currentObj[subKeys[i]];
|
|
}
|
|
currentObj[subKeys[lastIndex]] = obj[key];
|
|
delete obj[key];
|
|
if (isObject(currentObj[subKeys[lastIndex]])) {
|
|
handleFlatJson(currentObj[subKeys[lastIndex]]);
|
|
}
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
/*!
|
|
* @intlify/runtime v9.1.10
|
|
* (c) 2022 kazuya kawaguchi
|
|
* Released under the MIT License.
|
|
*/
|
|
const DEFAULT_MODIFIER = (str) => str;
|
|
const DEFAULT_MESSAGE = (ctx) => "";
|
|
const DEFAULT_MESSAGE_DATA_TYPE = "text";
|
|
const DEFAULT_NORMALIZE = (values) => values.length === 0 ? "" : values.join("");
|
|
const DEFAULT_INTERPOLATE = toDisplayString;
|
|
function pluralDefault(choice, choicesLength) {
|
|
choice = Math.abs(choice);
|
|
if (choicesLength === 2) {
|
|
return choice ? choice > 1 ? 1 : 0 : 1;
|
|
}
|
|
return choice ? Math.min(choice, 2) : 0;
|
|
}
|
|
function getPluralIndex(options) {
|
|
const index = isNumber(options.pluralIndex) ? options.pluralIndex : -1;
|
|
return options.named && (isNumber(options.named.count) || isNumber(options.named.n)) ? isNumber(options.named.count) ? options.named.count : isNumber(options.named.n) ? options.named.n : index : index;
|
|
}
|
|
function normalizeNamed(pluralIndex, props) {
|
|
if (!props.count) {
|
|
props.count = pluralIndex;
|
|
}
|
|
if (!props.n) {
|
|
props.n = pluralIndex;
|
|
}
|
|
}
|
|
function createMessageContext(options = {}) {
|
|
const locale = options.locale;
|
|
const pluralIndex = getPluralIndex(options);
|
|
const pluralRule = isObject$1(options.pluralRules) && isString(locale) && isFunction(options.pluralRules[locale]) ? options.pluralRules[locale] : pluralDefault;
|
|
const orgPluralRule = isObject$1(options.pluralRules) && isString(locale) && isFunction(options.pluralRules[locale]) ? pluralDefault : void 0;
|
|
const plural = (messages) => messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
|
|
const _list = options.list || [];
|
|
const list = (index) => _list[index];
|
|
const _named = options.named || {};
|
|
isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
|
|
const named = (key) => _named[key];
|
|
function message(key) {
|
|
const msg = isFunction(options.messages) ? options.messages(key) : isObject$1(options.messages) ? options.messages[key] : false;
|
|
return !msg ? options.parent ? options.parent.message(key) : DEFAULT_MESSAGE : msg;
|
|
}
|
|
const _modifier = (name) => options.modifiers ? options.modifiers[name] : DEFAULT_MODIFIER;
|
|
const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize) ? options.processor.normalize : DEFAULT_NORMALIZE;
|
|
const interpolate = isPlainObject(options.processor) && isFunction(options.processor.interpolate) ? options.processor.interpolate : DEFAULT_INTERPOLATE;
|
|
const type = isPlainObject(options.processor) && isString(options.processor.type) ? options.processor.type : DEFAULT_MESSAGE_DATA_TYPE;
|
|
const ctx = {
|
|
["list"]: list,
|
|
["named"]: named,
|
|
["plural"]: plural,
|
|
["linked"]: (key, modifier) => {
|
|
const msg = message(key)(ctx);
|
|
return isString(modifier) ? _modifier(modifier)(msg) : msg;
|
|
},
|
|
["message"]: message,
|
|
["type"]: type,
|
|
["interpolate"]: interpolate,
|
|
["normalize"]: normalize
|
|
};
|
|
return ctx;
|
|
}
|
|
/*!
|
|
* @intlify/message-compiler v9.1.10
|
|
* (c) 2022 kazuya kawaguchi
|
|
* Released under the MIT License.
|
|
*/
|
|
function createCompileError(code, loc, options = {}) {
|
|
const { domain, messages, args } = options;
|
|
const msg = code;
|
|
const error = new SyntaxError(String(msg));
|
|
error.code = code;
|
|
if (loc) {
|
|
error.location = loc;
|
|
}
|
|
error.domain = domain;
|
|
return error;
|
|
}
|
|
function defaultOnError(error) {
|
|
throw error;
|
|
}
|
|
function createPosition(line, column, offset) {
|
|
return { line, column, offset };
|
|
}
|
|
function createLocation(start, end, source) {
|
|
const loc = { start, end };
|
|
if (source != null) {
|
|
loc.source = source;
|
|
}
|
|
return loc;
|
|
}
|
|
const CHAR_SP = " ";
|
|
const CHAR_CR = "\r";
|
|
const CHAR_LF = "\n";
|
|
const CHAR_LS = String.fromCharCode(8232);
|
|
const CHAR_PS = String.fromCharCode(8233);
|
|
function createScanner(str) {
|
|
const _buf = str;
|
|
let _index = 0;
|
|
let _line = 1;
|
|
let _column = 1;
|
|
let _peekOffset = 0;
|
|
const isCRLF = (index2) => _buf[index2] === CHAR_CR && _buf[index2 + 1] === CHAR_LF;
|
|
const isLF = (index2) => _buf[index2] === CHAR_LF;
|
|
const isPS = (index2) => _buf[index2] === CHAR_PS;
|
|
const isLS = (index2) => _buf[index2] === CHAR_LS;
|
|
const isLineEnd = (index2) => isCRLF(index2) || isLF(index2) || isPS(index2) || isLS(index2);
|
|
const index = () => _index;
|
|
const line = () => _line;
|
|
const column = () => _column;
|
|
const peekOffset = () => _peekOffset;
|
|
const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
|
|
const currentChar = () => charAt(_index);
|
|
const currentPeek = () => charAt(_index + _peekOffset);
|
|
function next() {
|
|
_peekOffset = 0;
|
|
if (isLineEnd(_index)) {
|
|
_line++;
|
|
_column = 0;
|
|
}
|
|
if (isCRLF(_index)) {
|
|
_index++;
|
|
}
|
|
_index++;
|
|
_column++;
|
|
return _buf[_index];
|
|
}
|
|
function peek() {
|
|
if (isCRLF(_index + _peekOffset)) {
|
|
_peekOffset++;
|
|
}
|
|
_peekOffset++;
|
|
return _buf[_index + _peekOffset];
|
|
}
|
|
function reset() {
|
|
_index = 0;
|
|
_line = 1;
|
|
_column = 1;
|
|
_peekOffset = 0;
|
|
}
|
|
function resetPeek(offset = 0) {
|
|
_peekOffset = offset;
|
|
}
|
|
function skipToPeek() {
|
|
const target = _index + _peekOffset;
|
|
while (target !== _index) {
|
|
next();
|
|
}
|
|
_peekOffset = 0;
|
|
}
|
|
return {
|
|
index,
|
|
line,
|
|
column,
|
|
peekOffset,
|
|
charAt,
|
|
currentChar,
|
|
currentPeek,
|
|
next,
|
|
peek,
|
|
reset,
|
|
resetPeek,
|
|
skipToPeek
|
|
};
|
|
}
|
|
const EOF = void 0;
|
|
const LITERAL_DELIMITER = "'";
|
|
const ERROR_DOMAIN$1 = "tokenizer";
|
|
function createTokenizer(source, options = {}) {
|
|
const location = options.location !== false;
|
|
const _scnr = createScanner(source);
|
|
const currentOffset = () => _scnr.index();
|
|
const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
|
|
const _initLoc = currentPosition();
|
|
const _initOffset = currentOffset();
|
|
const _context = {
|
|
currentType: 14,
|
|
offset: _initOffset,
|
|
startLoc: _initLoc,
|
|
endLoc: _initLoc,
|
|
lastType: 14,
|
|
lastOffset: _initOffset,
|
|
lastStartLoc: _initLoc,
|
|
lastEndLoc: _initLoc,
|
|
braceNest: 0,
|
|
inLinked: false,
|
|
text: ""
|
|
};
|
|
const context = () => _context;
|
|
const { onError } = options;
|
|
function emitError(code, pos, offset, ...args) {
|
|
const ctx = context();
|
|
pos.column += offset;
|
|
pos.offset += offset;
|
|
if (onError) {
|
|
const loc = createLocation(ctx.startLoc, pos);
|
|
const err = createCompileError(code, loc, {
|
|
domain: ERROR_DOMAIN$1,
|
|
args
|
|
});
|
|
onError(err);
|
|
}
|
|
}
|
|
function getToken(context2, type, value) {
|
|
context2.endLoc = currentPosition();
|
|
context2.currentType = type;
|
|
const token = { type };
|
|
if (location) {
|
|
token.loc = createLocation(context2.startLoc, context2.endLoc);
|
|
}
|
|
if (value != null) {
|
|
token.value = value;
|
|
}
|
|
return token;
|
|
}
|
|
const getEndToken = (context2) => getToken(context2, 14);
|
|
function eat(scnr, ch) {
|
|
if (scnr.currentChar() === ch) {
|
|
scnr.next();
|
|
return ch;
|
|
} else {
|
|
emitError(0, currentPosition(), 0, ch);
|
|
return "";
|
|
}
|
|
}
|
|
function peekSpaces(scnr) {
|
|
let buf = "";
|
|
while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
|
|
buf += scnr.currentPeek();
|
|
scnr.peek();
|
|
}
|
|
return buf;
|
|
}
|
|
function skipSpaces(scnr) {
|
|
const buf = peekSpaces(scnr);
|
|
scnr.skipToPeek();
|
|
return buf;
|
|
}
|
|
function isIdentifierStart(ch) {
|
|
if (ch === EOF) {
|
|
return false;
|
|
}
|
|
const cc = ch.charCodeAt(0);
|
|
return cc >= 97 && cc <= 122 || cc >= 65 && cc <= 90 || cc === 95;
|
|
}
|
|
function isNumberStart(ch) {
|
|
if (ch === EOF) {
|
|
return false;
|
|
}
|
|
const cc = ch.charCodeAt(0);
|
|
return cc >= 48 && cc <= 57;
|
|
}
|
|
function isNamedIdentifierStart(scnr, context2) {
|
|
const { currentType } = context2;
|
|
if (currentType !== 2) {
|
|
return false;
|
|
}
|
|
peekSpaces(scnr);
|
|
const ret = isIdentifierStart(scnr.currentPeek());
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isListIdentifierStart(scnr, context2) {
|
|
const { currentType } = context2;
|
|
if (currentType !== 2) {
|
|
return false;
|
|
}
|
|
peekSpaces(scnr);
|
|
const ch = scnr.currentPeek() === "-" ? scnr.peek() : scnr.currentPeek();
|
|
const ret = isNumberStart(ch);
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isLiteralStart(scnr, context2) {
|
|
const { currentType } = context2;
|
|
if (currentType !== 2) {
|
|
return false;
|
|
}
|
|
peekSpaces(scnr);
|
|
const ret = scnr.currentPeek() === LITERAL_DELIMITER;
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isLinkedDotStart(scnr, context2) {
|
|
const { currentType } = context2;
|
|
if (currentType !== 8) {
|
|
return false;
|
|
}
|
|
peekSpaces(scnr);
|
|
const ret = scnr.currentPeek() === ".";
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isLinkedModifierStart(scnr, context2) {
|
|
const { currentType } = context2;
|
|
if (currentType !== 9) {
|
|
return false;
|
|
}
|
|
peekSpaces(scnr);
|
|
const ret = isIdentifierStart(scnr.currentPeek());
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isLinkedDelimiterStart(scnr, context2) {
|
|
const { currentType } = context2;
|
|
if (!(currentType === 8 || currentType === 12)) {
|
|
return false;
|
|
}
|
|
peekSpaces(scnr);
|
|
const ret = scnr.currentPeek() === ":";
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isLinkedReferStart(scnr, context2) {
|
|
const { currentType } = context2;
|
|
if (currentType !== 10) {
|
|
return false;
|
|
}
|
|
const fn = () => {
|
|
const ch = scnr.currentPeek();
|
|
if (ch === "{") {
|
|
return isIdentifierStart(scnr.peek());
|
|
} else if (ch === "@" || ch === "%" || ch === "|" || ch === ":" || ch === "." || ch === CHAR_SP || !ch) {
|
|
return false;
|
|
} else if (ch === CHAR_LF) {
|
|
scnr.peek();
|
|
return fn();
|
|
} else {
|
|
return isIdentifierStart(ch);
|
|
}
|
|
};
|
|
const ret = fn();
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isPluralStart(scnr) {
|
|
peekSpaces(scnr);
|
|
const ret = scnr.currentPeek() === "|";
|
|
scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function isTextStart(scnr, reset = true) {
|
|
const fn = (hasSpace = false, prev = "", detectModulo = false) => {
|
|
const ch = scnr.currentPeek();
|
|
if (ch === "{") {
|
|
return prev === "%" ? false : hasSpace;
|
|
} else if (ch === "@" || !ch) {
|
|
return prev === "%" ? true : hasSpace;
|
|
} else if (ch === "%") {
|
|
scnr.peek();
|
|
return fn(hasSpace, "%", true);
|
|
} else if (ch === "|") {
|
|
return prev === "%" || detectModulo ? true : !(prev === CHAR_SP || prev === CHAR_LF);
|
|
} else if (ch === CHAR_SP) {
|
|
scnr.peek();
|
|
return fn(true, CHAR_SP, detectModulo);
|
|
} else if (ch === CHAR_LF) {
|
|
scnr.peek();
|
|
return fn(true, CHAR_LF, detectModulo);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
const ret = fn();
|
|
reset && scnr.resetPeek();
|
|
return ret;
|
|
}
|
|
function takeChar(scnr, fn) {
|
|
const ch = scnr.currentChar();
|
|
if (ch === EOF) {
|
|
return EOF;
|
|
}
|
|
if (fn(ch)) {
|
|
scnr.next();
|
|
return ch;
|
|
}
|
|
return null;
|
|
}
|
|
function takeIdentifierChar(scnr) {
|
|
const closure = (ch) => {
|
|
const cc = ch.charCodeAt(0);
|
|
return cc >= 97 && cc <= 122 || cc >= 65 && cc <= 90 || cc >= 48 && cc <= 57 || cc === 95 || cc === 36;
|
|
};
|
|
return takeChar(scnr, closure);
|
|
}
|
|
function takeDigit(scnr) {
|
|
const closure = (ch) => {
|
|
const cc = ch.charCodeAt(0);
|
|
return cc >= 48 && cc <= 57;
|
|
};
|
|
return takeChar(scnr, closure);
|
|
}
|
|
function takeHexDigit(scnr) {
|
|
const closure = (ch) => {
|
|
const cc = ch.charCodeAt(0);
|
|
return cc >= 48 && cc <= 57 || cc >= 65 && cc <= 70 || cc >= 97 && cc <= 102;
|
|
};
|
|
return takeChar(scnr, closure);
|
|
}
|
|
function getDigits(scnr) {
|
|
let ch = "";
|
|
let num = "";
|
|
while (ch = takeDigit(scnr)) {
|
|
num += ch;
|
|
}
|
|
return num;
|
|
}
|
|
function readText(scnr) {
|
|
let buf = "";
|
|
while (true) {
|
|
const ch = scnr.currentChar();
|
|
if (ch === "{" || ch === "}" || ch === "@" || ch === "|" || !ch) {
|
|
break;
|
|
} else if (ch === "%") {
|
|
if (isTextStart(scnr)) {
|
|
buf += ch;
|
|
scnr.next();
|
|
} else {
|
|
break;
|
|
}
|
|
} else if (ch === CHAR_SP || ch === CHAR_LF) {
|
|
if (isTextStart(scnr)) {
|
|
buf += ch;
|
|
scnr.next();
|
|
} else if (isPluralStart(scnr)) {
|
|
break;
|
|
} else {
|
|
buf += ch;
|
|
scnr.next();
|
|
}
|
|
} else {
|
|
buf += ch;
|
|
scnr.next();
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
function readNamedIdentifier(scnr) {
|
|
skipSpaces(scnr);
|
|
let ch = "";
|
|
let name = "";
|
|
while (ch = takeIdentifierChar(scnr)) {
|
|
name += ch;
|
|
}
|
|
if (scnr.currentChar() === EOF) {
|
|
emitError(6, currentPosition(), 0);
|
|
}
|
|
return name;
|
|
}
|
|
function readListIdentifier(scnr) {
|
|
skipSpaces(scnr);
|
|
let value = "";
|
|
if (scnr.currentChar() === "-") {
|
|
scnr.next();
|
|
value += `-${getDigits(scnr)}`;
|
|
} else {
|
|
value += getDigits(scnr);
|
|
}
|
|
if (scnr.currentChar() === EOF) {
|
|
emitError(6, currentPosition(), 0);
|
|
}
|
|
return value;
|
|
}
|
|
function readLiteral(scnr) {
|
|
skipSpaces(scnr);
|
|
eat(scnr, `'`);
|
|
let ch = "";
|
|
let literal = "";
|
|
const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
|
|
while (ch = takeChar(scnr, fn)) {
|
|
if (ch === "\\") {
|
|
literal += readEscapeSequence(scnr);
|
|
} else {
|
|
literal += ch;
|
|
}
|
|
}
|
|
const current = scnr.currentChar();
|
|
if (current === CHAR_LF || current === EOF) {
|
|
emitError(2, currentPosition(), 0);
|
|
if (current === CHAR_LF) {
|
|
scnr.next();
|
|
eat(scnr, `'`);
|
|
}
|
|
return literal;
|
|
}
|
|
eat(scnr, `'`);
|
|
return literal;
|
|
}
|
|
function readEscapeSequence(scnr) {
|
|
const ch = scnr.currentChar();
|
|
switch (ch) {
|
|
case "\\":
|
|
case `'`:
|
|
scnr.next();
|
|
return `\\${ch}`;
|
|
case "u":
|
|
return readUnicodeEscapeSequence(scnr, ch, 4);
|
|
case "U":
|
|
return readUnicodeEscapeSequence(scnr, ch, 6);
|
|
default:
|
|
emitError(3, currentPosition(), 0, ch);
|
|
return "";
|
|
}
|
|
}
|
|
function readUnicodeEscapeSequence(scnr, unicode, digits) {
|
|
eat(scnr, unicode);
|
|
let sequence = "";
|
|
for (let i = 0; i < digits; i++) {
|
|
const ch = takeHexDigit(scnr);
|
|
if (!ch) {
|
|
emitError(4, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
|
|
break;
|
|
}
|
|
sequence += ch;
|
|
}
|
|
return `\\${unicode}${sequence}`;
|
|
}
|
|
function readInvalidIdentifier(scnr) {
|
|
skipSpaces(scnr);
|
|
let ch = "";
|
|
let identifiers = "";
|
|
const closure = (ch2) => ch2 !== "{" && ch2 !== "}" && ch2 !== CHAR_SP && ch2 !== CHAR_LF;
|
|
while (ch = takeChar(scnr, closure)) {
|
|
identifiers += ch;
|
|
}
|
|
return identifiers;
|
|
}
|
|
function readLinkedModifier(scnr) {
|
|
let ch = "";
|
|
let name = "";
|
|
while (ch = takeIdentifierChar(scnr)) {
|
|
name += ch;
|
|
}
|
|
return name;
|
|
}
|
|
function readLinkedRefer(scnr) {
|
|
const fn = (detect = false, buf) => {
|
|
const ch = scnr.currentChar();
|
|
if (ch === "{" || ch === "%" || ch === "@" || ch === "|" || !ch) {
|
|
return buf;
|
|
} else if (ch === CHAR_SP) {
|
|
return buf;
|
|
} else if (ch === CHAR_LF) {
|
|
buf += ch;
|
|
scnr.next();
|
|
return fn(detect, buf);
|
|
} else {
|
|
buf += ch;
|
|
scnr.next();
|
|
return fn(true, buf);
|
|
}
|
|
};
|
|
return fn(false, "");
|
|
}
|
|
function readPlural(scnr) {
|
|
skipSpaces(scnr);
|
|
const plural = eat(scnr, "|");
|
|
skipSpaces(scnr);
|
|
return plural;
|
|
}
|
|
function readTokenInPlaceholder(scnr, context2) {
|
|
let token = null;
|
|
const ch = scnr.currentChar();
|
|
switch (ch) {
|
|
case "{":
|
|
if (context2.braceNest >= 1) {
|
|
emitError(8, currentPosition(), 0);
|
|
}
|
|
scnr.next();
|
|
token = getToken(context2, 2, "{");
|
|
skipSpaces(scnr);
|
|
context2.braceNest++;
|
|
return token;
|
|
case "}":
|
|
if (context2.braceNest > 0 && context2.currentType === 2) {
|
|
emitError(7, currentPosition(), 0);
|
|
}
|
|
scnr.next();
|
|
token = getToken(context2, 3, "}");
|
|
context2.braceNest--;
|
|
context2.braceNest > 0 && skipSpaces(scnr);
|
|
if (context2.inLinked && context2.braceNest === 0) {
|
|
context2.inLinked = false;
|
|
}
|
|
return token;
|
|
case "@":
|
|
if (context2.braceNest > 0) {
|
|
emitError(6, currentPosition(), 0);
|
|
}
|
|
token = readTokenInLinked(scnr, context2) || getEndToken(context2);
|
|
context2.braceNest = 0;
|
|
return token;
|
|
default:
|
|
let validNamedIdentifier = true;
|
|
let validListIdentifier = true;
|
|
let validLiteral = true;
|
|
if (isPluralStart(scnr)) {
|
|
if (context2.braceNest > 0) {
|
|
emitError(6, currentPosition(), 0);
|
|
}
|
|
token = getToken(context2, 1, readPlural(scnr));
|
|
context2.braceNest = 0;
|
|
context2.inLinked = false;
|
|
return token;
|
|
}
|
|
if (context2.braceNest > 0 && (context2.currentType === 5 || context2.currentType === 6 || context2.currentType === 7)) {
|
|
emitError(6, currentPosition(), 0);
|
|
context2.braceNest = 0;
|
|
return readToken(scnr, context2);
|
|
}
|
|
if (validNamedIdentifier = isNamedIdentifierStart(scnr, context2)) {
|
|
token = getToken(context2, 5, readNamedIdentifier(scnr));
|
|
skipSpaces(scnr);
|
|
return token;
|
|
}
|
|
if (validListIdentifier = isListIdentifierStart(scnr, context2)) {
|
|
token = getToken(context2, 6, readListIdentifier(scnr));
|
|
skipSpaces(scnr);
|
|
return token;
|
|
}
|
|
if (validLiteral = isLiteralStart(scnr, context2)) {
|
|
token = getToken(context2, 7, readLiteral(scnr));
|
|
skipSpaces(scnr);
|
|
return token;
|
|
}
|
|
if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
|
|
token = getToken(context2, 13, readInvalidIdentifier(scnr));
|
|
emitError(1, currentPosition(), 0, token.value);
|
|
skipSpaces(scnr);
|
|
return token;
|
|
}
|
|
break;
|
|
}
|
|
return token;
|
|
}
|
|
function readTokenInLinked(scnr, context2) {
|
|
const { currentType } = context2;
|
|
let token = null;
|
|
const ch = scnr.currentChar();
|
|
if ((currentType === 8 || currentType === 9 || currentType === 12 || currentType === 10) && (ch === CHAR_LF || ch === CHAR_SP)) {
|
|
emitError(9, currentPosition(), 0);
|
|
}
|
|
switch (ch) {
|
|
case "@":
|
|
scnr.next();
|
|
token = getToken(context2, 8, "@");
|
|
context2.inLinked = true;
|
|
return token;
|
|
case ".":
|
|
skipSpaces(scnr);
|
|
scnr.next();
|
|
return getToken(context2, 9, ".");
|
|
case ":":
|
|
skipSpaces(scnr);
|
|
scnr.next();
|
|
return getToken(context2, 10, ":");
|
|
default:
|
|
if (isPluralStart(scnr)) {
|
|
token = getToken(context2, 1, readPlural(scnr));
|
|
context2.braceNest = 0;
|
|
context2.inLinked = false;
|
|
return token;
|
|
}
|
|
if (isLinkedDotStart(scnr, context2) || isLinkedDelimiterStart(scnr, context2)) {
|
|
skipSpaces(scnr);
|
|
return readTokenInLinked(scnr, context2);
|
|
}
|
|
if (isLinkedModifierStart(scnr, context2)) {
|
|
skipSpaces(scnr);
|
|
return getToken(context2, 12, readLinkedModifier(scnr));
|
|
}
|
|
if (isLinkedReferStart(scnr, context2)) {
|
|
skipSpaces(scnr);
|
|
if (ch === "{") {
|
|
return readTokenInPlaceholder(scnr, context2) || token;
|
|
} else {
|
|
return getToken(context2, 11, readLinkedRefer(scnr));
|
|
}
|
|
}
|
|
if (currentType === 8) {
|
|
emitError(9, currentPosition(), 0);
|
|
}
|
|
context2.braceNest = 0;
|
|
context2.inLinked = false;
|
|
return readToken(scnr, context2);
|
|
}
|
|
}
|
|
function readToken(scnr, context2) {
|
|
let token = { type: 14 };
|
|
if (context2.braceNest > 0) {
|
|
return readTokenInPlaceholder(scnr, context2) || getEndToken(context2);
|
|
}
|
|
if (context2.inLinked) {
|
|
return readTokenInLinked(scnr, context2) || getEndToken(context2);
|
|
}
|
|
const ch = scnr.currentChar();
|
|
switch (ch) {
|
|
case "{":
|
|
return readTokenInPlaceholder(scnr, context2) || getEndToken(context2);
|
|
case "}":
|
|
emitError(5, currentPosition(), 0);
|
|
scnr.next();
|
|
return getToken(context2, 3, "}");
|
|
case "@":
|
|
return readTokenInLinked(scnr, context2) || getEndToken(context2);
|
|
default:
|
|
if (isPluralStart(scnr)) {
|
|
token = getToken(context2, 1, readPlural(scnr));
|
|
context2.braceNest = 0;
|
|
context2.inLinked = false;
|
|
return token;
|
|
}
|
|
if (isTextStart(scnr)) {
|
|
return getToken(context2, 0, readText(scnr));
|
|
}
|
|
if (ch === "%") {
|
|
scnr.next();
|
|
return getToken(context2, 4, "%");
|
|
}
|
|
break;
|
|
}
|
|
return token;
|
|
}
|
|
function nextToken() {
|
|
const { currentType, offset, startLoc, endLoc } = _context;
|
|
_context.lastType = currentType;
|
|
_context.lastOffset = offset;
|
|
_context.lastStartLoc = startLoc;
|
|
_context.lastEndLoc = endLoc;
|
|
_context.offset = currentOffset();
|
|
_context.startLoc = currentPosition();
|
|
if (_scnr.currentChar() === EOF) {
|
|
return getToken(_context, 14);
|
|
}
|
|
return readToken(_scnr, _context);
|
|
}
|
|
return {
|
|
nextToken,
|
|
currentOffset,
|
|
currentPosition,
|
|
context
|
|
};
|
|
}
|
|
const ERROR_DOMAIN = "parser";
|
|
const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
|
|
function fromEscapeSequence(match, codePoint4, codePoint6) {
|
|
switch (match) {
|
|
case `\\\\`:
|
|
return `\\`;
|
|
case `\\'`:
|
|
return `'`;
|
|
default: {
|
|
const codePoint = parseInt(codePoint4 || codePoint6, 16);
|
|
if (codePoint <= 55295 || codePoint >= 57344) {
|
|
return String.fromCodePoint(codePoint);
|
|
}
|
|
return "\uFFFD";
|
|
}
|
|
}
|
|
}
|
|
function createParser(options = {}) {
|
|
const location = options.location !== false;
|
|
const { onError } = options;
|
|
function emitError(tokenzer, code, start, offset, ...args) {
|
|
const end = tokenzer.currentPosition();
|
|
end.offset += offset;
|
|
end.column += offset;
|
|
if (onError) {
|
|
const loc = createLocation(start, end);
|
|
const err = createCompileError(code, loc, {
|
|
domain: ERROR_DOMAIN,
|
|
args
|
|
});
|
|
onError(err);
|
|
}
|
|
}
|
|
function startNode(type, offset, loc) {
|
|
const node = {
|
|
type,
|
|
start: offset,
|
|
end: offset
|
|
};
|
|
if (location) {
|
|
node.loc = { start: loc, end: loc };
|
|
}
|
|
return node;
|
|
}
|
|
function endNode(node, offset, pos, type) {
|
|
node.end = offset;
|
|
if (type) {
|
|
node.type = type;
|
|
}
|
|
if (location && node.loc) {
|
|
node.loc.end = pos;
|
|
}
|
|
}
|
|
function parseText(tokenizer, value) {
|
|
const context = tokenizer.context();
|
|
const node = startNode(3, context.offset, context.startLoc);
|
|
node.value = value;
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return node;
|
|
}
|
|
function parseList(tokenizer, index) {
|
|
const context = tokenizer.context();
|
|
const { lastOffset: offset, lastStartLoc: loc } = context;
|
|
const node = startNode(5, offset, loc);
|
|
node.index = parseInt(index, 10);
|
|
tokenizer.nextToken();
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return node;
|
|
}
|
|
function parseNamed(tokenizer, key) {
|
|
const context = tokenizer.context();
|
|
const { lastOffset: offset, lastStartLoc: loc } = context;
|
|
const node = startNode(4, offset, loc);
|
|
node.key = key;
|
|
tokenizer.nextToken();
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return node;
|
|
}
|
|
function parseLiteral(tokenizer, value) {
|
|
const context = tokenizer.context();
|
|
const { lastOffset: offset, lastStartLoc: loc } = context;
|
|
const node = startNode(9, offset, loc);
|
|
node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
|
|
tokenizer.nextToken();
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return node;
|
|
}
|
|
function parseLinkedModifier(tokenizer) {
|
|
const token = tokenizer.nextToken();
|
|
const context = tokenizer.context();
|
|
const { lastOffset: offset, lastStartLoc: loc } = context;
|
|
const node = startNode(8, offset, loc);
|
|
if (token.type !== 12) {
|
|
emitError(tokenizer, 11, context.lastStartLoc, 0);
|
|
node.value = "";
|
|
endNode(node, offset, loc);
|
|
return {
|
|
nextConsumeToken: token,
|
|
node
|
|
};
|
|
}
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
node.value = token.value || "";
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return {
|
|
node
|
|
};
|
|
}
|
|
function parseLinkedKey(tokenizer, value) {
|
|
const context = tokenizer.context();
|
|
const node = startNode(7, context.offset, context.startLoc);
|
|
node.value = value;
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return node;
|
|
}
|
|
function parseLinked(tokenizer) {
|
|
const context = tokenizer.context();
|
|
const linkedNode = startNode(6, context.offset, context.startLoc);
|
|
let token = tokenizer.nextToken();
|
|
if (token.type === 9) {
|
|
const parsed = parseLinkedModifier(tokenizer);
|
|
linkedNode.modifier = parsed.node;
|
|
token = parsed.nextConsumeToken || tokenizer.nextToken();
|
|
}
|
|
if (token.type !== 10) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
token = tokenizer.nextToken();
|
|
if (token.type === 2) {
|
|
token = tokenizer.nextToken();
|
|
}
|
|
switch (token.type) {
|
|
case 11:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
linkedNode.key = parseLinkedKey(tokenizer, token.value || "");
|
|
break;
|
|
case 5:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
linkedNode.key = parseNamed(tokenizer, token.value || "");
|
|
break;
|
|
case 6:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
linkedNode.key = parseList(tokenizer, token.value || "");
|
|
break;
|
|
case 7:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
linkedNode.key = parseLiteral(tokenizer, token.value || "");
|
|
break;
|
|
default:
|
|
emitError(tokenizer, 12, context.lastStartLoc, 0);
|
|
const nextContext = tokenizer.context();
|
|
const emptyLinkedKeyNode = startNode(7, nextContext.offset, nextContext.startLoc);
|
|
emptyLinkedKeyNode.value = "";
|
|
endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
|
|
linkedNode.key = emptyLinkedKeyNode;
|
|
endNode(linkedNode, nextContext.offset, nextContext.startLoc);
|
|
return {
|
|
nextConsumeToken: token,
|
|
node: linkedNode
|
|
};
|
|
}
|
|
endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return {
|
|
node: linkedNode
|
|
};
|
|
}
|
|
function parseMessage(tokenizer) {
|
|
const context = tokenizer.context();
|
|
const startOffset = context.currentType === 1 ? tokenizer.currentOffset() : context.offset;
|
|
const startLoc = context.currentType === 1 ? context.endLoc : context.startLoc;
|
|
const node = startNode(2, startOffset, startLoc);
|
|
node.items = [];
|
|
let nextToken = null;
|
|
do {
|
|
const token = nextToken || tokenizer.nextToken();
|
|
nextToken = null;
|
|
switch (token.type) {
|
|
case 0:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
node.items.push(parseText(tokenizer, token.value || ""));
|
|
break;
|
|
case 6:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
node.items.push(parseList(tokenizer, token.value || ""));
|
|
break;
|
|
case 5:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
node.items.push(parseNamed(tokenizer, token.value || ""));
|
|
break;
|
|
case 7:
|
|
if (token.value == null) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, getTokenCaption(token));
|
|
}
|
|
node.items.push(parseLiteral(tokenizer, token.value || ""));
|
|
break;
|
|
case 8:
|
|
const parsed = parseLinked(tokenizer);
|
|
node.items.push(parsed.node);
|
|
nextToken = parsed.nextConsumeToken || null;
|
|
break;
|
|
}
|
|
} while (context.currentType !== 14 && context.currentType !== 1);
|
|
const endOffset = context.currentType === 1 ? context.lastOffset : tokenizer.currentOffset();
|
|
const endLoc = context.currentType === 1 ? context.lastEndLoc : tokenizer.currentPosition();
|
|
endNode(node, endOffset, endLoc);
|
|
return node;
|
|
}
|
|
function parsePlural(tokenizer, offset, loc, msgNode) {
|
|
const context = tokenizer.context();
|
|
let hasEmptyMessage = msgNode.items.length === 0;
|
|
const node = startNode(1, offset, loc);
|
|
node.cases = [];
|
|
node.cases.push(msgNode);
|
|
do {
|
|
const msg = parseMessage(tokenizer);
|
|
if (!hasEmptyMessage) {
|
|
hasEmptyMessage = msg.items.length === 0;
|
|
}
|
|
node.cases.push(msg);
|
|
} while (context.currentType !== 14);
|
|
if (hasEmptyMessage) {
|
|
emitError(tokenizer, 10, loc, 0);
|
|
}
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return node;
|
|
}
|
|
function parseResource(tokenizer) {
|
|
const context = tokenizer.context();
|
|
const { offset, startLoc } = context;
|
|
const msgNode = parseMessage(tokenizer);
|
|
if (context.currentType === 14) {
|
|
return msgNode;
|
|
} else {
|
|
return parsePlural(tokenizer, offset, startLoc, msgNode);
|
|
}
|
|
}
|
|
function parse2(source) {
|
|
const tokenizer = createTokenizer(source, assign({}, options));
|
|
const context = tokenizer.context();
|
|
const node = startNode(0, context.offset, context.startLoc);
|
|
if (location && node.loc) {
|
|
node.loc.source = source;
|
|
}
|
|
node.body = parseResource(tokenizer);
|
|
if (context.currentType !== 14) {
|
|
emitError(tokenizer, 13, context.lastStartLoc, 0, source[context.offset] || "");
|
|
}
|
|
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
return node;
|
|
}
|
|
return { parse: parse2 };
|
|
}
|
|
function getTokenCaption(token) {
|
|
if (token.type === 14) {
|
|
return "EOF";
|
|
}
|
|
const name = (token.value || "").replace(/\r?\n/gu, "\\n");
|
|
return name.length > 10 ? name.slice(0, 9) + "\u2026" : name;
|
|
}
|
|
function createTransformer(ast, options = {}) {
|
|
const _context = {
|
|
ast,
|
|
helpers: /* @__PURE__ */ new Set()
|
|
};
|
|
const context = () => _context;
|
|
const helper = (name) => {
|
|
_context.helpers.add(name);
|
|
return name;
|
|
};
|
|
return { context, helper };
|
|
}
|
|
function traverseNodes(nodes, transformer) {
|
|
for (let i = 0; i < nodes.length; i++) {
|
|
traverseNode(nodes[i], transformer);
|
|
}
|
|
}
|
|
function traverseNode(node, transformer) {
|
|
switch (node.type) {
|
|
case 1:
|
|
traverseNodes(node.cases, transformer);
|
|
transformer.helper("plural");
|
|
break;
|
|
case 2:
|
|
traverseNodes(node.items, transformer);
|
|
break;
|
|
case 6:
|
|
const linked = node;
|
|
traverseNode(linked.key, transformer);
|
|
transformer.helper("linked");
|
|
break;
|
|
case 5:
|
|
transformer.helper("interpolate");
|
|
transformer.helper("list");
|
|
break;
|
|
case 4:
|
|
transformer.helper("interpolate");
|
|
transformer.helper("named");
|
|
break;
|
|
}
|
|
}
|
|
function transform(ast, options = {}) {
|
|
const transformer = createTransformer(ast);
|
|
transformer.helper("normalize");
|
|
ast.body && traverseNode(ast.body, transformer);
|
|
const context = transformer.context();
|
|
ast.helpers = Array.from(context.helpers);
|
|
}
|
|
function createCodeGenerator(ast, options) {
|
|
const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
|
|
const _context = {
|
|
source: ast.loc.source,
|
|
filename,
|
|
code: "",
|
|
column: 1,
|
|
line: 1,
|
|
offset: 0,
|
|
map: void 0,
|
|
breakLineCode,
|
|
needIndent: _needIndent,
|
|
indentLevel: 0
|
|
};
|
|
const context = () => _context;
|
|
function push(code, node) {
|
|
_context.code += code;
|
|
}
|
|
function _newline(n, withBreakLine = true) {
|
|
const _breakLineCode = withBreakLine ? breakLineCode : "";
|
|
push(_needIndent ? _breakLineCode + ` `.repeat(n) : _breakLineCode);
|
|
}
|
|
function indent(withNewLine = true) {
|
|
const level = ++_context.indentLevel;
|
|
withNewLine && _newline(level);
|
|
}
|
|
function deindent(withNewLine = true) {
|
|
const level = --_context.indentLevel;
|
|
withNewLine && _newline(level);
|
|
}
|
|
function newline() {
|
|
_newline(_context.indentLevel);
|
|
}
|
|
const helper = (key) => `_${key}`;
|
|
const needIndent = () => _context.needIndent;
|
|
return {
|
|
context,
|
|
push,
|
|
indent,
|
|
deindent,
|
|
newline,
|
|
helper,
|
|
needIndent
|
|
};
|
|
}
|
|
function generateLinkedNode(generator, node) {
|
|
const { helper } = generator;
|
|
generator.push(`${helper("linked")}(`);
|
|
generateNode(generator, node.key);
|
|
if (node.modifier) {
|
|
generator.push(`, `);
|
|
generateNode(generator, node.modifier);
|
|
}
|
|
generator.push(`)`);
|
|
}
|
|
function generateMessageNode(generator, node) {
|
|
const { helper, needIndent } = generator;
|
|
generator.push(`${helper("normalize")}([`);
|
|
generator.indent(needIndent());
|
|
const length = node.items.length;
|
|
for (let i = 0; i < length; i++) {
|
|
generateNode(generator, node.items[i]);
|
|
if (i === length - 1) {
|
|
break;
|
|
}
|
|
generator.push(", ");
|
|
}
|
|
generator.deindent(needIndent());
|
|
generator.push("])");
|
|
}
|
|
function generatePluralNode(generator, node) {
|
|
const { helper, needIndent } = generator;
|
|
if (node.cases.length > 1) {
|
|
generator.push(`${helper("plural")}([`);
|
|
generator.indent(needIndent());
|
|
const length = node.cases.length;
|
|
for (let i = 0; i < length; i++) {
|
|
generateNode(generator, node.cases[i]);
|
|
if (i === length - 1) {
|
|
break;
|
|
}
|
|
generator.push(", ");
|
|
}
|
|
generator.deindent(needIndent());
|
|
generator.push(`])`);
|
|
}
|
|
}
|
|
function generateResource(generator, node) {
|
|
if (node.body) {
|
|
generateNode(generator, node.body);
|
|
} else {
|
|
generator.push("null");
|
|
}
|
|
}
|
|
function generateNode(generator, node) {
|
|
const { helper } = generator;
|
|
switch (node.type) {
|
|
case 0:
|
|
generateResource(generator, node);
|
|
break;
|
|
case 1:
|
|
generatePluralNode(generator, node);
|
|
break;
|
|
case 2:
|
|
generateMessageNode(generator, node);
|
|
break;
|
|
case 6:
|
|
generateLinkedNode(generator, node);
|
|
break;
|
|
case 8:
|
|
generator.push(JSON.stringify(node.value), node);
|
|
break;
|
|
case 7:
|
|
generator.push(JSON.stringify(node.value), node);
|
|
break;
|
|
case 5:
|
|
generator.push(`${helper("interpolate")}(${helper("list")}(${node.index}))`, node);
|
|
break;
|
|
case 4:
|
|
generator.push(`${helper("interpolate")}(${helper("named")}(${JSON.stringify(node.key)}))`, node);
|
|
break;
|
|
case 9:
|
|
generator.push(JSON.stringify(node.value), node);
|
|
break;
|
|
case 3:
|
|
generator.push(JSON.stringify(node.value), node);
|
|
break;
|
|
}
|
|
}
|
|
const generate = (ast, options = {}) => {
|
|
const mode = isString(options.mode) ? options.mode : "normal";
|
|
const filename = isString(options.filename) ? options.filename : "message.intl";
|
|
const sourceMap = !!options.sourceMap;
|
|
const breakLineCode = options.breakLineCode != null ? options.breakLineCode : mode === "arrow" ? ";" : "\n";
|
|
const needIndent = options.needIndent ? options.needIndent : mode !== "arrow";
|
|
const helpers = ast.helpers || [];
|
|
const generator = createCodeGenerator(ast, {
|
|
mode,
|
|
filename,
|
|
sourceMap,
|
|
breakLineCode,
|
|
needIndent
|
|
});
|
|
generator.push(mode === "normal" ? `function __msg__ (ctx) {` : `(ctx) => {`);
|
|
generator.indent(needIndent);
|
|
if (helpers.length > 0) {
|
|
generator.push(`const { ${helpers.map((s) => `${s}: _${s}`).join(", ")} } = ctx`);
|
|
generator.newline();
|
|
}
|
|
generator.push(`return `);
|
|
generateNode(generator, ast);
|
|
generator.deindent(needIndent);
|
|
generator.push(`}`);
|
|
const { code, map } = generator.context();
|
|
return {
|
|
ast,
|
|
code,
|
|
map: map ? map.toJSON() : void 0
|
|
};
|
|
};
|
|
function baseCompile(source, options = {}) {
|
|
const assignedOptions = assign({}, options);
|
|
const parser = createParser(assignedOptions);
|
|
const ast = parser.parse(source);
|
|
transform(ast, assignedOptions);
|
|
return generate(ast, assignedOptions);
|
|
}
|
|
/*!
|
|
* @intlify/devtools-if v9.1.10
|
|
* (c) 2022 kazuya kawaguchi
|
|
* Released under the MIT License.
|
|
*/
|
|
const IntlifyDevToolsHooks = {
|
|
I18nInit: "i18n:init",
|
|
FunctionTranslate: "function:translate"
|
|
};
|
|
/*!
|
|
* @intlify/core-base v9.1.10
|
|
* (c) 2022 kazuya kawaguchi
|
|
* Released under the MIT License.
|
|
*/
|
|
let devtools = null;
|
|
function setDevToolsHook(hook) {
|
|
devtools = hook;
|
|
}
|
|
function initI18nDevTools(i18n, version, meta) {
|
|
devtools && devtools.emit(IntlifyDevToolsHooks.I18nInit, {
|
|
timestamp: Date.now(),
|
|
i18n,
|
|
version,
|
|
meta
|
|
});
|
|
}
|
|
const translateDevTools = /* @__PURE__ */ createDevToolsHook(IntlifyDevToolsHooks.FunctionTranslate);
|
|
function createDevToolsHook(hook) {
|
|
return (payloads) => devtools && devtools.emit(hook, payloads);
|
|
}
|
|
const VERSION = "9.1.10";
|
|
const NOT_REOSLVED = -1;
|
|
const MISSING_RESOLVE_VALUE = "";
|
|
function getDefaultLinkedModifiers() {
|
|
return {
|
|
upper: (val) => isString(val) ? val.toUpperCase() : val,
|
|
lower: (val) => isString(val) ? val.toLowerCase() : val,
|
|
capitalize: (val) => isString(val) ? `${val.charAt(0).toLocaleUpperCase()}${val.substr(1)}` : val
|
|
};
|
|
}
|
|
let _compiler;
|
|
function registerMessageCompiler(compiler) {
|
|
_compiler = compiler;
|
|
}
|
|
let _additionalMeta = null;
|
|
const setAdditionalMeta = (meta) => {
|
|
_additionalMeta = meta;
|
|
};
|
|
const getAdditionalMeta = () => _additionalMeta;
|
|
let _cid = 0;
|
|
function createCoreContext(options = {}) {
|
|
const version = isString(options.version) ? options.version : VERSION;
|
|
const locale = isString(options.locale) ? options.locale : "en-US";
|
|
const fallbackLocale = isArray(options.fallbackLocale) || isPlainObject(options.fallbackLocale) || isString(options.fallbackLocale) || options.fallbackLocale === false ? options.fallbackLocale : locale;
|
|
const messages = isPlainObject(options.messages) ? options.messages : { [locale]: {} };
|
|
const datetimeFormats = isPlainObject(options.datetimeFormats) ? options.datetimeFormats : { [locale]: {} };
|
|
const numberFormats = isPlainObject(options.numberFormats) ? options.numberFormats : { [locale]: {} };
|
|
const modifiers = assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
|
|
const pluralRules = options.pluralRules || {};
|
|
const missing = isFunction(options.missing) ? options.missing : null;
|
|
const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn) ? options.missingWarn : true;
|
|
const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn) ? options.fallbackWarn : true;
|
|
const fallbackFormat = !!options.fallbackFormat;
|
|
const unresolving = !!options.unresolving;
|
|
const postTranslation = isFunction(options.postTranslation) ? options.postTranslation : null;
|
|
const processor = isPlainObject(options.processor) ? options.processor : null;
|
|
const warnHtmlMessage = isBoolean(options.warnHtmlMessage) ? options.warnHtmlMessage : true;
|
|
const escapeParameter = !!options.escapeParameter;
|
|
const messageCompiler = isFunction(options.messageCompiler) ? options.messageCompiler : _compiler;
|
|
const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;
|
|
const internalOptions = options;
|
|
const __datetimeFormatters = isObject$1(internalOptions.__datetimeFormatters) ? internalOptions.__datetimeFormatters : /* @__PURE__ */ new Map();
|
|
const __numberFormatters = isObject$1(internalOptions.__numberFormatters) ? internalOptions.__numberFormatters : /* @__PURE__ */ new Map();
|
|
const __meta = isObject$1(internalOptions.__meta) ? internalOptions.__meta : {};
|
|
_cid++;
|
|
const context = {
|
|
version,
|
|
cid: _cid,
|
|
locale,
|
|
fallbackLocale,
|
|
messages,
|
|
datetimeFormats,
|
|
numberFormats,
|
|
modifiers,
|
|
pluralRules,
|
|
missing,
|
|
missingWarn,
|
|
fallbackWarn,
|
|
fallbackFormat,
|
|
unresolving,
|
|
postTranslation,
|
|
processor,
|
|
warnHtmlMessage,
|
|
escapeParameter,
|
|
messageCompiler,
|
|
onWarn,
|
|
__datetimeFormatters,
|
|
__numberFormatters,
|
|
__meta
|
|
};
|
|
if (__INTLIFY_PROD_DEVTOOLS__) {
|
|
initI18nDevTools(context, version, __meta);
|
|
}
|
|
return context;
|
|
}
|
|
function handleMissing(context, key, locale, missingWarn, type) {
|
|
const { missing, onWarn } = context;
|
|
if (missing !== null) {
|
|
const ret = missing(context, locale, key, type);
|
|
return isString(ret) ? ret : key;
|
|
} else {
|
|
return key;
|
|
}
|
|
}
|
|
function getLocaleChain(ctx, fallback, start) {
|
|
const context = ctx;
|
|
if (!context.__localeChainCache) {
|
|
context.__localeChainCache = /* @__PURE__ */ new Map();
|
|
}
|
|
let chain = context.__localeChainCache.get(start);
|
|
if (!chain) {
|
|
chain = [];
|
|
let block = [start];
|
|
while (isArray(block)) {
|
|
block = appendBlockToChain(chain, block, fallback);
|
|
}
|
|
const defaults = isArray(fallback) ? fallback : isPlainObject(fallback) ? fallback["default"] ? fallback["default"] : null : fallback;
|
|
block = isString(defaults) ? [defaults] : defaults;
|
|
if (isArray(block)) {
|
|
appendBlockToChain(chain, block, false);
|
|
}
|
|
context.__localeChainCache.set(start, chain);
|
|
}
|
|
return chain;
|
|
}
|
|
function appendBlockToChain(chain, block, blocks) {
|
|
let follow = true;
|
|
for (let i = 0; i < block.length && isBoolean(follow); i++) {
|
|
const locale = block[i];
|
|
if (isString(locale)) {
|
|
follow = appendLocaleToChain(chain, block[i], blocks);
|
|
}
|
|
}
|
|
return follow;
|
|
}
|
|
function appendLocaleToChain(chain, locale, blocks) {
|
|
let follow;
|
|
const tokens = locale.split("-");
|
|
do {
|
|
const target = tokens.join("-");
|
|
follow = appendItemToChain(chain, target, blocks);
|
|
tokens.splice(-1, 1);
|
|
} while (tokens.length && follow === true);
|
|
return follow;
|
|
}
|
|
function appendItemToChain(chain, target, blocks) {
|
|
let follow = false;
|
|
if (!chain.includes(target)) {
|
|
follow = true;
|
|
if (target) {
|
|
follow = target[target.length - 1] !== "!";
|
|
const locale = target.replace(/!/g, "");
|
|
chain.push(locale);
|
|
if ((isArray(blocks) || isPlainObject(blocks)) && blocks[locale]) {
|
|
follow = blocks[locale];
|
|
}
|
|
}
|
|
}
|
|
return follow;
|
|
}
|
|
function updateFallbackLocale(ctx, locale, fallback) {
|
|
const context = ctx;
|
|
context.__localeChainCache = /* @__PURE__ */ new Map();
|
|
getLocaleChain(ctx, fallback, locale);
|
|
}
|
|
const defaultOnCacheKey = (source) => source;
|
|
let compileCache = /* @__PURE__ */ Object.create(null);
|
|
function compileToFunction(source, options = {}) {
|
|
{
|
|
const onCacheKey = options.onCacheKey || defaultOnCacheKey;
|
|
const key = onCacheKey(source);
|
|
const cached = compileCache[key];
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
let occurred = false;
|
|
const onError = options.onError || defaultOnError;
|
|
options.onError = (err) => {
|
|
occurred = true;
|
|
onError(err);
|
|
};
|
|
const { code } = baseCompile(source, options);
|
|
const msg = new Function(`return ${code}`)();
|
|
return !occurred ? compileCache[key] = msg : msg;
|
|
}
|
|
}
|
|
function createCoreError(code) {
|
|
return createCompileError(code, null, void 0);
|
|
}
|
|
const NOOP_MESSAGE_FUNCTION = () => "";
|
|
const isMessageFunction = (val) => isFunction(val);
|
|
function translate(context, ...args) {
|
|
const { fallbackFormat, postTranslation, unresolving, fallbackLocale, messages } = context;
|
|
const [key, options] = parseTranslateArgs(...args);
|
|
const missingWarn = isBoolean(options.missingWarn) ? options.missingWarn : context.missingWarn;
|
|
const fallbackWarn = isBoolean(options.fallbackWarn) ? options.fallbackWarn : context.fallbackWarn;
|
|
const escapeParameter = isBoolean(options.escapeParameter) ? options.escapeParameter : context.escapeParameter;
|
|
const resolvedMessage = !!options.resolvedMessage;
|
|
const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) ? !isBoolean(options.default) ? options.default : key : fallbackFormat ? key : "";
|
|
const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== "";
|
|
const locale = isString(options.locale) ? options.locale : context.locale;
|
|
escapeParameter && escapeParams(options);
|
|
let [format, targetLocale, message] = !resolvedMessage ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) : [
|
|
key,
|
|
locale,
|
|
messages[locale] || {}
|
|
];
|
|
let cacheBaseKey = key;
|
|
if (!resolvedMessage && !(isString(format) || isMessageFunction(format))) {
|
|
if (enableDefaultMsg) {
|
|
format = defaultMsgOrKey;
|
|
cacheBaseKey = format;
|
|
}
|
|
}
|
|
if (!resolvedMessage && (!(isString(format) || isMessageFunction(format)) || !isString(targetLocale))) {
|
|
return unresolving ? NOT_REOSLVED : key;
|
|
}
|
|
let occurred = false;
|
|
const errorDetector = () => {
|
|
occurred = true;
|
|
};
|
|
const msg = !isMessageFunction(format) ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, errorDetector) : format;
|
|
if (occurred) {
|
|
return format;
|
|
}
|
|
const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
|
|
const msgContext = createMessageContext(ctxOptions);
|
|
const messaged = evaluateMessage(context, msg, msgContext);
|
|
const ret = postTranslation ? postTranslation(messaged) : messaged;
|
|
if (__INTLIFY_PROD_DEVTOOLS__) {
|
|
const payloads = {
|
|
timestamp: Date.now(),
|
|
key: isString(key) ? key : isMessageFunction(format) ? format.key : "",
|
|
locale: targetLocale || (isMessageFunction(format) ? format.locale : ""),
|
|
format: isString(format) ? format : isMessageFunction(format) ? format.source : "",
|
|
message: ret
|
|
};
|
|
payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
|
|
translateDevTools(payloads);
|
|
}
|
|
return ret;
|
|
}
|
|
function escapeParams(options) {
|
|
if (isArray(options.list)) {
|
|
options.list = options.list.map((item) => isString(item) ? escapeHtml(item) : item);
|
|
} else if (isObject$1(options.named)) {
|
|
Object.keys(options.named).forEach((key) => {
|
|
if (isString(options.named[key])) {
|
|
options.named[key] = escapeHtml(options.named[key]);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
|
|
const { messages, onWarn } = context;
|
|
const locales = getLocaleChain(context, fallbackLocale, locale);
|
|
let message = {};
|
|
let targetLocale;
|
|
let format = null;
|
|
const type = "translate";
|
|
for (let i = 0; i < locales.length; i++) {
|
|
targetLocale = locales[i];
|
|
message = messages[targetLocale] || {};
|
|
if ((format = resolveValue(message, key)) === null) {
|
|
format = message[key];
|
|
}
|
|
if (isString(format) || isFunction(format))
|
|
break;
|
|
const missingRet = handleMissing(context, key, targetLocale, missingWarn, type);
|
|
if (missingRet !== key) {
|
|
format = missingRet;
|
|
}
|
|
}
|
|
return [format, targetLocale, message];
|
|
}
|
|
function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, errorDetector) {
|
|
const { messageCompiler, warnHtmlMessage } = context;
|
|
if (isMessageFunction(format)) {
|
|
const msg2 = format;
|
|
msg2.locale = msg2.locale || targetLocale;
|
|
msg2.key = msg2.key || key;
|
|
return msg2;
|
|
}
|
|
const msg = messageCompiler(format, getCompileOptions(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, errorDetector));
|
|
msg.locale = targetLocale;
|
|
msg.key = key;
|
|
msg.source = format;
|
|
return msg;
|
|
}
|
|
function evaluateMessage(context, msg, msgCtx) {
|
|
const messaged = msg(msgCtx);
|
|
return messaged;
|
|
}
|
|
function parseTranslateArgs(...args) {
|
|
const [arg1, arg2, arg3] = args;
|
|
const options = {};
|
|
if (!isString(arg1) && !isNumber(arg1) && !isMessageFunction(arg1)) {
|
|
throw createCoreError(14);
|
|
}
|
|
const key = isNumber(arg1) ? String(arg1) : isMessageFunction(arg1) ? arg1 : arg1;
|
|
if (isNumber(arg2)) {
|
|
options.plural = arg2;
|
|
} else if (isString(arg2)) {
|
|
options.default = arg2;
|
|
} else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
|
|
options.named = arg2;
|
|
} else if (isArray(arg2)) {
|
|
options.list = arg2;
|
|
}
|
|
if (isNumber(arg3)) {
|
|
options.plural = arg3;
|
|
} else if (isString(arg3)) {
|
|
options.default = arg3;
|
|
} else if (isPlainObject(arg3)) {
|
|
assign(options, arg3);
|
|
}
|
|
return [key, options];
|
|
}
|
|
function getCompileOptions(context, locale, key, source, warnHtmlMessage, errorDetector) {
|
|
return {
|
|
warnHtmlMessage,
|
|
onError: (err) => {
|
|
errorDetector && errorDetector(err);
|
|
{
|
|
throw err;
|
|
}
|
|
},
|
|
onCacheKey: (source2) => generateFormatCacheKey(locale, key, source2)
|
|
};
|
|
}
|
|
function getMessageContextOptions(context, locale, message, options) {
|
|
const { modifiers, pluralRules } = context;
|
|
const resolveMessage = (key) => {
|
|
const val = resolveValue(message, key);
|
|
if (isString(val)) {
|
|
let occurred = false;
|
|
const errorDetector = () => {
|
|
occurred = true;
|
|
};
|
|
const msg = compileMessageFormat(context, key, locale, val, key, errorDetector);
|
|
return !occurred ? msg : NOOP_MESSAGE_FUNCTION;
|
|
} else if (isMessageFunction(val)) {
|
|
return val;
|
|
} else {
|
|
return NOOP_MESSAGE_FUNCTION;
|
|
}
|
|
};
|
|
const ctxOptions = {
|
|
locale,
|
|
modifiers,
|
|
pluralRules,
|
|
messages: resolveMessage
|
|
};
|
|
if (context.processor) {
|
|
ctxOptions.processor = context.processor;
|
|
}
|
|
if (options.list) {
|
|
ctxOptions.list = options.list;
|
|
}
|
|
if (options.named) {
|
|
ctxOptions.named = options.named;
|
|
}
|
|
if (isNumber(options.plural)) {
|
|
ctxOptions.pluralIndex = options.plural;
|
|
}
|
|
return ctxOptions;
|
|
}
|
|
function datetime(context, ...args) {
|
|
const { datetimeFormats, unresolving, fallbackLocale, onWarn } = context;
|
|
const { __datetimeFormatters } = context;
|
|
const [key, value, options, overrides] = parseDateTimeArgs(...args);
|
|
const missingWarn = isBoolean(options.missingWarn) ? options.missingWarn : context.missingWarn;
|
|
isBoolean(options.fallbackWarn) ? options.fallbackWarn : context.fallbackWarn;
|
|
const part = !!options.part;
|
|
const locale = isString(options.locale) ? options.locale : context.locale;
|
|
const locales = getLocaleChain(context, fallbackLocale, locale);
|
|
if (!isString(key) || key === "") {
|
|
return new Intl.DateTimeFormat(locale).format(value);
|
|
}
|
|
let datetimeFormat = {};
|
|
let targetLocale;
|
|
let format = null;
|
|
const type = "datetime format";
|
|
for (let i = 0; i < locales.length; i++) {
|
|
targetLocale = locales[i];
|
|
datetimeFormat = datetimeFormats[targetLocale] || {};
|
|
format = datetimeFormat[key];
|
|
if (isPlainObject(format))
|
|
break;
|
|
handleMissing(context, key, targetLocale, missingWarn, type);
|
|
}
|
|
if (!isPlainObject(format) || !isString(targetLocale)) {
|
|
return unresolving ? NOT_REOSLVED : key;
|
|
}
|
|
let id = `${targetLocale}__${key}`;
|
|
if (!isEmptyObject(overrides)) {
|
|
id = `${id}__${JSON.stringify(overrides)}`;
|
|
}
|
|
let formatter = __datetimeFormatters.get(id);
|
|
if (!formatter) {
|
|
formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
|
|
__datetimeFormatters.set(id, formatter);
|
|
}
|
|
return !part ? formatter.format(value) : formatter.formatToParts(value);
|
|
}
|
|
function parseDateTimeArgs(...args) {
|
|
const [arg1, arg2, arg3, arg4] = args;
|
|
let options = {};
|
|
let overrides = {};
|
|
let value;
|
|
if (isString(arg1)) {
|
|
if (!/\d{4}-\d{2}-\d{2}(T.*)?/.test(arg1)) {
|
|
throw createCoreError(16);
|
|
}
|
|
value = new Date(arg1);
|
|
try {
|
|
value.toISOString();
|
|
} catch (e) {
|
|
throw createCoreError(16);
|
|
}
|
|
} else if (isDate(arg1)) {
|
|
if (isNaN(arg1.getTime())) {
|
|
throw createCoreError(15);
|
|
}
|
|
value = arg1;
|
|
} else if (isNumber(arg1)) {
|
|
value = arg1;
|
|
} else {
|
|
throw createCoreError(14);
|
|
}
|
|
if (isString(arg2)) {
|
|
options.key = arg2;
|
|
} else if (isPlainObject(arg2)) {
|
|
options = arg2;
|
|
}
|
|
if (isString(arg3)) {
|
|
options.locale = arg3;
|
|
} else if (isPlainObject(arg3)) {
|
|
overrides = arg3;
|
|
}
|
|
if (isPlainObject(arg4)) {
|
|
overrides = arg4;
|
|
}
|
|
return [options.key || "", value, options, overrides];
|
|
}
|
|
function clearDateTimeFormat(ctx, locale, format) {
|
|
const context = ctx;
|
|
for (const key in format) {
|
|
const id = `${locale}__${key}`;
|
|
if (!context.__datetimeFormatters.has(id)) {
|
|
continue;
|
|
}
|
|
context.__datetimeFormatters.delete(id);
|
|
}
|
|
}
|
|
function number(context, ...args) {
|
|
const { numberFormats, unresolving, fallbackLocale, onWarn } = context;
|
|
const { __numberFormatters } = context;
|
|
const [key, value, options, overrides] = parseNumberArgs(...args);
|
|
const missingWarn = isBoolean(options.missingWarn) ? options.missingWarn : context.missingWarn;
|
|
isBoolean(options.fallbackWarn) ? options.fallbackWarn : context.fallbackWarn;
|
|
const part = !!options.part;
|
|
const locale = isString(options.locale) ? options.locale : context.locale;
|
|
const locales = getLocaleChain(context, fallbackLocale, locale);
|
|
if (!isString(key) || key === "") {
|
|
return new Intl.NumberFormat(locale).format(value);
|
|
}
|
|
let numberFormat = {};
|
|
let targetLocale;
|
|
let format = null;
|
|
const type = "number format";
|
|
for (let i = 0; i < locales.length; i++) {
|
|
targetLocale = locales[i];
|
|
numberFormat = numberFormats[targetLocale] || {};
|
|
format = numberFormat[key];
|
|
if (isPlainObject(format))
|
|
break;
|
|
handleMissing(context, key, targetLocale, missingWarn, type);
|
|
}
|
|
if (!isPlainObject(format) || !isString(targetLocale)) {
|
|
return unresolving ? NOT_REOSLVED : key;
|
|
}
|
|
let id = `${targetLocale}__${key}`;
|
|
if (!isEmptyObject(overrides)) {
|
|
id = `${id}__${JSON.stringify(overrides)}`;
|
|
}
|
|
let formatter = __numberFormatters.get(id);
|
|
if (!formatter) {
|
|
formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));
|
|
__numberFormatters.set(id, formatter);
|
|
}
|
|
return !part ? formatter.format(value) : formatter.formatToParts(value);
|
|
}
|
|
function parseNumberArgs(...args) {
|
|
const [arg1, arg2, arg3, arg4] = args;
|
|
let options = {};
|
|
let overrides = {};
|
|
if (!isNumber(arg1)) {
|
|
throw createCoreError(14);
|
|
}
|
|
const value = arg1;
|
|
if (isString(arg2)) {
|
|
options.key = arg2;
|
|
} else if (isPlainObject(arg2)) {
|
|
options = arg2;
|
|
}
|
|
if (isString(arg3)) {
|
|
options.locale = arg3;
|
|
} else if (isPlainObject(arg3)) {
|
|
overrides = arg3;
|
|
}
|
|
if (isPlainObject(arg4)) {
|
|
overrides = arg4;
|
|
}
|
|
return [options.key || "", value, options, overrides];
|
|
}
|
|
function clearNumberFormat(ctx, locale, format) {
|
|
const context = ctx;
|
|
for (const key in format) {
|
|
const id = `${locale}__${key}`;
|
|
if (!context.__numberFormatters.has(id)) {
|
|
continue;
|
|
}
|
|
context.__numberFormatters.delete(id);
|
|
}
|
|
}
|
|
{
|
|
if (typeof __INTLIFY_PROD_DEVTOOLS__ !== "boolean") {
|
|
getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;
|
|
}
|
|
}
|
|
export { parseDateTimeArgs as A, datetime as B, parseNumberArgs as C, number as D, getLocaleChain as E, MISSING_RESOLVE_VALUE as M, NOT_REOSLVED as N, assign as a, isString as b, isObject$1 as c, isArray as d, isBoolean as e, createCompileError as f, isEmptyObject as g, getGlobalThis as h, isNumber as i, isPlainObject as j, hasOwn$1 as k, handleFlatJson as l, makeSymbol as m, isRegExp as n, isFunction as o, createCoreContext as p, compileToFunction as q, registerMessageCompiler as r, setDevToolsHook as s, resolveValue as t, updateFallbackLocale as u, clearDateTimeFormat as v, clearNumberFormat as w, setAdditionalMeta as x, parseTranslateArgs as y, translate as z };
|