mirror of
https://github.com/cupcakearmy/svelte-i18n.git
synced 2024-08-19 19:54:38 +02:00
3320 lines
106 KiB
JavaScript
3320 lines
106 KiB
JavaScript
var app = (function () {
|
|
'use strict';
|
|
|
|
function noop() { }
|
|
function add_location(element, file, line, column, char) {
|
|
element.__svelte_meta = {
|
|
loc: { file, line, column, char }
|
|
};
|
|
}
|
|
function run(fn) {
|
|
return fn();
|
|
}
|
|
function blank_object() {
|
|
return Object.create(null);
|
|
}
|
|
function run_all(fns) {
|
|
fns.forEach(run);
|
|
}
|
|
function is_function(thing) {
|
|
return typeof thing === 'function';
|
|
}
|
|
function safe_not_equal(a, b) {
|
|
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
|
|
}
|
|
function validate_store(store, name) {
|
|
if (!store || typeof store.subscribe !== 'function') {
|
|
throw new Error(`'${name}' is not a store with a 'subscribe' method`);
|
|
}
|
|
}
|
|
function subscribe(component, store, callback) {
|
|
const unsub = store.subscribe(callback);
|
|
component.$$.on_destroy.push(unsub.unsubscribe
|
|
? () => unsub.unsubscribe()
|
|
: unsub);
|
|
}
|
|
|
|
function append(target, node) {
|
|
target.appendChild(node);
|
|
}
|
|
function insert(target, node, anchor) {
|
|
target.insertBefore(node, anchor || null);
|
|
}
|
|
function detach(node) {
|
|
node.parentNode.removeChild(node);
|
|
}
|
|
function element(name) {
|
|
return document.createElement(name);
|
|
}
|
|
function text(data) {
|
|
return document.createTextNode(data);
|
|
}
|
|
function space() {
|
|
return text(' ');
|
|
}
|
|
function listen(node, event, handler, options) {
|
|
node.addEventListener(event, handler, options);
|
|
return () => node.removeEventListener(event, handler, options);
|
|
}
|
|
function attr(node, attribute, value) {
|
|
if (value == null)
|
|
node.removeAttribute(attribute);
|
|
else
|
|
node.setAttribute(attribute, value);
|
|
}
|
|
function to_number(value) {
|
|
return value === '' ? undefined : +value;
|
|
}
|
|
function children(element) {
|
|
return Array.from(element.childNodes);
|
|
}
|
|
function set_data(text, data) {
|
|
data = '' + data;
|
|
if (text.data !== data)
|
|
text.data = data;
|
|
}
|
|
|
|
let current_component;
|
|
function set_current_component(component) {
|
|
current_component = component;
|
|
}
|
|
|
|
const dirty_components = [];
|
|
const resolved_promise = Promise.resolve();
|
|
let update_scheduled = false;
|
|
const binding_callbacks = [];
|
|
const render_callbacks = [];
|
|
const flush_callbacks = [];
|
|
function schedule_update() {
|
|
if (!update_scheduled) {
|
|
update_scheduled = true;
|
|
resolved_promise.then(flush);
|
|
}
|
|
}
|
|
function add_render_callback(fn) {
|
|
render_callbacks.push(fn);
|
|
}
|
|
function flush() {
|
|
const seen_callbacks = new Set();
|
|
do {
|
|
// first, call beforeUpdate functions
|
|
// and update components
|
|
while (dirty_components.length) {
|
|
const component = dirty_components.shift();
|
|
set_current_component(component);
|
|
update(component.$$);
|
|
}
|
|
while (binding_callbacks.length)
|
|
binding_callbacks.shift()();
|
|
// then, once components are updated, call
|
|
// afterUpdate functions. This may cause
|
|
// subsequent updates...
|
|
while (render_callbacks.length) {
|
|
const callback = render_callbacks.pop();
|
|
if (!seen_callbacks.has(callback)) {
|
|
callback();
|
|
// ...so guard against infinite loops
|
|
seen_callbacks.add(callback);
|
|
}
|
|
}
|
|
} while (dirty_components.length);
|
|
while (flush_callbacks.length) {
|
|
flush_callbacks.pop()();
|
|
}
|
|
update_scheduled = false;
|
|
}
|
|
function update($$) {
|
|
if ($$.fragment) {
|
|
$$.update($$.dirty);
|
|
run_all($$.before_render);
|
|
$$.fragment.p($$.dirty, $$.ctx);
|
|
$$.dirty = null;
|
|
$$.after_render.forEach(add_render_callback);
|
|
}
|
|
}
|
|
function mount_component(component, target, anchor) {
|
|
const { fragment, on_mount, on_destroy, after_render } = component.$$;
|
|
fragment.m(target, anchor);
|
|
// onMount happens after the initial afterUpdate. Because
|
|
// afterUpdate callbacks happen in reverse order (inner first)
|
|
// we schedule onMount callbacks before afterUpdate callbacks
|
|
add_render_callback(() => {
|
|
const new_on_destroy = on_mount.map(run).filter(is_function);
|
|
if (on_destroy) {
|
|
on_destroy.push(...new_on_destroy);
|
|
}
|
|
else {
|
|
// Edge case - component was destroyed immediately,
|
|
// most likely as a result of a binding initialising
|
|
run_all(new_on_destroy);
|
|
}
|
|
component.$$.on_mount = [];
|
|
});
|
|
after_render.forEach(add_render_callback);
|
|
}
|
|
function destroy(component, detaching) {
|
|
if (component.$$) {
|
|
run_all(component.$$.on_destroy);
|
|
component.$$.fragment.d(detaching);
|
|
// TODO null out other refs, including component.$$ (but need to
|
|
// preserve final state?)
|
|
component.$$.on_destroy = component.$$.fragment = null;
|
|
component.$$.ctx = {};
|
|
}
|
|
}
|
|
function make_dirty(component, key) {
|
|
if (!component.$$.dirty) {
|
|
dirty_components.push(component);
|
|
schedule_update();
|
|
component.$$.dirty = blank_object();
|
|
}
|
|
component.$$.dirty[key] = true;
|
|
}
|
|
function init(component, options, instance, create_fragment, not_equal$$1, prop_names) {
|
|
const parent_component = current_component;
|
|
set_current_component(component);
|
|
const props = options.props || {};
|
|
const $$ = component.$$ = {
|
|
fragment: null,
|
|
ctx: null,
|
|
// state
|
|
props: prop_names,
|
|
update: noop,
|
|
not_equal: not_equal$$1,
|
|
bound: blank_object(),
|
|
// lifecycle
|
|
on_mount: [],
|
|
on_destroy: [],
|
|
before_render: [],
|
|
after_render: [],
|
|
context: new Map(parent_component ? parent_component.$$.context : []),
|
|
// everything else
|
|
callbacks: blank_object(),
|
|
dirty: null
|
|
};
|
|
let ready = false;
|
|
$$.ctx = instance
|
|
? instance(component, props, (key, value) => {
|
|
if ($$.ctx && not_equal$$1($$.ctx[key], $$.ctx[key] = value)) {
|
|
if ($$.bound[key])
|
|
$$.bound[key](value);
|
|
if (ready)
|
|
make_dirty(component, key);
|
|
}
|
|
})
|
|
: props;
|
|
$$.update();
|
|
ready = true;
|
|
run_all($$.before_render);
|
|
$$.fragment = create_fragment($$.ctx);
|
|
if (options.target) {
|
|
if (options.hydrate) {
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
$$.fragment.l(children(options.target));
|
|
}
|
|
else {
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
$$.fragment.c();
|
|
}
|
|
if (options.intro && component.$$.fragment.i)
|
|
component.$$.fragment.i();
|
|
mount_component(component, options.target, options.anchor);
|
|
flush();
|
|
}
|
|
set_current_component(parent_component);
|
|
}
|
|
class SvelteComponent {
|
|
$destroy() {
|
|
destroy(this, true);
|
|
this.$destroy = noop;
|
|
}
|
|
$on(type, callback) {
|
|
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
|
|
callbacks.push(callback);
|
|
return () => {
|
|
const index = callbacks.indexOf(callback);
|
|
if (index !== -1)
|
|
callbacks.splice(index, 1);
|
|
};
|
|
}
|
|
$set() {
|
|
// overridden by instance, if it has props
|
|
}
|
|
}
|
|
class SvelteComponentDev extends SvelteComponent {
|
|
constructor(options) {
|
|
if (!options || (!options.target && !options.$$inline)) {
|
|
throw new Error(`'target' is a required option`);
|
|
}
|
|
super();
|
|
}
|
|
$destroy() {
|
|
super.$destroy();
|
|
this.$destroy = () => {
|
|
console.warn(`Component was already destroyed`); // eslint-disable-line no-console
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a `Readable` store that allows reading by subscription.
|
|
* @param value initial value
|
|
* @param {StartStopNotifier}start start and stop notifications for subscriptions
|
|
*/
|
|
function readable(value, start) {
|
|
return {
|
|
subscribe: writable(value, start).subscribe,
|
|
};
|
|
}
|
|
/**
|
|
* Create a `Writable` store that allows both updating and reading by subscription.
|
|
* @param {*=}value initial value
|
|
* @param {StartStopNotifier=}start start and stop notifications for subscriptions
|
|
*/
|
|
function writable(value, start = noop) {
|
|
let stop;
|
|
const subscribers = [];
|
|
function set(new_value) {
|
|
if (safe_not_equal(value, new_value)) {
|
|
value = new_value;
|
|
if (!stop) {
|
|
return; // not ready
|
|
}
|
|
subscribers.forEach((s) => s[1]());
|
|
subscribers.forEach((s) => s[0](value));
|
|
}
|
|
}
|
|
function update(fn) {
|
|
set(fn(value));
|
|
}
|
|
function subscribe(run, invalidate = noop) {
|
|
const subscriber = [run, invalidate];
|
|
subscribers.push(subscriber);
|
|
if (subscribers.length === 1) {
|
|
stop = start(set) || noop;
|
|
}
|
|
run(value);
|
|
return () => {
|
|
const index = subscribers.indexOf(subscriber);
|
|
if (index !== -1) {
|
|
subscribers.splice(index, 1);
|
|
}
|
|
if (subscribers.length === 0) {
|
|
stop();
|
|
}
|
|
};
|
|
}
|
|
return { set, update, subscribe };
|
|
}
|
|
/**
|
|
* Derived value store by synchronizing one or more readable stores and
|
|
* applying an aggregation function over its input values.
|
|
* @param {Stores} stores input stores
|
|
* @param {function(Stores=, function(*)=):*}fn function callback that aggregates the values
|
|
* @param {*=}initial_value when used asynchronously
|
|
*/
|
|
function derived(stores, fn, initial_value) {
|
|
const single = !Array.isArray(stores);
|
|
const stores_array = single
|
|
? [stores]
|
|
: stores;
|
|
const auto = fn.length < 2;
|
|
const invalidators = [];
|
|
const store = readable(initial_value, (set) => {
|
|
let inited = false;
|
|
const values = [];
|
|
let pending = 0;
|
|
let cleanup = noop;
|
|
const sync = () => {
|
|
if (pending) {
|
|
return;
|
|
}
|
|
cleanup();
|
|
const result = fn(single ? values[0] : values, set);
|
|
if (auto) {
|
|
set(result);
|
|
}
|
|
else {
|
|
cleanup = is_function(result) ? result : noop;
|
|
}
|
|
};
|
|
const unsubscribers = stores_array.map((store, i) => store.subscribe((value) => {
|
|
values[i] = value;
|
|
pending &= ~(1 << i);
|
|
if (inited) {
|
|
sync();
|
|
}
|
|
}, () => {
|
|
run_all(invalidators);
|
|
pending |= (1 << i);
|
|
}));
|
|
inited = true;
|
|
sync();
|
|
return function stop() {
|
|
run_all(unsubscribers);
|
|
cleanup();
|
|
};
|
|
});
|
|
return {
|
|
subscribe(run, invalidate = noop) {
|
|
invalidators.push(invalidate);
|
|
const unsubscribe = store.subscribe(run, invalidate);
|
|
return () => {
|
|
const index = invalidators.indexOf(invalidate);
|
|
if (index !== -1) {
|
|
invalidators.splice(index, 1);
|
|
}
|
|
unsubscribe();
|
|
};
|
|
}
|
|
};
|
|
}
|
|
|
|
// gutted from https://github.com/Polymer/observe-js/blob/master/src/observe.js
|
|
function noop$1 () {}
|
|
function detectEval () {
|
|
// Don't test for eval if we're running in a Chrome App environment.
|
|
// We check for APIs set that only exist in a Chrome App context.
|
|
if (typeof chrome !== 'undefined' && chrome.app && chrome.app.runtime) {
|
|
return false
|
|
}
|
|
|
|
// Firefox OS Apps do not allow eval. This feature detection is very hacky
|
|
// but even if some other platform adds support for this function this code
|
|
// will continue to work.
|
|
if (typeof navigator != 'undefined' && navigator.getDeviceStorage) {
|
|
return false
|
|
}
|
|
|
|
try {
|
|
var f = new Function('', 'return true;');
|
|
return f()
|
|
} catch (ex) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
var hasEval = detectEval();
|
|
|
|
function isIndex (s) {
|
|
return +s === s >>> 0 && s !== ''
|
|
}
|
|
|
|
function isObject (obj) {
|
|
return obj === Object(obj)
|
|
}
|
|
|
|
var createObject = ('__proto__' in {}) ?
|
|
function (obj) {
|
|
return obj
|
|
} :
|
|
function (obj) {
|
|
var proto = obj.__proto__;
|
|
if (!proto)
|
|
return obj
|
|
var newObject = Object.create(proto);
|
|
Object.getOwnPropertyNames(obj).forEach(function (name) {
|
|
Object.defineProperty(newObject, name,
|
|
Object.getOwnPropertyDescriptor(obj, name));
|
|
});
|
|
return newObject
|
|
};
|
|
|
|
function parsePath (path) {
|
|
var keys = [];
|
|
var index = -1;
|
|
var c, newChar, key, type, transition, action, typeMap, mode = 'beforePath';
|
|
|
|
var actions = {
|
|
push: function () {
|
|
if (key === undefined)
|
|
return
|
|
|
|
keys.push(key);
|
|
key = undefined;
|
|
},
|
|
|
|
append: function () {
|
|
if (key === undefined)
|
|
key = newChar;
|
|
else
|
|
key += newChar;
|
|
}
|
|
};
|
|
|
|
function maybeUnescapeQuote () {
|
|
if (index >= path.length)
|
|
return
|
|
|
|
var nextChar = path[index + 1];
|
|
if ((mode == 'inSingleQuote' && nextChar == "'") ||
|
|
(mode == 'inDoubleQuote' && nextChar == '"')) {
|
|
index++;
|
|
newChar = nextChar;
|
|
actions.append();
|
|
return true
|
|
}
|
|
}
|
|
|
|
while (mode) {
|
|
index++;
|
|
c = path[index];
|
|
|
|
if (c == '\\' && maybeUnescapeQuote())
|
|
continue
|
|
|
|
type = getPathCharType(c);
|
|
typeMap = pathStateMachine[mode];
|
|
transition = typeMap[type] || typeMap['else'] || 'error';
|
|
|
|
if (transition == 'error')
|
|
return // parse error
|
|
|
|
mode = transition[0];
|
|
action = actions[transition[1]] || noop$1;
|
|
newChar = transition[2] === undefined ? c : transition[2];
|
|
action();
|
|
|
|
if (mode === 'afterPath') {
|
|
return keys
|
|
}
|
|
}
|
|
|
|
return // parse error
|
|
}
|
|
|
|
var identStart = '[\$_a-zA-Z]';
|
|
var identPart = '[\$_a-zA-Z0-9]';
|
|
var identRegExp = new RegExp('^' + identStart + '+' + identPart + '*' + '$');
|
|
|
|
function isIdent (s) {
|
|
return identRegExp.test(s)
|
|
}
|
|
|
|
var constructorIsPrivate = {};
|
|
|
|
function Path (parts, privateToken) {
|
|
if (privateToken !== constructorIsPrivate)
|
|
throw Error('Use Path.get to retrieve path objects')
|
|
|
|
for (var i = 0; i < parts.length; i++) {
|
|
this.push(String(parts[i]));
|
|
}
|
|
|
|
if (hasEval && this.length) {
|
|
this.getValueFrom = this.compiledGetValueFromFn();
|
|
}
|
|
}
|
|
|
|
var pathCache = {};
|
|
|
|
function getPath (pathString) {
|
|
if (pathString instanceof Path)
|
|
return pathString
|
|
|
|
if (pathString == null || pathString.length == 0)
|
|
pathString = '';
|
|
|
|
if (typeof pathString != 'string') {
|
|
if (isIndex(pathString.length)) {
|
|
// Constructed with array-like (pre-parsed) keys
|
|
return new Path(pathString, constructorIsPrivate)
|
|
}
|
|
|
|
pathString = String(pathString);
|
|
}
|
|
|
|
var path = pathCache[pathString];
|
|
if (path)
|
|
return path
|
|
|
|
var parts = parsePath(pathString);
|
|
if (!parts)
|
|
return invalidPath
|
|
|
|
var path = new Path(parts, constructorIsPrivate);
|
|
pathCache[pathString] = path;
|
|
return path
|
|
}
|
|
|
|
Path.get = getPath;
|
|
|
|
function formatAccessor (key) {
|
|
if (isIndex(key)) {
|
|
return '[' + key + ']'
|
|
} else {
|
|
return '["' + key.replace(/"/g, '\\"') + '"]'
|
|
}
|
|
}
|
|
|
|
Path.prototype = createObject({
|
|
__proto__: [],
|
|
valid: true,
|
|
|
|
toString: function () {
|
|
var pathString = '';
|
|
for (var i = 0; i < this.length; i++) {
|
|
var key = this[i];
|
|
if (isIdent(key)) {
|
|
pathString += i ? '.' + key : key;
|
|
} else {
|
|
pathString += formatAccessor(key);
|
|
}
|
|
}
|
|
|
|
return pathString
|
|
},
|
|
|
|
getValueFrom: function (obj, directObserver) {
|
|
for (var i = 0; i < this.length; i++) {
|
|
if (obj == null)
|
|
return
|
|
obj = obj[this[i]];
|
|
}
|
|
return obj
|
|
},
|
|
|
|
iterateObjects: function (obj, observe) {
|
|
for (var i = 0; i < this.length; i++) {
|
|
if (i)
|
|
obj = obj[this[i - 1]];
|
|
if (!isObject(obj))
|
|
return
|
|
observe(obj, this[i]);
|
|
}
|
|
},
|
|
|
|
compiledGetValueFromFn: function () {
|
|
var str = '';
|
|
var pathString = 'obj';
|
|
str += 'if (obj != null';
|
|
var i = 0;
|
|
var key;
|
|
for (; i < (this.length - 1); i++) {
|
|
key = this[i];
|
|
pathString += isIdent(key) ? '.' + key : formatAccessor(key);
|
|
str += ' &&\n ' + pathString + ' != null';
|
|
}
|
|
str += ')\n';
|
|
|
|
var key = this[i];
|
|
pathString += isIdent(key) ? '.' + key : formatAccessor(key);
|
|
|
|
str += ' return ' + pathString + ';\nelse\n return undefined;';
|
|
return new Function('obj', str)
|
|
},
|
|
|
|
setValueFrom: function (obj, value) {
|
|
if (!this.length)
|
|
return false
|
|
|
|
for (var i = 0; i < this.length - 1; i++) {
|
|
if (!isObject(obj))
|
|
return false
|
|
obj = obj[this[i]];
|
|
}
|
|
|
|
if (!isObject(obj))
|
|
return false
|
|
|
|
obj[this[i]] = value;
|
|
return true
|
|
}
|
|
});
|
|
|
|
function getPathCharType (char) {
|
|
if (char === undefined)
|
|
return 'eof'
|
|
|
|
var code = char.charCodeAt(0);
|
|
|
|
switch (code) {
|
|
case 0x5B: // [
|
|
case 0x5D: // ]
|
|
case 0x2E: // .
|
|
case 0x22: // "
|
|
case 0x27: // '
|
|
case 0x30: // 0
|
|
return char
|
|
|
|
case 0x5F: // _
|
|
case 0x24: // $
|
|
return 'ident'
|
|
|
|
case 0x20: // Space
|
|
case 0x09: // Tab
|
|
case 0x0A: // Newline
|
|
case 0x0D: // Return
|
|
case 0xA0: // No-break space
|
|
case 0xFEFF: // Byte Order Mark
|
|
case 0x2028: // Line Separator
|
|
case 0x2029: // Paragraph Separator
|
|
return 'ws'
|
|
}
|
|
|
|
// a-z, A-Z
|
|
if ((0x61 <= code && code <= 0x7A) || (0x41 <= code && code <= 0x5A))
|
|
return 'ident'
|
|
|
|
// 1-9
|
|
if (0x31 <= code && code <= 0x39)
|
|
return 'number'
|
|
|
|
return 'else'
|
|
}
|
|
|
|
var pathStateMachine = {
|
|
'beforePath': {
|
|
'ws': ['beforePath'],
|
|
'ident': ['inIdent', 'append'],
|
|
'[': ['beforeElement'],
|
|
'eof': ['afterPath']
|
|
},
|
|
|
|
'inPath': {
|
|
'ws': ['inPath'],
|
|
'.': ['beforeIdent'],
|
|
'[': ['beforeElement'],
|
|
'eof': ['afterPath']
|
|
},
|
|
|
|
'beforeIdent': {
|
|
'ws': ['beforeIdent'],
|
|
'ident': ['inIdent', 'append']
|
|
},
|
|
|
|
'inIdent': {
|
|
'ident': ['inIdent', 'append'],
|
|
'0': ['inIdent', 'append'],
|
|
'number': ['inIdent', 'append'],
|
|
'ws': ['inPath', 'push'],
|
|
'.': ['beforeIdent', 'push'],
|
|
'[': ['beforeElement', 'push'],
|
|
'eof': ['afterPath', 'push']
|
|
},
|
|
|
|
'beforeElement': {
|
|
'ws': ['beforeElement'],
|
|
'0': ['afterZero', 'append'],
|
|
'number': ['inIndex', 'append'],
|
|
"'": ['inSingleQuote', 'append', ''],
|
|
'"': ['inDoubleQuote', 'append', '']
|
|
},
|
|
|
|
'afterZero': {
|
|
'ws': ['afterElement', 'push'],
|
|
']': ['inPath', 'push']
|
|
},
|
|
|
|
'inIndex': {
|
|
'0': ['inIndex', 'append'],
|
|
'number': ['inIndex', 'append'],
|
|
'ws': ['afterElement'],
|
|
']': ['inPath', 'push']
|
|
},
|
|
|
|
'inSingleQuote': {
|
|
"'": ['afterElement'],
|
|
'eof': ['error'],
|
|
'else': ['inSingleQuote', 'append']
|
|
},
|
|
|
|
'inDoubleQuote': {
|
|
'"': ['afterElement'],
|
|
'eof': ['error'],
|
|
'else': ['inDoubleQuote', 'append']
|
|
},
|
|
|
|
'afterElement': {
|
|
'ws': ['afterElement'],
|
|
']': ['inPath', 'push']
|
|
}
|
|
};
|
|
|
|
var invalidPath = new Path('', constructorIsPrivate);
|
|
invalidPath.valid = false;
|
|
invalidPath.getValueFrom = invalidPath.setValueFrom = function () {};
|
|
|
|
var path = Path;
|
|
|
|
/**
|
|
*
|
|
* @param {Object} o
|
|
* @param {String} path
|
|
* @returns {*}
|
|
*/
|
|
var objectResolvePath = function (o, path$1) {
|
|
if (typeof path$1 !== 'string') {
|
|
throw new TypeError('path must be a string')
|
|
}
|
|
if (typeof o !== 'object') {
|
|
throw new TypeError('object must be passed')
|
|
}
|
|
var pathObj = path.get(path$1);
|
|
if (!pathObj.valid) {
|
|
throw new Error('path is not a valid object path')
|
|
}
|
|
return pathObj.getValueFrom(o)
|
|
};
|
|
|
|
/*
|
|
Copyright (c) 2014, Yahoo! Inc. All rights reserved.
|
|
Copyrights licensed under the New BSD License.
|
|
See the accompanying LICENSE file for terms.
|
|
*/
|
|
var __extends = (undefined && undefined.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var Compiler = /** @class */ (function () {
|
|
function Compiler(locales, formats) {
|
|
this.locales = [];
|
|
this.formats = {
|
|
number: {},
|
|
date: {},
|
|
time: {}
|
|
};
|
|
this.pluralNumberFormat = null;
|
|
this.currentPlural = null;
|
|
this.pluralStack = [];
|
|
this.locales = locales;
|
|
this.formats = formats;
|
|
}
|
|
Compiler.prototype.compile = function (ast) {
|
|
this.pluralStack = [];
|
|
this.currentPlural = null;
|
|
this.pluralNumberFormat = null;
|
|
return this.compileMessage(ast);
|
|
};
|
|
Compiler.prototype.compileMessage = function (ast) {
|
|
var _this = this;
|
|
if (!(ast && ast.type === 'messageFormatPattern')) {
|
|
throw new Error('Message AST is not of type: "messageFormatPattern"');
|
|
}
|
|
var elements = ast.elements;
|
|
var pattern = elements
|
|
.filter(function (el) {
|
|
return el.type === 'messageTextElement' || el.type === 'argumentElement';
|
|
})
|
|
.map(function (el) {
|
|
return el.type === 'messageTextElement'
|
|
? _this.compileMessageText(el)
|
|
: _this.compileArgument(el);
|
|
});
|
|
if (pattern.length !== elements.length) {
|
|
throw new Error('Message element does not have a valid type');
|
|
}
|
|
return pattern;
|
|
};
|
|
Compiler.prototype.compileMessageText = function (element) {
|
|
// When this `element` is part of plural sub-pattern and its value contains
|
|
// an unescaped '#', use a `PluralOffsetString` helper to properly output
|
|
// the number with the correct offset in the string.
|
|
if (this.currentPlural && /(^|[^\\])#/g.test(element.value)) {
|
|
// Create a cache a NumberFormat instance that can be reused for any
|
|
// PluralOffsetString instance in this message.
|
|
if (!this.pluralNumberFormat) {
|
|
this.pluralNumberFormat = new Intl.NumberFormat(this.locales);
|
|
}
|
|
return new PluralOffsetString(this.currentPlural.id, this.currentPlural.format.offset, this.pluralNumberFormat, element.value);
|
|
}
|
|
// Unescape the escaped '#'s in the message text.
|
|
return element.value.replace(/\\#/g, '#');
|
|
};
|
|
Compiler.prototype.compileArgument = function (element) {
|
|
var format = element.format, id = element.id;
|
|
if (!format) {
|
|
return new StringFormat(id);
|
|
}
|
|
var _a = this, formats = _a.formats, locales = _a.locales;
|
|
switch (format.type) {
|
|
case 'numberFormat':
|
|
return {
|
|
id: id,
|
|
format: new Intl.NumberFormat(locales, formats.number[format.style])
|
|
.format
|
|
};
|
|
case 'dateFormat':
|
|
return {
|
|
id: id,
|
|
format: new Intl.DateTimeFormat(locales, formats.date[format.style])
|
|
.format
|
|
};
|
|
case 'timeFormat':
|
|
return {
|
|
id: id,
|
|
format: new Intl.DateTimeFormat(locales, formats.time[format.style])
|
|
.format
|
|
};
|
|
case 'pluralFormat':
|
|
return new PluralFormat(id, format.ordinal, format.offset, this.compileOptions(element), locales);
|
|
case 'selectFormat':
|
|
return new SelectFormat(id, this.compileOptions(element));
|
|
default:
|
|
throw new Error('Message element does not have a valid format type');
|
|
}
|
|
};
|
|
Compiler.prototype.compileOptions = function (element) {
|
|
var _this = this;
|
|
var format = element.format;
|
|
var options = format.options;
|
|
// Save the current plural element, if any, then set it to a new value when
|
|
// compiling the options sub-patterns. This conforms the spec's algorithm
|
|
// for handling `"#"` syntax in message text.
|
|
this.pluralStack.push(this.currentPlural);
|
|
this.currentPlural = format.type === 'pluralFormat' ? element : null;
|
|
var optionsHash = options.reduce(function (all, option) {
|
|
// Compile the sub-pattern and save it under the options's selector.
|
|
all[option.selector] = _this.compileMessage(option.value);
|
|
return all;
|
|
}, {});
|
|
// Pop the plural stack to put back the original current plural value.
|
|
this.currentPlural = this.pluralStack.pop();
|
|
return optionsHash;
|
|
};
|
|
return Compiler;
|
|
}());
|
|
// -- Compiler Helper Classes --------------------------------------------------
|
|
var Formatter = /** @class */ (function () {
|
|
function Formatter(id) {
|
|
this.id = id;
|
|
}
|
|
return Formatter;
|
|
}());
|
|
var StringFormat = /** @class */ (function (_super) {
|
|
__extends(StringFormat, _super);
|
|
function StringFormat() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
StringFormat.prototype.format = function (value) {
|
|
if (!value && typeof value !== 'number') {
|
|
return '';
|
|
}
|
|
return typeof value === 'string' ? value : String(value);
|
|
};
|
|
return StringFormat;
|
|
}(Formatter));
|
|
var PluralFormat = /** @class */ (function () {
|
|
function PluralFormat(id, useOrdinal, offset, options, locales) {
|
|
this.id = id;
|
|
this.offset = offset;
|
|
this.options = options;
|
|
this.pluralRules = new Intl.PluralRules(locales, {
|
|
type: useOrdinal ? 'ordinal' : 'cardinal'
|
|
});
|
|
}
|
|
PluralFormat.prototype.getOption = function (value) {
|
|
var options = this.options;
|
|
var option = options['=' + value] ||
|
|
options[this.pluralRules.select(value - this.offset)];
|
|
return option || options.other;
|
|
};
|
|
return PluralFormat;
|
|
}());
|
|
var PluralOffsetString = /** @class */ (function (_super) {
|
|
__extends(PluralOffsetString, _super);
|
|
function PluralOffsetString(id, offset, numberFormat, string) {
|
|
var _this = _super.call(this, id) || this;
|
|
_this.offset = offset;
|
|
_this.numberFormat = numberFormat;
|
|
_this.string = string;
|
|
return _this;
|
|
}
|
|
PluralOffsetString.prototype.format = function (value) {
|
|
var number = this.numberFormat.format(value - this.offset);
|
|
return this.string
|
|
.replace(/(^|[^\\])#/g, '$1' + number)
|
|
.replace(/\\#/g, '#');
|
|
};
|
|
return PluralOffsetString;
|
|
}(Formatter));
|
|
var SelectFormat = /** @class */ (function () {
|
|
function SelectFormat(id, options) {
|
|
this.id = id;
|
|
this.options = options;
|
|
}
|
|
SelectFormat.prototype.getOption = function (value) {
|
|
var options = this.options;
|
|
return options[value] || options.other;
|
|
};
|
|
return SelectFormat;
|
|
}());
|
|
function isSelectOrPluralFormat(f) {
|
|
return !!f.options;
|
|
}
|
|
//# sourceMappingURL=compiler.js.map
|
|
|
|
var parser = /*
|
|
* Generated by PEG.js 0.10.0.
|
|
*
|
|
* http://pegjs.org/
|
|
*/
|
|
(function() {
|
|
|
|
function peg$subclass(child, parent) {
|
|
function ctor() { this.constructor = child; }
|
|
ctor.prototype = parent.prototype;
|
|
child.prototype = new ctor();
|
|
}
|
|
|
|
function peg$SyntaxError(message, expected, found, location) {
|
|
this.message = message;
|
|
this.expected = expected;
|
|
this.found = found;
|
|
this.location = location;
|
|
this.name = "SyntaxError";
|
|
|
|
if (typeof Error.captureStackTrace === "function") {
|
|
Error.captureStackTrace(this, peg$SyntaxError);
|
|
}
|
|
}
|
|
|
|
peg$subclass(peg$SyntaxError, Error);
|
|
|
|
peg$SyntaxError.buildMessage = function(expected, found) {
|
|
var DESCRIBE_EXPECTATION_FNS = {
|
|
literal: function(expectation) {
|
|
return "\"" + literalEscape(expectation.text) + "\"";
|
|
},
|
|
|
|
"class": function(expectation) {
|
|
var escapedParts = "",
|
|
i;
|
|
|
|
for (i = 0; i < expectation.parts.length; i++) {
|
|
escapedParts += expectation.parts[i] instanceof Array
|
|
? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
|
|
: classEscape(expectation.parts[i]);
|
|
}
|
|
|
|
return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
|
|
},
|
|
|
|
any: function(expectation) {
|
|
return "any character";
|
|
},
|
|
|
|
end: function(expectation) {
|
|
return "end of input";
|
|
},
|
|
|
|
other: function(expectation) {
|
|
return expectation.description;
|
|
}
|
|
};
|
|
|
|
function hex(ch) {
|
|
return ch.charCodeAt(0).toString(16).toUpperCase();
|
|
}
|
|
|
|
function literalEscape(s) {
|
|
return s
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/"/g, '\\"')
|
|
.replace(/\0/g, '\\0')
|
|
.replace(/\t/g, '\\t')
|
|
.replace(/\n/g, '\\n')
|
|
.replace(/\r/g, '\\r')
|
|
.replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
|
|
.replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
|
|
}
|
|
|
|
function classEscape(s) {
|
|
return s
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/\]/g, '\\]')
|
|
.replace(/\^/g, '\\^')
|
|
.replace(/-/g, '\\-')
|
|
.replace(/\0/g, '\\0')
|
|
.replace(/\t/g, '\\t')
|
|
.replace(/\n/g, '\\n')
|
|
.replace(/\r/g, '\\r')
|
|
.replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
|
|
.replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
|
|
}
|
|
|
|
function describeExpectation(expectation) {
|
|
return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
|
|
}
|
|
|
|
function describeExpected(expected) {
|
|
var descriptions = new Array(expected.length),
|
|
i, j;
|
|
|
|
for (i = 0; i < expected.length; i++) {
|
|
descriptions[i] = describeExpectation(expected[i]);
|
|
}
|
|
|
|
descriptions.sort();
|
|
|
|
if (descriptions.length > 0) {
|
|
for (i = 1, j = 1; i < descriptions.length; i++) {
|
|
if (descriptions[i - 1] !== descriptions[i]) {
|
|
descriptions[j] = descriptions[i];
|
|
j++;
|
|
}
|
|
}
|
|
descriptions.length = j;
|
|
}
|
|
|
|
switch (descriptions.length) {
|
|
case 1:
|
|
return descriptions[0];
|
|
|
|
case 2:
|
|
return descriptions[0] + " or " + descriptions[1];
|
|
|
|
default:
|
|
return descriptions.slice(0, -1).join(", ")
|
|
+ ", or "
|
|
+ descriptions[descriptions.length - 1];
|
|
}
|
|
}
|
|
|
|
function describeFound(found) {
|
|
return found ? "\"" + literalEscape(found) + "\"" : "end of input";
|
|
}
|
|
|
|
return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
|
|
};
|
|
|
|
function peg$parse(input, options) {
|
|
options = options !== void 0 ? options : {};
|
|
|
|
var peg$FAILED = {},
|
|
|
|
peg$startRuleFunctions = { start: peg$parsestart },
|
|
peg$startRuleFunction = peg$parsestart,
|
|
|
|
peg$c0 = function(elements) {
|
|
return {
|
|
type : 'messageFormatPattern',
|
|
elements: elements,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c1 = function(chunks) {
|
|
return chunks.reduce(function (all, chunk) {
|
|
return all.concat(chunk)
|
|
}, []).join('')
|
|
},
|
|
peg$c2 = function(messageText) {
|
|
return {
|
|
type : 'messageTextElement',
|
|
value: messageText,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c3 = /^[^ \t\n\r,.+={}#]/,
|
|
peg$c4 = peg$classExpectation([" ", "\t", "\n", "\r", ",", ".", "+", "=", "{", "}", "#"], true, false),
|
|
peg$c5 = "{",
|
|
peg$c6 = peg$literalExpectation("{", false),
|
|
peg$c7 = ",",
|
|
peg$c8 = peg$literalExpectation(",", false),
|
|
peg$c9 = "}",
|
|
peg$c10 = peg$literalExpectation("}", false),
|
|
peg$c11 = function(id, format) {
|
|
return {
|
|
type : 'argumentElement',
|
|
id : id,
|
|
format: format && format[2],
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c12 = "number",
|
|
peg$c13 = peg$literalExpectation("number", false),
|
|
peg$c14 = "date",
|
|
peg$c15 = peg$literalExpectation("date", false),
|
|
peg$c16 = "time",
|
|
peg$c17 = peg$literalExpectation("time", false),
|
|
peg$c18 = function(type, style) {
|
|
return {
|
|
type : type + 'Format',
|
|
style: style && style[2],
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c19 = "plural",
|
|
peg$c20 = peg$literalExpectation("plural", false),
|
|
peg$c21 = function(pluralStyle) {
|
|
return {
|
|
type : pluralStyle.type,
|
|
ordinal: false,
|
|
offset : pluralStyle.offset || 0,
|
|
options: pluralStyle.options,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c22 = "selectordinal",
|
|
peg$c23 = peg$literalExpectation("selectordinal", false),
|
|
peg$c24 = function(pluralStyle) {
|
|
return {
|
|
type : pluralStyle.type,
|
|
ordinal: true,
|
|
offset : pluralStyle.offset || 0,
|
|
options: pluralStyle.options,
|
|
location: location()
|
|
}
|
|
},
|
|
peg$c25 = "select",
|
|
peg$c26 = peg$literalExpectation("select", false),
|
|
peg$c27 = function(options) {
|
|
return {
|
|
type : 'selectFormat',
|
|
options: options,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c28 = "=",
|
|
peg$c29 = peg$literalExpectation("=", false),
|
|
peg$c30 = function(selector, pattern) {
|
|
return {
|
|
type : 'optionalFormatPattern',
|
|
selector: selector,
|
|
value : pattern,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c31 = "offset:",
|
|
peg$c32 = peg$literalExpectation("offset:", false),
|
|
peg$c33 = function(number) {
|
|
return number;
|
|
},
|
|
peg$c34 = function(offset, options) {
|
|
return {
|
|
type : 'pluralFormat',
|
|
offset : offset,
|
|
options: options,
|
|
location: location()
|
|
};
|
|
},
|
|
peg$c35 = peg$otherExpectation("whitespace"),
|
|
peg$c36 = /^[ \t\n\r]/,
|
|
peg$c37 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false),
|
|
peg$c38 = peg$otherExpectation("optionalWhitespace"),
|
|
peg$c39 = /^[0-9]/,
|
|
peg$c40 = peg$classExpectation([["0", "9"]], false, false),
|
|
peg$c41 = /^[0-9a-f]/i,
|
|
peg$c42 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true),
|
|
peg$c43 = "0",
|
|
peg$c44 = peg$literalExpectation("0", false),
|
|
peg$c45 = /^[1-9]/,
|
|
peg$c46 = peg$classExpectation([["1", "9"]], false, false),
|
|
peg$c47 = function(digits) {
|
|
return parseInt(digits, 10);
|
|
},
|
|
peg$c48 = /^[^{}\\\0-\x1F\x7F \t\n\r]/,
|
|
peg$c49 = peg$classExpectation(["{", "}", "\\", ["\0", "\x1F"], "\x7F", " ", "\t", "\n", "\r"], true, false),
|
|
peg$c50 = "\\\\",
|
|
peg$c51 = peg$literalExpectation("\\\\", false),
|
|
peg$c52 = function() { return '\\'; },
|
|
peg$c53 = "\\#",
|
|
peg$c54 = peg$literalExpectation("\\#", false),
|
|
peg$c55 = function() { return '\\#'; },
|
|
peg$c56 = "\\{",
|
|
peg$c57 = peg$literalExpectation("\\{", false),
|
|
peg$c58 = function() { return '\u007B'; },
|
|
peg$c59 = "\\}",
|
|
peg$c60 = peg$literalExpectation("\\}", false),
|
|
peg$c61 = function() { return '\u007D'; },
|
|
peg$c62 = "\\u",
|
|
peg$c63 = peg$literalExpectation("\\u", false),
|
|
peg$c64 = function(digits) {
|
|
return String.fromCharCode(parseInt(digits, 16));
|
|
},
|
|
peg$c65 = function(chars) { return chars.join(''); },
|
|
|
|
peg$currPos = 0,
|
|
peg$savedPos = 0,
|
|
peg$posDetailsCache = [{ line: 1, column: 1 }],
|
|
peg$maxFailPos = 0,
|
|
peg$maxFailExpected = [],
|
|
peg$silentFails = 0,
|
|
|
|
peg$result;
|
|
|
|
if ("startRule" in options) {
|
|
if (!(options.startRule in peg$startRuleFunctions)) {
|
|
throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
|
|
}
|
|
|
|
peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
|
|
}
|
|
|
|
function location() {
|
|
return peg$computeLocation(peg$savedPos, peg$currPos);
|
|
}
|
|
|
|
function peg$literalExpectation(text, ignoreCase) {
|
|
return { type: "literal", text: text, ignoreCase: ignoreCase };
|
|
}
|
|
|
|
function peg$classExpectation(parts, inverted, ignoreCase) {
|
|
return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
|
|
}
|
|
|
|
function peg$endExpectation() {
|
|
return { type: "end" };
|
|
}
|
|
|
|
function peg$otherExpectation(description) {
|
|
return { type: "other", description: description };
|
|
}
|
|
|
|
function peg$computePosDetails(pos) {
|
|
var details = peg$posDetailsCache[pos], p;
|
|
|
|
if (details) {
|
|
return details;
|
|
} else {
|
|
p = pos - 1;
|
|
while (!peg$posDetailsCache[p]) {
|
|
p--;
|
|
}
|
|
|
|
details = peg$posDetailsCache[p];
|
|
details = {
|
|
line: details.line,
|
|
column: details.column
|
|
};
|
|
|
|
while (p < pos) {
|
|
if (input.charCodeAt(p) === 10) {
|
|
details.line++;
|
|
details.column = 1;
|
|
} else {
|
|
details.column++;
|
|
}
|
|
|
|
p++;
|
|
}
|
|
|
|
peg$posDetailsCache[pos] = details;
|
|
return details;
|
|
}
|
|
}
|
|
|
|
function peg$computeLocation(startPos, endPos) {
|
|
var startPosDetails = peg$computePosDetails(startPos),
|
|
endPosDetails = peg$computePosDetails(endPos);
|
|
|
|
return {
|
|
start: {
|
|
offset: startPos,
|
|
line: startPosDetails.line,
|
|
column: startPosDetails.column
|
|
},
|
|
end: {
|
|
offset: endPos,
|
|
line: endPosDetails.line,
|
|
column: endPosDetails.column
|
|
}
|
|
};
|
|
}
|
|
|
|
function peg$fail(expected) {
|
|
if (peg$currPos < peg$maxFailPos) { return; }
|
|
|
|
if (peg$currPos > peg$maxFailPos) {
|
|
peg$maxFailPos = peg$currPos;
|
|
peg$maxFailExpected = [];
|
|
}
|
|
|
|
peg$maxFailExpected.push(expected);
|
|
}
|
|
|
|
function peg$buildStructuredError(expected, found, location) {
|
|
return new peg$SyntaxError(
|
|
peg$SyntaxError.buildMessage(expected, found),
|
|
expected,
|
|
found,
|
|
location
|
|
);
|
|
}
|
|
|
|
function peg$parsestart() {
|
|
var s0;
|
|
|
|
s0 = peg$parsemessageFormatPattern();
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageFormatPattern() {
|
|
var s0, s1, s2;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$parsemessageFormatElement();
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$parsemessageFormatElement();
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c0(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageFormatElement() {
|
|
var s0;
|
|
|
|
s0 = peg$parsemessageTextElement();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parseargumentElement();
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageText() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$currPos;
|
|
s3 = peg$parse_();
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parsechars();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parse_();
|
|
if (s5 !== peg$FAILED) {
|
|
s3 = [s3, s4, s5];
|
|
s2 = s3;
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$currPos;
|
|
s3 = peg$parse_();
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parsechars();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parse_();
|
|
if (s5 !== peg$FAILED) {
|
|
s3 = [s3, s4, s5];
|
|
s2 = s3;
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c1(s1);
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
s1 = peg$parsews();
|
|
if (s1 !== peg$FAILED) {
|
|
s0 = input.substring(s0, peg$currPos);
|
|
} else {
|
|
s0 = s1;
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsemessageTextElement() {
|
|
var s0, s1;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$parsemessageText();
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c2(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseargument() {
|
|
var s0, s1, s2;
|
|
|
|
s0 = peg$parsenumber();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
if (peg$c3.test(input.charAt(peg$currPos))) {
|
|
s2 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s2 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c4); }
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
if (peg$c3.test(input.charAt(peg$currPos))) {
|
|
s2 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s2 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c4); }
|
|
}
|
|
}
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s0 = input.substring(s0, peg$currPos);
|
|
} else {
|
|
s0 = s1;
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseargumentElement() {
|
|
var s0, s1, s2, s3, s4, s5, s6, s7, s8;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
s1 = peg$c5;
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c6); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parseargument();
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s6 = peg$c7;
|
|
peg$currPos++;
|
|
} else {
|
|
s6 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c8); }
|
|
}
|
|
if (s6 !== peg$FAILED) {
|
|
s7 = peg$parse_();
|
|
if (s7 !== peg$FAILED) {
|
|
s8 = peg$parseelementFormat();
|
|
if (s8 !== peg$FAILED) {
|
|
s6 = [s6, s7, s8];
|
|
s5 = s6;
|
|
} else {
|
|
peg$currPos = s5;
|
|
s5 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s5;
|
|
s5 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s5;
|
|
s5 = peg$FAILED;
|
|
}
|
|
if (s5 === peg$FAILED) {
|
|
s5 = null;
|
|
}
|
|
if (s5 !== peg$FAILED) {
|
|
s6 = peg$parse_();
|
|
if (s6 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
s7 = peg$c9;
|
|
peg$currPos++;
|
|
} else {
|
|
s7 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c10); }
|
|
}
|
|
if (s7 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c11(s3, s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseelementFormat() {
|
|
var s0;
|
|
|
|
s0 = peg$parsesimpleFormat();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parsepluralFormat();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parseselectOrdinalFormat();
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parseselectFormat();
|
|
}
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsesimpleFormat() {
|
|
var s0, s1, s2, s3, s4, s5, s6;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 6) === peg$c12) {
|
|
s1 = peg$c12;
|
|
peg$currPos += 6;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c13); }
|
|
}
|
|
if (s1 === peg$FAILED) {
|
|
if (input.substr(peg$currPos, 4) === peg$c14) {
|
|
s1 = peg$c14;
|
|
peg$currPos += 4;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c15); }
|
|
}
|
|
if (s1 === peg$FAILED) {
|
|
if (input.substr(peg$currPos, 4) === peg$c16) {
|
|
s1 = peg$c16;
|
|
peg$currPos += 4;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c17); }
|
|
}
|
|
}
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s4 = peg$c7;
|
|
peg$currPos++;
|
|
} else {
|
|
s4 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c8); }
|
|
}
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parse_();
|
|
if (s5 !== peg$FAILED) {
|
|
s6 = peg$parsechars();
|
|
if (s6 !== peg$FAILED) {
|
|
s4 = [s4, s5, s6];
|
|
s3 = s4;
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
if (s3 === peg$FAILED) {
|
|
s3 = null;
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c18(s1, s3);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsepluralFormat() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 6) === peg$c19) {
|
|
s1 = peg$c19;
|
|
peg$currPos += 6;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c20); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s3 = peg$c7;
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c8); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsepluralStyle();
|
|
if (s5 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c21(s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseselectOrdinalFormat() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 13) === peg$c22) {
|
|
s1 = peg$c22;
|
|
peg$currPos += 13;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c23); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s3 = peg$c7;
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c8); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsepluralStyle();
|
|
if (s5 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c24(s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseselectFormat() {
|
|
var s0, s1, s2, s3, s4, s5, s6;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 6) === peg$c25) {
|
|
s1 = peg$c25;
|
|
peg$currPos += 6;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c26); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
s3 = peg$c7;
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c8); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = peg$parse_();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = [];
|
|
s6 = peg$parseoptionalFormatPattern();
|
|
if (s6 !== peg$FAILED) {
|
|
while (s6 !== peg$FAILED) {
|
|
s5.push(s6);
|
|
s6 = peg$parseoptionalFormatPattern();
|
|
}
|
|
} else {
|
|
s5 = peg$FAILED;
|
|
}
|
|
if (s5 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c27(s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseselector() {
|
|
var s0, s1, s2, s3;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 61) {
|
|
s2 = peg$c28;
|
|
peg$currPos++;
|
|
} else {
|
|
s2 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c29); }
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parsenumber();
|
|
if (s3 !== peg$FAILED) {
|
|
s2 = [s2, s3];
|
|
s1 = s2;
|
|
} else {
|
|
peg$currPos = s1;
|
|
s1 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s1;
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s0 = input.substring(s0, peg$currPos);
|
|
} else {
|
|
s0 = s1;
|
|
}
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$parsechars();
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseoptionalFormatPattern() {
|
|
var s0, s1, s2, s3, s4, s5, s6;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$parse_();
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parseselector();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parse_();
|
|
if (s3 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
s4 = peg$c5;
|
|
peg$currPos++;
|
|
} else {
|
|
s4 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c6); }
|
|
}
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsemessageFormatPattern();
|
|
if (s5 !== peg$FAILED) {
|
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
s6 = peg$c9;
|
|
peg$currPos++;
|
|
} else {
|
|
s6 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c10); }
|
|
}
|
|
if (s6 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c30(s2, s5);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parseoffset() {
|
|
var s0, s1, s2, s3;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 7) === peg$c31) {
|
|
s1 = peg$c31;
|
|
peg$currPos += 7;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c32); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = peg$parsenumber();
|
|
if (s3 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c33(s3);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsepluralStyle() {
|
|
var s0, s1, s2, s3, s4;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = peg$parseoffset();
|
|
if (s1 === peg$FAILED) {
|
|
s1 = null;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$parse_();
|
|
if (s2 !== peg$FAILED) {
|
|
s3 = [];
|
|
s4 = peg$parseoptionalFormatPattern();
|
|
if (s4 !== peg$FAILED) {
|
|
while (s4 !== peg$FAILED) {
|
|
s3.push(s4);
|
|
s4 = peg$parseoptionalFormatPattern();
|
|
}
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c34(s1, s3);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsews() {
|
|
var s0, s1;
|
|
|
|
peg$silentFails++;
|
|
s0 = [];
|
|
if (peg$c36.test(input.charAt(peg$currPos))) {
|
|
s1 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c37); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
while (s1 !== peg$FAILED) {
|
|
s0.push(s1);
|
|
if (peg$c36.test(input.charAt(peg$currPos))) {
|
|
s1 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c37); }
|
|
}
|
|
}
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
}
|
|
peg$silentFails--;
|
|
if (s0 === peg$FAILED) {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c35); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parse_() {
|
|
var s0, s1, s2;
|
|
|
|
peg$silentFails++;
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$parsews();
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$parsews();
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s0 = input.substring(s0, peg$currPos);
|
|
} else {
|
|
s0 = s1;
|
|
}
|
|
peg$silentFails--;
|
|
if (s0 === peg$FAILED) {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c38); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsedigit() {
|
|
var s0;
|
|
|
|
if (peg$c39.test(input.charAt(peg$currPos))) {
|
|
s0 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c40); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsehexDigit() {
|
|
var s0;
|
|
|
|
if (peg$c41.test(input.charAt(peg$currPos))) {
|
|
s0 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c42); }
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsenumber() {
|
|
var s0, s1, s2, s3, s4, s5;
|
|
|
|
s0 = peg$currPos;
|
|
if (input.charCodeAt(peg$currPos) === 48) {
|
|
s1 = peg$c43;
|
|
peg$currPos++;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c44); }
|
|
}
|
|
if (s1 === peg$FAILED) {
|
|
s1 = peg$currPos;
|
|
s2 = peg$currPos;
|
|
if (peg$c45.test(input.charAt(peg$currPos))) {
|
|
s3 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s3 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c46); }
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s4 = [];
|
|
s5 = peg$parsedigit();
|
|
while (s5 !== peg$FAILED) {
|
|
s4.push(s5);
|
|
s5 = peg$parsedigit();
|
|
}
|
|
if (s4 !== peg$FAILED) {
|
|
s3 = [s3, s4];
|
|
s2 = s3;
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s2;
|
|
s2 = peg$FAILED;
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
s1 = input.substring(s1, peg$currPos);
|
|
} else {
|
|
s1 = s2;
|
|
}
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c47(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsechar() {
|
|
var s0, s1, s2, s3, s4, s5, s6, s7;
|
|
|
|
if (peg$c48.test(input.charAt(peg$currPos))) {
|
|
s0 = input.charAt(peg$currPos);
|
|
peg$currPos++;
|
|
} else {
|
|
s0 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c49); }
|
|
}
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c50) {
|
|
s1 = peg$c50;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c51); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c52();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c53) {
|
|
s1 = peg$c53;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c54); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c55();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c56) {
|
|
s1 = peg$c56;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c57); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c58();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c59) {
|
|
s1 = peg$c59;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c60); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c61();
|
|
}
|
|
s0 = s1;
|
|
if (s0 === peg$FAILED) {
|
|
s0 = peg$currPos;
|
|
if (input.substr(peg$currPos, 2) === peg$c62) {
|
|
s1 = peg$c62;
|
|
peg$currPos += 2;
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
if (peg$silentFails === 0) { peg$fail(peg$c63); }
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
s2 = peg$currPos;
|
|
s3 = peg$currPos;
|
|
s4 = peg$parsehexDigit();
|
|
if (s4 !== peg$FAILED) {
|
|
s5 = peg$parsehexDigit();
|
|
if (s5 !== peg$FAILED) {
|
|
s6 = peg$parsehexDigit();
|
|
if (s6 !== peg$FAILED) {
|
|
s7 = peg$parsehexDigit();
|
|
if (s7 !== peg$FAILED) {
|
|
s4 = [s4, s5, s6, s7];
|
|
s3 = s4;
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s3;
|
|
s3 = peg$FAILED;
|
|
}
|
|
if (s3 !== peg$FAILED) {
|
|
s2 = input.substring(s2, peg$currPos);
|
|
} else {
|
|
s2 = s3;
|
|
}
|
|
if (s2 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c64(s2);
|
|
s0 = s1;
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
} else {
|
|
peg$currPos = s0;
|
|
s0 = peg$FAILED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return s0;
|
|
}
|
|
|
|
function peg$parsechars() {
|
|
var s0, s1, s2;
|
|
|
|
s0 = peg$currPos;
|
|
s1 = [];
|
|
s2 = peg$parsechar();
|
|
if (s2 !== peg$FAILED) {
|
|
while (s2 !== peg$FAILED) {
|
|
s1.push(s2);
|
|
s2 = peg$parsechar();
|
|
}
|
|
} else {
|
|
s1 = peg$FAILED;
|
|
}
|
|
if (s1 !== peg$FAILED) {
|
|
peg$savedPos = s0;
|
|
s1 = peg$c65(s1);
|
|
}
|
|
s0 = s1;
|
|
|
|
return s0;
|
|
}
|
|
|
|
peg$result = peg$startRuleFunction();
|
|
|
|
if (peg$result !== peg$FAILED && peg$currPos === input.length) {
|
|
return peg$result;
|
|
} else {
|
|
if (peg$result !== peg$FAILED && peg$currPos < input.length) {
|
|
peg$fail(peg$endExpectation());
|
|
}
|
|
|
|
throw peg$buildStructuredError(
|
|
peg$maxFailExpected,
|
|
peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
|
|
peg$maxFailPos < input.length
|
|
? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
|
|
: peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
|
|
);
|
|
}
|
|
}
|
|
|
|
return {
|
|
SyntaxError: peg$SyntaxError,
|
|
parse: peg$parse
|
|
};
|
|
})();
|
|
|
|
/*
|
|
Copyright (c) 2014, Yahoo! Inc. All rights reserved.
|
|
Copyrights licensed under the New BSD License.
|
|
See the accompanying LICENSE file for terms.
|
|
*/
|
|
var __extends$1 = (undefined && undefined.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __assign = (undefined && undefined.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
// -- MessageFormat --------------------------------------------------------
|
|
function resolveLocale(locales) {
|
|
if (typeof locales === 'string') {
|
|
locales = [locales];
|
|
}
|
|
try {
|
|
return Intl.NumberFormat.supportedLocalesOf(locales, {
|
|
// IE11 localeMatcher `lookup` seems to convert `en` -> `en-US`
|
|
// but not other browsers,
|
|
localeMatcher: 'best fit'
|
|
})[0];
|
|
}
|
|
catch (e) {
|
|
return MessageFormat.defaultLocale;
|
|
}
|
|
}
|
|
function formatPatterns(pattern, values) {
|
|
var result = '';
|
|
for (var _i = 0, pattern_1 = pattern; _i < pattern_1.length; _i++) {
|
|
var part = pattern_1[_i];
|
|
// Exist early for string parts.
|
|
if (typeof part === 'string') {
|
|
result += part;
|
|
continue;
|
|
}
|
|
var id = part.id;
|
|
// Enforce that all required values are provided by the caller.
|
|
if (!(values && id in values)) {
|
|
throw new FormatError("A value must be provided for: " + id, id);
|
|
}
|
|
var value = values[id];
|
|
// Recursively format plural and select parts' option — which can be a
|
|
// nested pattern structure. The choosing of the option to use is
|
|
// abstracted-by and delegated-to the part helper object.
|
|
if (isSelectOrPluralFormat(part)) {
|
|
result += formatPatterns(part.getOption(value), values);
|
|
}
|
|
else {
|
|
result += part.format(value);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mergeConfig(c1, c2) {
|
|
if (!c2) {
|
|
return c1;
|
|
}
|
|
return __assign({}, (c1 || {}), (c2 || {}), Object.keys(c1).reduce(function (all, k) {
|
|
all[k] = __assign({}, c1[k], (c2[k] || {}));
|
|
return all;
|
|
}, {}));
|
|
}
|
|
function mergeConfigs(defaultConfig, configs) {
|
|
if (!configs) {
|
|
return defaultConfig;
|
|
}
|
|
return Object.keys(defaultConfig).reduce(function (all, k) {
|
|
all[k] = mergeConfig(defaultConfig[k], configs[k]);
|
|
return all;
|
|
}, __assign({}, defaultConfig));
|
|
}
|
|
var FormatError = /** @class */ (function (_super) {
|
|
__extends$1(FormatError, _super);
|
|
function FormatError(msg, variableId) {
|
|
var _this = _super.call(this, msg) || this;
|
|
_this.variableId = variableId;
|
|
return _this;
|
|
}
|
|
return FormatError;
|
|
}(Error));
|
|
var MessageFormat = (function (message, locales, overrideFormats) {
|
|
if (locales === void 0) { locales = MessageFormat.defaultLocale; }
|
|
// Parse string messages into an AST.
|
|
var ast = typeof message === 'string' ? MessageFormat.__parse(message) : message;
|
|
if (!(ast && ast.type === 'messageFormatPattern')) {
|
|
throw new TypeError('A message must be provided as a String or AST.');
|
|
}
|
|
// Creates a new object with the specified `formats` merged with the default
|
|
// formats.
|
|
var formats = mergeConfigs(MessageFormat.formats, overrideFormats);
|
|
// Defined first because it's used to build the format pattern.
|
|
var locale = resolveLocale(locales || []);
|
|
// Compile the `ast` to a pattern that is highly optimized for repeated
|
|
// `format()` invocations. **Note:** This passes the `locales` set provided
|
|
// to the constructor instead of just the resolved locale.
|
|
var pattern = new Compiler(locales, formats).compile(ast);
|
|
// "Bind" `format()` method to `this` so it can be passed by reference like
|
|
// the other `Intl` APIs.
|
|
return {
|
|
format: function (values) {
|
|
try {
|
|
return formatPatterns(pattern, values);
|
|
}
|
|
catch (e) {
|
|
if (e.variableId) {
|
|
throw new Error("The intl string context variable '" + e.variableId + "' was not provided to the string '" + message + "'");
|
|
}
|
|
else {
|
|
throw e;
|
|
}
|
|
}
|
|
},
|
|
resolvedOptions: function () {
|
|
return { locale: locale };
|
|
},
|
|
getAst: function () {
|
|
return ast;
|
|
}
|
|
};
|
|
});
|
|
MessageFormat.defaultLocale = 'en';
|
|
// Default format options used as the prototype of the `formats` provided to the
|
|
// constructor. These are used when constructing the internal Intl.NumberFormat
|
|
// and Intl.DateTimeFormat instances.
|
|
MessageFormat.formats = {
|
|
number: {
|
|
currency: {
|
|
style: 'currency'
|
|
},
|
|
percent: {
|
|
style: 'percent'
|
|
}
|
|
},
|
|
date: {
|
|
short: {
|
|
month: 'numeric',
|
|
day: 'numeric',
|
|
year: '2-digit'
|
|
},
|
|
medium: {
|
|
month: 'short',
|
|
day: 'numeric',
|
|
year: 'numeric'
|
|
},
|
|
long: {
|
|
month: 'long',
|
|
day: 'numeric',
|
|
year: 'numeric'
|
|
},
|
|
full: {
|
|
weekday: 'long',
|
|
month: 'long',
|
|
day: 'numeric',
|
|
year: 'numeric'
|
|
}
|
|
},
|
|
time: {
|
|
short: {
|
|
hour: 'numeric',
|
|
minute: 'numeric'
|
|
},
|
|
medium: {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
second: 'numeric'
|
|
},
|
|
long: {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
second: 'numeric',
|
|
timeZoneName: 'short'
|
|
},
|
|
full: {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
second: 'numeric',
|
|
timeZoneName: 'short'
|
|
}
|
|
}
|
|
};
|
|
MessageFormat.__parse = parser.parse;
|
|
//# sourceMappingURL=index.js.map
|
|
|
|
/**
|
|
* @constant DEFAULT_OPTIONS_KEYS the default options keys
|
|
*/
|
|
var DEFAULT_OPTIONS_KEYS = {
|
|
isEqual: true,
|
|
isMatchingKey: true,
|
|
isPromise: true,
|
|
maxSize: true,
|
|
onCacheAdd: true,
|
|
onCacheChange: true,
|
|
onCacheHit: true,
|
|
transformKey: true,
|
|
};
|
|
/**
|
|
* @function slice
|
|
*
|
|
* @description
|
|
* slice.call() pre-bound
|
|
*/
|
|
var slice = Array.prototype.slice;
|
|
/**
|
|
* @function cloneArray
|
|
*
|
|
* @description
|
|
* clone the array-like object and return the new array
|
|
*
|
|
* @param arrayLike the array-like object to clone
|
|
* @returns the clone as an array
|
|
*/
|
|
function cloneArray(arrayLike) {
|
|
var length = arrayLike.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
if (length === 1) {
|
|
return [arrayLike[0]];
|
|
}
|
|
if (length === 2) {
|
|
return [arrayLike[0], arrayLike[1]];
|
|
}
|
|
if (length === 3) {
|
|
return [arrayLike[0], arrayLike[1], arrayLike[2]];
|
|
}
|
|
return slice.call(arrayLike, 0);
|
|
}
|
|
/**
|
|
* @function getCustomOptions
|
|
*
|
|
* @description
|
|
* get the custom options on the object passed
|
|
*
|
|
* @param options the memoization options passed
|
|
* @returns the custom options passed
|
|
*/
|
|
function getCustomOptions(options) {
|
|
var customOptions = {};
|
|
/* eslint-disable no-restricted-syntax */
|
|
for (var key in options) {
|
|
if (!DEFAULT_OPTIONS_KEYS[key]) {
|
|
customOptions[key] = options[key];
|
|
}
|
|
}
|
|
/* eslint-enable */
|
|
return customOptions;
|
|
}
|
|
/**
|
|
* @function isMemoized
|
|
*
|
|
* @description
|
|
* is the function passed already memoized
|
|
*
|
|
* @param fn the function to test
|
|
* @returns is the function already memoized
|
|
*/
|
|
function isMemoized(fn) {
|
|
return (typeof fn === 'function' &&
|
|
fn.isMemoized);
|
|
}
|
|
/**
|
|
* @function isSameValueZero
|
|
*
|
|
* @description
|
|
* are the objects equal based on SameValueZero equality
|
|
*
|
|
* @param object1 the first object to compare
|
|
* @param object2 the second object to compare
|
|
* @returns are the two objects equal
|
|
*/
|
|
function isSameValueZero(object1, object2) {
|
|
// eslint-disable-next-line no-self-compare
|
|
return object1 === object2 || (object1 !== object1 && object2 !== object2);
|
|
}
|
|
/**
|
|
* @function mergeOptions
|
|
*
|
|
* @description
|
|
* merge the options into the target
|
|
*
|
|
* @param existingOptions the options provided
|
|
* @param newOptions the options to include
|
|
* @returns the merged options
|
|
*/
|
|
function mergeOptions(existingOptions, newOptions) {
|
|
// @ts-ignore
|
|
var target = {};
|
|
/* eslint-disable no-restricted-syntax */
|
|
for (var key in existingOptions) {
|
|
target[key] = existingOptions[key];
|
|
}
|
|
for (var key in newOptions) {
|
|
target[key] = newOptions[key];
|
|
}
|
|
/* eslint-enable */
|
|
return target;
|
|
}
|
|
|
|
// utils
|
|
var Cache = /** @class */ (function () {
|
|
function Cache(options) {
|
|
this.keys = [];
|
|
this.values = [];
|
|
this.options = options;
|
|
var isMatchingKeyFunction = typeof options.isMatchingKey === 'function';
|
|
if (isMatchingKeyFunction) {
|
|
this.getKeyIndex = this._getKeyIndexFromMatchingKey;
|
|
}
|
|
else if (options.maxSize > 1) {
|
|
this.getKeyIndex = this._getKeyIndexForMany;
|
|
}
|
|
else {
|
|
this.getKeyIndex = this._getKeyIndexForSingle;
|
|
}
|
|
this.canTransformKey = typeof options.transformKey === 'function';
|
|
this.shouldCloneArguments = this.canTransformKey || isMatchingKeyFunction;
|
|
this.shouldUpdateOnAdd = typeof options.onCacheAdd === 'function';
|
|
this.shouldUpdateOnChange = typeof options.onCacheChange === 'function';
|
|
this.shouldUpdateOnHit = typeof options.onCacheHit === 'function';
|
|
}
|
|
Object.defineProperty(Cache.prototype, "size", {
|
|
get: function () {
|
|
return this.keys.length;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Cache.prototype, "snapshot", {
|
|
get: function () {
|
|
return {
|
|
keys: cloneArray(this.keys),
|
|
size: this.size,
|
|
values: cloneArray(this.values),
|
|
};
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @function _getKeyIndexFromMatchingKey
|
|
*
|
|
* @description
|
|
* gets the matching key index when a custom key matcher is used
|
|
*
|
|
* @param keyToMatch the key to match
|
|
* @returns the index of the matching key, or -1
|
|
*/
|
|
Cache.prototype._getKeyIndexFromMatchingKey = function (keyToMatch) {
|
|
var _a = this.options, isMatchingKey = _a.isMatchingKey, maxSize = _a.maxSize;
|
|
var keys = this.keys;
|
|
var keysLength = keys.length;
|
|
if (!keysLength) {
|
|
return -1;
|
|
}
|
|
if (isMatchingKey(keys[0], keyToMatch)) {
|
|
return 0;
|
|
}
|
|
if (maxSize > 1) {
|
|
for (var index = 1; index < keysLength; index++) {
|
|
if (isMatchingKey(keys[index], keyToMatch)) {
|
|
return index;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
/**
|
|
* @function _getKeyIndexForMany
|
|
*
|
|
* @description
|
|
* gets the matching key index when multiple keys are used
|
|
*
|
|
* @param keyToMatch the key to match
|
|
* @returns the index of the matching key, or -1
|
|
*/
|
|
Cache.prototype._getKeyIndexForMany = function (keyToMatch) {
|
|
var isEqual = this.options.isEqual;
|
|
var keys = this.keys;
|
|
var keysLength = keys.length;
|
|
if (!keysLength) {
|
|
return -1;
|
|
}
|
|
if (keysLength === 1) {
|
|
return this._getKeyIndexForSingle(keyToMatch);
|
|
}
|
|
var keyLength = keyToMatch.length;
|
|
var existingKey;
|
|
var argIndex;
|
|
if (keyLength > 1) {
|
|
for (var index = 0; index < keysLength; index++) {
|
|
existingKey = keys[index];
|
|
if (existingKey.length === keyLength) {
|
|
argIndex = 0;
|
|
for (; argIndex < keyLength; argIndex++) {
|
|
if (!isEqual(existingKey[argIndex], keyToMatch[argIndex])) {
|
|
break;
|
|
}
|
|
}
|
|
if (argIndex === keyLength) {
|
|
return index;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (var index = 0; index < keysLength; index++) {
|
|
existingKey = keys[index];
|
|
if (existingKey.length === keyLength &&
|
|
isEqual(existingKey[0], keyToMatch[0])) {
|
|
return index;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
/**
|
|
* @function _getKeyIndexForSingle
|
|
*
|
|
* @description
|
|
* gets the matching key index when a single key is used
|
|
*
|
|
* @param keyToMatch the key to match
|
|
* @returns the index of the matching key, or -1
|
|
*/
|
|
Cache.prototype._getKeyIndexForSingle = function (keyToMatch) {
|
|
var keys = this.keys;
|
|
if (!keys.length) {
|
|
return -1;
|
|
}
|
|
var existingKey = keys[0];
|
|
var length = existingKey.length;
|
|
if (keyToMatch.length !== length) {
|
|
return -1;
|
|
}
|
|
var isEqual = this.options.isEqual;
|
|
if (length > 1) {
|
|
for (var index = 0; index < length; index++) {
|
|
if (!isEqual(existingKey[index], keyToMatch[index])) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
return isEqual(existingKey[0], keyToMatch[0]) ? 0 : -1;
|
|
};
|
|
/**
|
|
* @function orderByLru
|
|
*
|
|
* @description
|
|
* order the array based on a Least-Recently-Used basis
|
|
*
|
|
* @param key the new key to move to the front
|
|
* @param value the new value to move to the front
|
|
* @param startingIndex the index of the item to move to the front
|
|
*/
|
|
Cache.prototype.orderByLru = function (key, value, startingIndex) {
|
|
var keys = this.keys;
|
|
var values = this.values;
|
|
var currentLength = keys.length;
|
|
var index = startingIndex;
|
|
while (index--) {
|
|
keys[index + 1] = keys[index];
|
|
values[index + 1] = values[index];
|
|
}
|
|
keys[0] = key;
|
|
values[0] = value;
|
|
var maxSize = this.options.maxSize;
|
|
if (currentLength === maxSize && startingIndex === currentLength) {
|
|
keys.pop();
|
|
values.pop();
|
|
}
|
|
else if (startingIndex >= maxSize) {
|
|
// eslint-disable-next-line no-multi-assign
|
|
keys.length = values.length = maxSize;
|
|
}
|
|
};
|
|
/**
|
|
* @function updateAsyncCache
|
|
*
|
|
* @description
|
|
* update the promise method to auto-remove from cache if rejected, and
|
|
* if resolved then fire cache hit / changed
|
|
*
|
|
* @param memoized the memoized function
|
|
*/
|
|
Cache.prototype.updateAsyncCache = function (memoized) {
|
|
var _this = this;
|
|
var _a = this.options, onCacheChange = _a.onCacheChange, onCacheHit = _a.onCacheHit;
|
|
var firstKey = this.keys[0];
|
|
var firstValue = this.values[0];
|
|
this.values[0] = firstValue.then(function (value) {
|
|
if (_this.shouldUpdateOnHit) {
|
|
onCacheHit(_this, _this.options, memoized);
|
|
}
|
|
if (_this.shouldUpdateOnChange) {
|
|
onCacheChange(_this, _this.options, memoized);
|
|
}
|
|
return value;
|
|
}, function (error) {
|
|
var keyIndex = _this.getKeyIndex(firstKey);
|
|
if (keyIndex !== -1) {
|
|
_this.keys.splice(keyIndex, 1);
|
|
_this.values.splice(keyIndex, 1);
|
|
}
|
|
throw error;
|
|
});
|
|
};
|
|
return Cache;
|
|
}());
|
|
|
|
// cache
|
|
function createMemoizedFunction(fn, options) {
|
|
if (options === void 0) { options = {}; }
|
|
if (isMemoized(fn)) {
|
|
return createMemoizedFunction(fn.fn, mergeOptions(fn.options, options));
|
|
}
|
|
if (typeof fn !== 'function') {
|
|
throw new TypeError('You must pass a function to `memoize`.');
|
|
}
|
|
var _a = options.isEqual, isEqual = _a === void 0 ? isSameValueZero : _a, isMatchingKey = options.isMatchingKey, _b = options.isPromise, isPromise = _b === void 0 ? false : _b, _c = options.maxSize, maxSize = _c === void 0 ? 1 : _c, onCacheAdd = options.onCacheAdd, onCacheChange = options.onCacheChange, onCacheHit = options.onCacheHit, transformKey = options.transformKey;
|
|
var normalizedOptions = mergeOptions({
|
|
isEqual: isEqual,
|
|
isMatchingKey: isMatchingKey,
|
|
isPromise: isPromise,
|
|
maxSize: maxSize,
|
|
onCacheAdd: onCacheAdd,
|
|
onCacheChange: onCacheChange,
|
|
onCacheHit: onCacheHit,
|
|
transformKey: transformKey,
|
|
}, getCustomOptions(options));
|
|
var cache = new Cache(normalizedOptions);
|
|
var keys = cache.keys, values = cache.values, canTransformKey = cache.canTransformKey, shouldCloneArguments = cache.shouldCloneArguments, shouldUpdateOnAdd = cache.shouldUpdateOnAdd, shouldUpdateOnChange = cache.shouldUpdateOnChange, shouldUpdateOnHit = cache.shouldUpdateOnHit;
|
|
// @ts-ignore
|
|
var memoized = function memoized() {
|
|
// @ts-ignore
|
|
var key = shouldCloneArguments
|
|
? cloneArray(arguments)
|
|
: arguments;
|
|
if (canTransformKey) {
|
|
key = transformKey(key);
|
|
}
|
|
var keyIndex = keys.length ? cache.getKeyIndex(key) : -1;
|
|
if (keyIndex !== -1) {
|
|
if (shouldUpdateOnHit) {
|
|
onCacheHit(cache, normalizedOptions, memoized);
|
|
}
|
|
if (keyIndex) {
|
|
cache.orderByLru(keys[keyIndex], values[keyIndex], keyIndex);
|
|
if (shouldUpdateOnChange) {
|
|
onCacheChange(cache, normalizedOptions, memoized);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
var newValue = fn.apply(this, arguments);
|
|
var newKey = shouldCloneArguments
|
|
? key
|
|
: cloneArray(arguments);
|
|
cache.orderByLru(newKey, newValue, keys.length);
|
|
if (isPromise) {
|
|
cache.updateAsyncCache(memoized);
|
|
}
|
|
if (shouldUpdateOnAdd) {
|
|
onCacheAdd(cache, normalizedOptions, memoized);
|
|
}
|
|
if (shouldUpdateOnChange) {
|
|
onCacheChange(cache, normalizedOptions, memoized);
|
|
}
|
|
}
|
|
return values[0];
|
|
};
|
|
memoized.cache = cache;
|
|
memoized.fn = fn;
|
|
memoized.isMemoized = true;
|
|
memoized.options = normalizedOptions;
|
|
return memoized;
|
|
}
|
|
//# sourceMappingURL=micro-memoize.esm.js.map
|
|
|
|
const s=({navigator:t,hash:e,search:o,fallback:r}={})=>{let n;const s=(t,e)=>{const o=t.substr(1).split("&").find(t=>0===t.indexOf(e));if(o)return o.split("=").pop()};return "undefined"!=typeof window&&(t&&(n=window.navigator.language||window.navigator.languages[0]),o&&(n=s(window.location.search,o)),e&&(n=s(window.location.hash,e))),n||r};let a,i;const c=createMemoizedFunction((t,e,o)=>new MessageFormat(t,e,o)),l=createMemoizedFunction((t,e)=>i[e][t]||objectResolvePath(i[e],t)),p=(t,e,o=a)=>c(t,o).format(e),f=(t,e,o=a)=>{"string"==typeof e&&(o=e,e=void 0);const r=l(t,o);return r?e?c(r,o).format(e):r:t};f.time=(t,e="short",o)=>p(`{t,time,${e}}`,{t:t},o),f.date=(t,e="short",o)=>p(`{d,date,${e}}`,{d:t},o),f.number=(t,e)=>p("{n,number}",{n:t},e),f.capital=(t,e,o)=>(t=>t.replace(/(^|\s)\S/,t=>t.toUpperCase()))(f(t,e,o)),f.title=(t,e,o)=>(t=>t.replace(/(^|\s)\S/g,t=>t.toUpperCase()))(f(t,e,o)),f.upper=(t,e,o)=>(t=>t.toLocaleUpperCase())(f(t,e,o)),f.lower=(t,e,o)=>(t=>t.toLocaleLowerCase())(f(t,e,o));const m=writable({});m.subscribe(t=>{i=t;});const u=writable({}),d=u.set;u.set=t=>{const e=(t=>{if(i[t])return t;if("string"==typeof t){const e=t.split("-").shift();if(i[e])return e}return null})(t);return e?d(e):(console.warn(`[svelte-i18n] Locale "${t}" not found.`),d(t))},u.update=t=>d(t(a)),u.subscribe(t=>{a=t;});const w=derived([u,m],()=>f);
|
|
|
|
// defining a locale dictionary
|
|
m.set({
|
|
pt: {
|
|
'switch.lang': 'Trocar idioma',
|
|
greeting: {
|
|
ask: 'Por favor, digite seu nome',
|
|
message: 'Olá {name}, como vai?',
|
|
},
|
|
photos:
|
|
'Você {n, plural, =0 {não tem fotos.} =1 {tem uma foto.} other {tem # fotos.}}',
|
|
cats: 'Tenho {n, number} {n,plural,=0{gatos}one{gato}other{gatos}}',
|
|
},
|
|
en: {
|
|
'switch.lang': 'Switch language',
|
|
greeting: {
|
|
ask: 'Please type your name',
|
|
message: 'Hello {name}, how are you?',
|
|
},
|
|
photos:
|
|
'You have {n, plural, =0 {no photos.} =1 {one photo.} other {# photos.}}',
|
|
cats: 'I have {n, number} {n,plural,one{cat}other{cats}}',
|
|
},
|
|
});
|
|
|
|
u.set(
|
|
s({
|
|
navigator: true,
|
|
hash: 'lang',
|
|
fallback: 'pt',
|
|
}),
|
|
);
|
|
|
|
u.subscribe(l => {
|
|
console.log('locale change', l);
|
|
});
|
|
|
|
/* src/App.svelte generated by Svelte v3.5.1 */
|
|
|
|
const file = "src/App.svelte";
|
|
|
|
function create_fragment(ctx) {
|
|
var t0_value = JSON.stringify(Object.keys(ctx.$dictionary), null, ' '), t0, t1, input0, input0_placeholder_value, t2, br0, t3, h1, t4_value = ctx.$_.title('greeting.message', { name: ctx.name }), t4, t5, br1, t6, input1, t7, h20, t8, t9_value = ctx.$_('photos', { n: ctx.pluralN }), t9, t10, br2, t11, input2, t12, h21, t13, t14_value = ctx.$_('cats', { n: ctx.catsN }), t14, t15, br3, t16, h22, t17, t18_value = ctx.$_.number(ctx.catsN), t18, t19, br4, t20, h23, t21, t22_value = ctx.$_.date(ctx.date, 'short'), t22, t23, br5, t24, h24, t25, t26_value = ctx.$_.time(ctx.date, 'medium'), t26, t27, br6, t28, button, t29_value = ctx.$_('switch.lang', null, ctx.oppositeLocale), t29, dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
input0 = element("input");
|
|
t2 = space();
|
|
br0 = element("br");
|
|
t3 = space();
|
|
h1 = element("h1");
|
|
t4 = text(t4_value);
|
|
t5 = space();
|
|
br1 = element("br");
|
|
t6 = space();
|
|
input1 = element("input");
|
|
t7 = space();
|
|
h20 = element("h2");
|
|
t8 = text("Plural: ");
|
|
t9 = text(t9_value);
|
|
t10 = space();
|
|
br2 = element("br");
|
|
t11 = space();
|
|
input2 = element("input");
|
|
t12 = space();
|
|
h21 = element("h2");
|
|
t13 = text("Number: ");
|
|
t14 = text(t14_value);
|
|
t15 = space();
|
|
br3 = element("br");
|
|
t16 = space();
|
|
h22 = element("h2");
|
|
t17 = text("Number util: ");
|
|
t18 = text(t18_value);
|
|
t19 = space();
|
|
br4 = element("br");
|
|
t20 = space();
|
|
h23 = element("h2");
|
|
t21 = text("Date util: ");
|
|
t22 = text(t22_value);
|
|
t23 = space();
|
|
br5 = element("br");
|
|
t24 = space();
|
|
h24 = element("h2");
|
|
t25 = text("Time util: ");
|
|
t26 = text(t26_value);
|
|
t27 = space();
|
|
br6 = element("br");
|
|
t28 = space();
|
|
button = element("button");
|
|
t29 = text(t29_value);
|
|
input0.className = "w-100";
|
|
attr(input0, "type", "text");
|
|
input0.placeholder = input0_placeholder_value = ctx.$_('greeting.ask');
|
|
add_location(input0, file, 17, 0, 318);
|
|
add_location(br0, file, 22, 0, 413);
|
|
add_location(h1, file, 24, 0, 421);
|
|
add_location(br1, file, 26, 0, 472);
|
|
attr(input1, "type", "range");
|
|
input1.min = "0";
|
|
input1.max = "5";
|
|
input1.step = "1";
|
|
add_location(input1, file, 27, 0, 479);
|
|
add_location(h20, file, 28, 0, 548);
|
|
add_location(br2, file, 30, 0, 597);
|
|
attr(input2, "type", "range");
|
|
input2.min = "100";
|
|
input2.max = "100000000";
|
|
input2.step = "10000";
|
|
add_location(input2, file, 31, 0, 604);
|
|
add_location(h21, file, 32, 0, 685);
|
|
add_location(br3, file, 34, 0, 730);
|
|
add_location(h22, file, 35, 0, 737);
|
|
add_location(br4, file, 37, 0, 779);
|
|
add_location(h23, file, 38, 0, 786);
|
|
add_location(br5, file, 40, 0, 832);
|
|
add_location(h24, file, 41, 0, 839);
|
|
add_location(br6, file, 43, 0, 886);
|
|
add_location(button, file, 44, 0, 893);
|
|
|
|
dispose = [
|
|
listen(input0, "input", ctx.input0_input_handler),
|
|
listen(input1, "change", ctx.input1_change_input_handler),
|
|
listen(input1, "input", ctx.input1_change_input_handler),
|
|
listen(input2, "change", ctx.input2_change_input_handler),
|
|
listen(input2, "input", ctx.input2_change_input_handler),
|
|
listen(button, "click", ctx.click_handler)
|
|
];
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t0, anchor);
|
|
insert(target, t1, anchor);
|
|
insert(target, input0, anchor);
|
|
|
|
input0.value = ctx.name;
|
|
|
|
insert(target, t2, anchor);
|
|
insert(target, br0, anchor);
|
|
insert(target, t3, anchor);
|
|
insert(target, h1, anchor);
|
|
append(h1, t4);
|
|
insert(target, t5, anchor);
|
|
insert(target, br1, anchor);
|
|
insert(target, t6, anchor);
|
|
insert(target, input1, anchor);
|
|
|
|
input1.value = ctx.pluralN;
|
|
|
|
insert(target, t7, anchor);
|
|
insert(target, h20, anchor);
|
|
append(h20, t8);
|
|
append(h20, t9);
|
|
insert(target, t10, anchor);
|
|
insert(target, br2, anchor);
|
|
insert(target, t11, anchor);
|
|
insert(target, input2, anchor);
|
|
|
|
input2.value = ctx.catsN;
|
|
|
|
insert(target, t12, anchor);
|
|
insert(target, h21, anchor);
|
|
append(h21, t13);
|
|
append(h21, t14);
|
|
insert(target, t15, anchor);
|
|
insert(target, br3, anchor);
|
|
insert(target, t16, anchor);
|
|
insert(target, h22, anchor);
|
|
append(h22, t17);
|
|
append(h22, t18);
|
|
insert(target, t19, anchor);
|
|
insert(target, br4, anchor);
|
|
insert(target, t20, anchor);
|
|
insert(target, h23, anchor);
|
|
append(h23, t21);
|
|
append(h23, t22);
|
|
insert(target, t23, anchor);
|
|
insert(target, br5, anchor);
|
|
insert(target, t24, anchor);
|
|
insert(target, h24, anchor);
|
|
append(h24, t25);
|
|
append(h24, t26);
|
|
insert(target, t27, anchor);
|
|
insert(target, br6, anchor);
|
|
insert(target, t28, anchor);
|
|
insert(target, button, anchor);
|
|
append(button, t29);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.$dictionary) && t0_value !== (t0_value = JSON.stringify(Object.keys(ctx.$dictionary), null, ' '))) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if (changed.name && (input0.value !== ctx.name)) input0.value = ctx.name;
|
|
|
|
if ((changed.$_) && input0_placeholder_value !== (input0_placeholder_value = ctx.$_('greeting.ask'))) {
|
|
input0.placeholder = input0_placeholder_value;
|
|
}
|
|
|
|
if ((changed.$_ || changed.name) && t4_value !== (t4_value = ctx.$_.title('greeting.message', { name: ctx.name }))) {
|
|
set_data(t4, t4_value);
|
|
}
|
|
|
|
if (changed.pluralN) input1.value = ctx.pluralN;
|
|
|
|
if ((changed.$_ || changed.pluralN) && t9_value !== (t9_value = ctx.$_('photos', { n: ctx.pluralN }))) {
|
|
set_data(t9, t9_value);
|
|
}
|
|
|
|
if (changed.catsN) input2.value = ctx.catsN;
|
|
|
|
if ((changed.$_ || changed.catsN) && t14_value !== (t14_value = ctx.$_('cats', { n: ctx.catsN }))) {
|
|
set_data(t14, t14_value);
|
|
}
|
|
|
|
if ((changed.$_ || changed.catsN) && t18_value !== (t18_value = ctx.$_.number(ctx.catsN))) {
|
|
set_data(t18, t18_value);
|
|
}
|
|
|
|
if ((changed.$_ || changed.date) && t22_value !== (t22_value = ctx.$_.date(ctx.date, 'short'))) {
|
|
set_data(t22, t22_value);
|
|
}
|
|
|
|
if ((changed.$_ || changed.date) && t26_value !== (t26_value = ctx.$_.time(ctx.date, 'medium'))) {
|
|
set_data(t26, t26_value);
|
|
}
|
|
|
|
if ((changed.$_ || changed.oppositeLocale) && t29_value !== (t29_value = ctx.$_('switch.lang', null, ctx.oppositeLocale))) {
|
|
set_data(t29, t29_value);
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t0);
|
|
detach(t1);
|
|
detach(input0);
|
|
detach(t2);
|
|
detach(br0);
|
|
detach(t3);
|
|
detach(h1);
|
|
detach(t5);
|
|
detach(br1);
|
|
detach(t6);
|
|
detach(input1);
|
|
detach(t7);
|
|
detach(h20);
|
|
detach(t10);
|
|
detach(br2);
|
|
detach(t11);
|
|
detach(input2);
|
|
detach(t12);
|
|
detach(h21);
|
|
detach(t15);
|
|
detach(br3);
|
|
detach(t16);
|
|
detach(h22);
|
|
detach(t19);
|
|
detach(br4);
|
|
detach(t20);
|
|
detach(h23);
|
|
detach(t23);
|
|
detach(br5);
|
|
detach(t24);
|
|
detach(h24);
|
|
detach(t27);
|
|
detach(br6);
|
|
detach(t28);
|
|
detach(button);
|
|
}
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance($$self, $$props, $$invalidate) {
|
|
let $locale, $dictionary, $_;
|
|
|
|
validate_store(u, 'locale');
|
|
subscribe($$self, u, $$value => { $locale = $$value; $$invalidate('$locale', $locale); });
|
|
validate_store(m, 'dictionary');
|
|
subscribe($$self, m, $$value => { $dictionary = $$value; $$invalidate('$dictionary', $dictionary); });
|
|
validate_store(w, '_');
|
|
subscribe($$self, w, $$value => { $_ = $$value; $$invalidate('$_', $_); });
|
|
|
|
let name = '';
|
|
let pluralN = 2;
|
|
let catsN = 992301;
|
|
let date = new Date();
|
|
|
|
setInterval(() => {
|
|
$$invalidate('date', date = new Date());
|
|
}, 1000);
|
|
|
|
function input0_input_handler() {
|
|
name = this.value;
|
|
$$invalidate('name', name);
|
|
}
|
|
|
|
function input1_change_input_handler() {
|
|
pluralN = to_number(this.value);
|
|
$$invalidate('pluralN', pluralN);
|
|
}
|
|
|
|
function input2_change_input_handler() {
|
|
catsN = to_number(this.value);
|
|
$$invalidate('catsN', catsN);
|
|
}
|
|
|
|
function click_handler() {
|
|
return u.set(oppositeLocale);
|
|
}
|
|
|
|
let oppositeLocale;
|
|
|
|
$$self.$$.update = ($$dirty = { $locale: 1 }) => {
|
|
if ($$dirty.$locale) { $$invalidate('oppositeLocale', oppositeLocale = $locale === 'pt' ? 'en' : 'pt'); }
|
|
};
|
|
|
|
return {
|
|
name,
|
|
pluralN,
|
|
catsN,
|
|
date,
|
|
oppositeLocale,
|
|
$dictionary,
|
|
$_,
|
|
input0_input_handler,
|
|
input1_change_input_handler,
|
|
input2_change_input_handler,
|
|
click_handler
|
|
};
|
|
}
|
|
|
|
class App extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance, create_fragment, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
const app = new App({
|
|
target: document.body,
|
|
props: { name: 'world' },
|
|
});
|
|
|
|
return app;
|
|
|
|
}());
|
|
//# sourceMappingURL=bundle.js.map
|