Hawk/build/js/libs/l10n.js
Mahdi Dibaiee ee6f5d6ffb feat setup: Setup Redux, Immutable.js and React
feat FileList: Implement File List + changedir action
2015-08-31 11:19:22 +04:30

1572 lines
36 KiB
JavaScript

// This is the Gaia version of l20n: https://github.com/l20n/l20n.js
// l20n is Apache 2.0 licensed: https://github.com/l20n/l20n.js/blob/master/LICENSE
// You can find the latest build for Gaia here: https://github.com/mozilla-b2g/gaia/blob/master/shared/js/l10n.js
(function(window, undefined) {
'use strict';
/* jshint validthis:true */
function L10nError(message, id, loc) {
this.name = 'L10nError';
this.message = message;
this.id = id;
this.loc = loc;
}
L10nError.prototype = Object.create(Error.prototype);
L10nError.prototype.constructor = L10nError;
/* jshint browser:true */
var io = {
load: function load(url, callback, sync) {
var xhr = new XMLHttpRequest();
if (xhr.overrideMimeType) {
xhr.overrideMimeType('text/plain');
}
xhr.open('GET', url, !sync);
xhr.addEventListener('load', function io_load(e) {
if (e.target.status === 200 || e.target.status === 0) {
callback(null, e.target.responseText);
} else {
callback(new L10nError('Not found: ' + url));
}
});
xhr.addEventListener('error', callback);
xhr.addEventListener('timeout', callback);
// the app: protocol throws on 404, see https://bugzil.la/827243
try {
xhr.send(null);
} catch (e) {
callback(new L10nError('Not found: ' + url));
}
},
loadJSON: function loadJSON(url, callback) {
var xhr = new XMLHttpRequest();
if (xhr.overrideMimeType) {
xhr.overrideMimeType('application/json');
}
xhr.open('GET', url);
xhr.responseType = 'json';
xhr.addEventListener('load', function io_loadjson(e) {
if (e.target.status === 200 || e.target.status === 0) {
callback(null, e.target.response);
} else {
callback(new L10nError('Not found: ' + url));
}
});
xhr.addEventListener('error', callback);
xhr.addEventListener('timeout', callback);
// the app: protocol throws on 404, see https://bugzil.la/827243
try {
xhr.send(null);
} catch (e) {
callback(new L10nError('Not found: ' + url));
}
}
};
function EventEmitter() {}
EventEmitter.prototype.emit = function ee_emit() {
if (!this._listeners) {
return;
}
var args = Array.prototype.slice.call(arguments);
var type = args.shift();
if (!this._listeners[type]) {
return;
}
var typeListeners = this._listeners[type].slice();
for (var i = 0; i < typeListeners.length; i++) {
typeListeners[i].apply(this, args);
}
};
EventEmitter.prototype.addEventListener = function ee_add(type, listener) {
if (!this._listeners) {
this._listeners = {};
}
if (!(type in this._listeners)) {
this._listeners[type] = [];
}
this._listeners[type].push(listener);
};
EventEmitter.prototype.removeEventListener = function ee_rm(type, listener) {
if (!this._listeners) {
return;
}
var typeListeners = this._listeners[type];
var pos = typeListeners.indexOf(listener);
if (pos === -1) {
return;
}
typeListeners.splice(pos, 1);
};
function getPluralRule(lang) {
var locales2rules = {
'af': 3,
'ak': 4,
'am': 4,
'ar': 1,
'asa': 3,
'az': 0,
'be': 11,
'bem': 3,
'bez': 3,
'bg': 3,
'bh': 4,
'bm': 0,
'bn': 3,
'bo': 0,
'br': 20,
'brx': 3,
'bs': 11,
'ca': 3,
'cgg': 3,
'chr': 3,
'cs': 12,
'cy': 17,
'da': 3,
'de': 3,
'dv': 3,
'dz': 0,
'ee': 3,
'el': 3,
'en': 3,
'eo': 3,
'es': 3,
'et': 3,
'eu': 3,
'fa': 0,
'ff': 5,
'fi': 3,
'fil': 4,
'fo': 3,
'fr': 5,
'fur': 3,
'fy': 3,
'ga': 8,
'gd': 24,
'gl': 3,
'gsw': 3,
'gu': 3,
'guw': 4,
'gv': 23,
'ha': 3,
'haw': 3,
'he': 2,
'hi': 4,
'hr': 11,
'hu': 0,
'id': 0,
'ig': 0,
'ii': 0,
'is': 3,
'it': 3,
'iu': 7,
'ja': 0,
'jmc': 3,
'jv': 0,
'ka': 0,
'kab': 5,
'kaj': 3,
'kcg': 3,
'kde': 0,
'kea': 0,
'kk': 3,
'kl': 3,
'km': 0,
'kn': 0,
'ko': 0,
'ksb': 3,
'ksh': 21,
'ku': 3,
'kw': 7,
'lag': 18,
'lb': 3,
'lg': 3,
'ln': 4,
'lo': 0,
'lt': 10,
'lv': 6,
'mas': 3,
'mg': 4,
'mk': 16,
'ml': 3,
'mn': 3,
'mo': 9,
'mr': 3,
'ms': 0,
'mt': 15,
'my': 0,
'nah': 3,
'naq': 7,
'nb': 3,
'nd': 3,
'ne': 3,
'nl': 3,
'nn': 3,
'no': 3,
'nr': 3,
'nso': 4,
'ny': 3,
'nyn': 3,
'om': 3,
'or': 3,
'pa': 3,
'pap': 3,
'pl': 13,
'ps': 3,
'pt': 3,
'rm': 3,
'ro': 9,
'rof': 3,
'ru': 11,
'rwk': 3,
'sah': 0,
'saq': 3,
'se': 7,
'seh': 3,
'ses': 0,
'sg': 0,
'sh': 11,
'shi': 19,
'sk': 12,
'sl': 14,
'sma': 7,
'smi': 7,
'smj': 7,
'smn': 7,
'sms': 7,
'sn': 3,
'so': 3,
'sq': 3,
'sr': 11,
'ss': 3,
'ssy': 3,
'st': 3,
'sv': 3,
'sw': 3,
'syr': 3,
'ta': 3,
'te': 3,
'teo': 3,
'th': 0,
'ti': 4,
'tig': 3,
'tk': 3,
'tl': 4,
'tn': 3,
'to': 0,
'tr': 0,
'ts': 3,
'tzm': 22,
'uk': 11,
'ur': 3,
've': 3,
'vi': 0,
'vun': 3,
'wa': 4,
'wae': 3,
'wo': 0,
'xh': 3,
'xog': 3,
'yo': 0,
'zh': 0,
'zu': 3
};
// utility functions for plural rules methods
function isIn(n, list) {
return list.indexOf(n) !== -1;
}
function isBetween(n, start, end) {
return start <= n && n <= end;
}
// list of all plural rules methods:
// map an integer to the plural form name to use
var pluralRules = {
'0': function() {
return 'other';
},
'1': function(n) {
if ((isBetween((n % 100), 3, 10))) {
return 'few';
}
if (n === 0) {
return 'zero';
}
if ((isBetween((n % 100), 11, 99))) {
return 'many';
}
if (n === 2) {
return 'two';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'2': function(n) {
if (n !== 0 && (n % 10) === 0) {
return 'many';
}
if (n === 2) {
return 'two';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'3': function(n) {
if (n === 1) {
return 'one';
}
return 'other';
},
'4': function(n) {
if ((isBetween(n, 0, 1))) {
return 'one';
}
return 'other';
},
'5': function(n) {
if ((isBetween(n, 0, 2)) && n !== 2) {
return 'one';
}
return 'other';
},
'6': function(n) {
if (n === 0) {
return 'zero';
}
if ((n % 10) === 1 && (n % 100) !== 11) {
return 'one';
}
return 'other';
},
'7': function(n) {
if (n === 2) {
return 'two';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'8': function(n) {
if ((isBetween(n, 3, 6))) {
return 'few';
}
if ((isBetween(n, 7, 10))) {
return 'many';
}
if (n === 2) {
return 'two';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'9': function(n) {
if (n === 0 || n !== 1 && (isBetween((n % 100), 1, 19))) {
return 'few';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'10': function(n) {
if ((isBetween((n % 10), 2, 9)) && !(isBetween((n % 100), 11, 19))) {
return 'few';
}
if ((n % 10) === 1 && !(isBetween((n % 100), 11, 19))) {
return 'one';
}
return 'other';
},
'11': function(n) {
if ((isBetween((n % 10), 2, 4)) && !(isBetween((n % 100), 12, 14))) {
return 'few';
}
if ((n % 10) === 0 ||
(isBetween((n % 10), 5, 9)) ||
(isBetween((n % 100), 11, 14))) {
return 'many';
}
if ((n % 10) === 1 && (n % 100) !== 11) {
return 'one';
}
return 'other';
},
'12': function(n) {
if ((isBetween(n, 2, 4))) {
return 'few';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'13': function(n) {
if ((isBetween((n % 10), 2, 4)) && !(isBetween((n % 100), 12, 14))) {
return 'few';
}
if (n !== 1 && (isBetween((n % 10), 0, 1)) ||
(isBetween((n % 10), 5, 9)) ||
(isBetween((n % 100), 12, 14))) {
return 'many';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'14': function(n) {
if ((isBetween((n % 100), 3, 4))) {
return 'few';
}
if ((n % 100) === 2) {
return 'two';
}
if ((n % 100) === 1) {
return 'one';
}
return 'other';
},
'15': function(n) {
if (n === 0 || (isBetween((n % 100), 2, 10))) {
return 'few';
}
if ((isBetween((n % 100), 11, 19))) {
return 'many';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'16': function(n) {
if ((n % 10) === 1 && n !== 11) {
return 'one';
}
return 'other';
},
'17': function(n) {
if (n === 3) {
return 'few';
}
if (n === 0) {
return 'zero';
}
if (n === 6) {
return 'many';
}
if (n === 2) {
return 'two';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'18': function(n) {
if (n === 0) {
return 'zero';
}
if ((isBetween(n, 0, 2)) && n !== 0 && n !== 2) {
return 'one';
}
return 'other';
},
'19': function(n) {
if ((isBetween(n, 2, 10))) {
return 'few';
}
if ((isBetween(n, 0, 1))) {
return 'one';
}
return 'other';
},
'20': function(n) {
if ((isBetween((n % 10), 3, 4) || ((n % 10) === 9)) && !(
isBetween((n % 100), 10, 19) ||
isBetween((n % 100), 70, 79) ||
isBetween((n % 100), 90, 99)
)) {
return 'few';
}
if ((n % 1000000) === 0 && n !== 0) {
return 'many';
}
if ((n % 10) === 2 && !isIn((n % 100), [12, 72, 92])) {
return 'two';
}
if ((n % 10) === 1 && !isIn((n % 100), [11, 71, 91])) {
return 'one';
}
return 'other';
},
'21': function(n) {
if (n === 0) {
return 'zero';
}
if (n === 1) {
return 'one';
}
return 'other';
},
'22': function(n) {
if ((isBetween(n, 0, 1)) || (isBetween(n, 11, 99))) {
return 'one';
}
return 'other';
},
'23': function(n) {
if ((isBetween((n % 10), 1, 2)) || (n % 20) === 0) {
return 'one';
}
return 'other';
},
'24': function(n) {
if ((isBetween(n, 3, 10) || isBetween(n, 13, 19))) {
return 'few';
}
if (isIn(n, [2, 12])) {
return 'two';
}
if (isIn(n, [1, 11])) {
return 'one';
}
return 'other';
}
};
// return a function that gives the plural form name for a given integer
var index = locales2rules[lang.replace(/-.*$/, '')];
if (!(index in pluralRules)) {
return function() { return 'other'; };
}
return pluralRules[index];
}
var nestedProps = ['style', 'dataset'];
var parsePatterns;
function parse(ctx, source) {
var ast = {};
if (!parsePatterns) {
parsePatterns = {
comment: /^\s*#|^\s*$/,
entity: /^([^=\s]+)\s*=\s*(.+)$/,
multiline: /[^\\]\\$/,
macro: /\{\[\s*(\w+)\(([^\)]*)\)\s*\]\}/i,
unicode: /\\u([0-9a-fA-F]{1,4})/g,
entries: /[\r\n]+/,
controlChars: /\\([\\\n\r\t\b\f\{\}\"\'])/g
};
}
var entries = source.split(parsePatterns.entries);
for (var i = 0; i < entries.length; i++) {
var line = entries[i];
if (parsePatterns.comment.test(line)) {
continue;
}
while (parsePatterns.multiline.test(line) && i < entries.length) {
line = line.slice(0, -1) + entries[++i].trim();
}
var entityMatch = line.match(parsePatterns.entity);
if (entityMatch) {
try {
parseEntity(entityMatch[1], entityMatch[2], ast);
} catch (e) {
if (ctx) {
ctx._emitter.emit('error', e);
} else {
throw e;
}
}
}
}
return ast;
}
function setEntityValue(id, attr, key, value, ast) {
var obj = ast;
var prop = id;
if (attr) {
if (!(id in obj)) {
obj[id] = {};
}
if (typeof(obj[id]) === 'string') {
obj[id] = {'_': obj[id]};
}
obj = obj[id];
prop = attr;
}
if (!key) {
obj[prop] = value;
return;
}
if (!(prop in obj)) {
obj[prop] = {'_': {}};
} else if (typeof(obj[prop]) === 'string') {
obj[prop] = {'_index': parseMacro(obj[prop]), '_': {}};
}
obj[prop]._[key] = value;
}
function parseEntity(id, value, ast) {
var name, key;
var pos = id.indexOf('[');
if (pos !== -1) {
name = id.substr(0, pos);
key = id.substring(pos + 1, id.length - 1);
} else {
name = id;
key = null;
}
var nameElements = name.split('.');
var attr;
if (nameElements.length > 1) {
var attrElements = [];
attrElements.push(nameElements.pop());
if (nameElements.length > 1) {
// Usually the last dot separates an attribute from an id
//
// In case when there are more than one dot in the id
// and the second to last item is "style" or "dataset" then the last two
// items are becoming the attribute.
//
// ex.
// id.style.color = foo =>
//
// id:
// style.color: foo
//
// id.other.color = foo =>
//
// id.other:
// color: foo
if (nestedProps.indexOf(nameElements[nameElements.length - 1]) !== -1) {
attrElements.push(nameElements.pop());
}
}
name = nameElements.join('.');
attr = attrElements.reverse().join('.');
} else {
attr = null;
}
setEntityValue(name, attr, key, unescapeString(value), ast);
}
function unescapeControlCharacters(str) {
return str.replace(parsePatterns.controlChars, '$1');
}
function unescapeUnicode(str) {
return str.replace(parsePatterns.unicode, function(match, token) {
return unescape('%u' + '0000'.slice(token.length) + token);
});
}
function unescapeString(str) {
if (str.lastIndexOf('\\') !== -1) {
str = unescapeControlCharacters(str);
}
return unescapeUnicode(str);
}
function parseMacro(str) {
var match = str.match(parsePatterns.macro);
if (!match) {
throw new L10nError('Malformed macro');
}
return [match[1], match[2]];
}
var MAX_PLACEABLE_LENGTH = 2500;
var MAX_PLACEABLES = 100;
var rePlaceables = /\{\{\s*(.+?)\s*\}\}/g;
function Entity(id, node, env) {
this.id = id;
this.env = env;
// the dirty guard prevents cyclic or recursive references from other
// Entities; see Entity.prototype.resolve
this.dirty = false;
if (typeof node === 'string') {
this.value = node;
} else {
// it's either a hash or it has attrs, or both
for (var key in node) {
if (node.hasOwnProperty(key) && key[0] !== '_') {
if (!this.attributes) {
this.attributes = {};
}
this.attributes[key] = new Entity(this.id + '.' + key, node[key],
env);
}
}
this.value = node._ || null;
this.index = node._index;
}
}
Entity.prototype.resolve = function E_resolve(ctxdata) {
if (this.dirty) {
return undefined;
}
this.dirty = true;
var val;
// if resolve fails, we want the exception to bubble up and stop the whole
// resolving process; however, we still need to clean up the dirty flag
try {
val = resolve(ctxdata, this.env, this.value, this.index);
} finally {
this.dirty = false;
}
return val;
};
Entity.prototype.toString = function E_toString(ctxdata) {
try {
return this.resolve(ctxdata);
} catch (e) {
return undefined;
}
};
Entity.prototype.valueOf = function E_valueOf(ctxdata) {
if (!this.attributes) {
return this.toString(ctxdata);
}
var entity = {
value: this.toString(ctxdata),
attributes: {}
};
for (var key in this.attributes) {
if (this.attributes.hasOwnProperty(key)) {
entity.attributes[key] = this.attributes[key].toString(ctxdata);
}
}
return entity;
};
function subPlaceable(ctxdata, env, match, id) {
if (ctxdata && ctxdata.hasOwnProperty(id) &&
(typeof ctxdata[id] === 'string' ||
(typeof ctxdata[id] === 'number' && !isNaN(ctxdata[id])))) {
return ctxdata[id];
}
if (env.hasOwnProperty(id)) {
if (!(env[id] instanceof Entity)) {
env[id] = new Entity(id, env[id], env);
}
var value = env[id].resolve(ctxdata);
if (typeof value === 'string') {
// prevent Billion Laughs attacks
if (value.length >= MAX_PLACEABLE_LENGTH) {
throw new L10nError('Too many characters in placeable (' +
value.length + ', max allowed is ' +
MAX_PLACEABLE_LENGTH + ')');
}
return value;
}
}
return match;
}
function interpolate(ctxdata, env, str) {
var placeablesCount = 0;
var value = str.replace(rePlaceables, function(match, id) {
// prevent Quadratic Blowup attacks
if (placeablesCount++ >= MAX_PLACEABLES) {
throw new L10nError('Too many placeables (' + placeablesCount +
', max allowed is ' + MAX_PLACEABLES + ')');
}
return subPlaceable(ctxdata, env, match, id);
});
placeablesCount = 0;
return value;
}
function resolve(ctxdata, env, expr, index) {
if (typeof expr === 'string') {
return interpolate(ctxdata, env, expr);
}
if (typeof expr === 'boolean' ||
typeof expr === 'number' ||
!expr) {
return expr;
}
// otherwise, it's a dict
if (index && ctxdata && ctxdata.hasOwnProperty(index[1])) {
var argValue = ctxdata[index[1]];
// special cases for zero, one, two if they are defined on the hash
if (argValue === 0 && 'zero' in expr) {
return resolve(ctxdata, env, expr.zero);
}
if (argValue === 1 && 'one' in expr) {
return resolve(ctxdata, env, expr.one);
}
if (argValue === 2 && 'two' in expr) {
return resolve(ctxdata, env, expr.two);
}
var selector = env.__plural(argValue);
if (expr.hasOwnProperty(selector)) {
return resolve(ctxdata, env, expr[selector]);
}
}
// if there was no index or no selector was found, try 'other'
if ('other' in expr) {
return resolve(ctxdata, env, expr.other);
}
return undefined;
}
function compile(env, ast) {
env = env || {};
for (var id in ast) {
if (ast.hasOwnProperty(id)) {
env[id] = new Entity(id, ast[id], env);
}
}
return env;
}
function Locale(id, ctx) {
this.id = id;
this.ctx = ctx;
this.isReady = false;
this.entries = {
__plural: getPluralRule(id)
};
}
Locale.prototype.getEntry = function L_getEntry(id) {
/* jshint -W093 */
var entries = this.entries;
if (!entries.hasOwnProperty(id)) {
return undefined;
}
if (entries[id] instanceof Entity) {
return entries[id];
}
return entries[id] = new Entity(id, entries[id], entries);
};
Locale.prototype.build = function L_build(callback) {
var sync = !callback;
var ctx = this.ctx;
var self = this;
var l10nLoads = ctx.resLinks.length;
function onL10nLoaded(err) {
if (err) {
ctx._emitter.emit('error', err);
}
if (--l10nLoads <= 0) {
self.isReady = true;
if (callback) {
callback();
}
}
}
if (l10nLoads === 0) {
onL10nLoaded();
return;
}
function onJSONLoaded(err, json) {
if (!err && json) {
self.addAST(json);
}
onL10nLoaded(err);
}
function onPropLoaded(err, source) {
if (!err && source) {
var ast = parse(ctx, source);
self.addAST(ast);
}
onL10nLoaded(err);
}
for (var i = 0; i < ctx.resLinks.length; i++) {
var path = ctx.resLinks[i].replace('{{locale}}', this.id);
var type = path.substr(path.lastIndexOf('.') + 1);
switch (type) {
case 'json':
io.loadJSON(path, onJSONLoaded, sync);
break;
case 'properties':
io.load(path, onPropLoaded, sync);
break;
}
}
};
Locale.prototype.addAST = function(ast) {
for (var id in ast) {
if (ast.hasOwnProperty(id)) {
this.entries[id] = ast[id];
}
}
};
Locale.prototype.getEntity = function(id, ctxdata) {
var entry = this.getEntry(id);
if (!entry) {
return null;
}
return entry.valueOf(ctxdata);
};
function Context(id) {
this.id = id;
this.isReady = false;
this.isLoading = false;
this.supportedLocales = [];
this.resLinks = [];
this.locales = {};
this._emitter = new EventEmitter();
// Getting translations
function getWithFallback(id) {
/* jshint -W084 */
if (!this.isReady) {
throw new L10nError('Context not ready');
}
var cur = 0;
var loc;
var locale;
while (loc = this.supportedLocales[cur]) {
locale = this.getLocale(loc);
if (!locale.isReady) {
// build without callback, synchronously
locale.build(null);
}
var entry = locale.getEntry(id);
if (entry === undefined) {
cur++;
warning.call(this, new L10nError(id + ' not found in ' + loc, id,
loc));
continue;
}
return entry;
}
error.call(this, new L10nError(id + ' not found', id));
return null;
}
this.get = function get(id, ctxdata) {
var entry = getWithFallback.call(this, id);
if (entry === null) {
return '';
}
return entry.toString(ctxdata) || '';
};
this.getEntity = function getEntity(id, ctxdata) {
var entry = getWithFallback.call(this, id);
if (entry === null) {
return null;
}
return entry.valueOf(ctxdata);
};
// Helpers
this.getLocale = function getLocale(code) {
/* jshint -W093 */
var locales = this.locales;
if (locales[code]) {
return locales[code];
}
return locales[code] = new Locale(code, this);
};
// Getting ready
function negotiate(available, requested, defaultLocale) {
if (available.indexOf(requested[0]) === -1 ||
requested[0] === defaultLocale) {
return [defaultLocale];
} else {
return [requested[0], defaultLocale];
}
}
function freeze(supported) {
var locale = this.getLocale(supported[0]);
if (locale.isReady) {
setReady.call(this, supported);
} else {
locale.build(setReady.bind(this, supported));
}
}
function setReady(supported) {
this.supportedLocales = supported;
this.isReady = true;
this._emitter.emit('ready');
}
this.requestLocales = function requestLocales() {
if (this.isLoading && !this.isReady) {
throw new L10nError('Context not ready');
}
this.isLoading = true;
var requested = Array.prototype.slice.call(arguments);
var supported = negotiate(requested.concat('en-US'), requested, 'en-US');
freeze.call(this, supported);
};
// Events
this.addEventListener = function addEventListener(type, listener) {
this._emitter.addEventListener(type, listener);
};
this.removeEventListener = function removeEventListener(type, listener) {
this._emitter.removeEventListener(type, listener);
};
this.ready = function ready(callback) {
if (this.isReady) {
setTimeout(callback);
}
this.addEventListener('ready', callback);
};
this.once = function once(callback) {
/* jshint -W068 */
if (this.isReady) {
setTimeout(callback);
return;
}
var callAndRemove = (function() {
this.removeEventListener('ready', callAndRemove);
callback();
}).bind(this);
this.addEventListener('ready', callAndRemove);
};
// Errors
function warning(e) {
this._emitter.emit('warning', e);
return e;
}
function error(e) {
this._emitter.emit('error', e);
return e;
}
}
/* jshint -W104 */
var DEBUG = false;
var isPretranslated = false;
var rtlList = ['ar', 'he', 'fa', 'ps', 'qps-plocm', 'ur'];
// Public API
navigator.mozL10n = {
ctx: new Context(),
get: function get(id, ctxdata) {
return navigator.mozL10n.ctx.get(id, ctxdata);
},
localize: function localize(element, id, args) {
return localizeElement.call(navigator.mozL10n, element, id, args);
},
translate: function translate(element) {
return translateFragment.call(navigator.mozL10n, element);
},
ready: function ready(callback) {
return navigator.mozL10n.ctx.ready(callback);
},
once: function once(callback) {
return navigator.mozL10n.ctx.once(callback);
},
get readyState() {
return navigator.mozL10n.ctx.isReady ? 'complete' : 'loading';
},
language: {
set code(lang) {
navigator.mozL10n.ctx.requestLocales(lang);
},
get code() {
return navigator.mozL10n.ctx.supportedLocales[0];
},
get direction() {
return getDirection(navigator.mozL10n.ctx.supportedLocales[0]);
}
},
_getInternalAPI: function() {
return {
Error: L10nError,
Context: Context,
Locale: Locale,
Entity: Entity,
getPluralRule: getPluralRule,
rePlaceables: rePlaceables,
getTranslatableChildren: getTranslatableChildren,
getL10nAttributes: getL10nAttributes,
loadINI: loadINI,
fireLocalizedEvent: fireLocalizedEvent,
parse: parse,
compile: compile
};
}
};
navigator.mozL10n.ctx.ready(onReady.bind(navigator.mozL10n));
if (DEBUG) {
navigator.mozL10n.ctx.addEventListener('error', console.error);
navigator.mozL10n.ctx.addEventListener('warning', console.warn);
}
function getDirection(lang) {
return (rtlList.indexOf(lang) >= 0) ? 'rtl' : 'ltr';
}
var readyStates = {
'loading': 0,
'interactive': 1,
'complete': 2
};
function waitFor(state, callback) {
state = readyStates[state];
if (readyStates[document.readyState] >= state) {
callback();
return;
}
document.addEventListener('readystatechange', function l10n_onrsc() {
if (readyStates[document.readyState] >= state) {
document.removeEventListener('readystatechange', l10n_onrsc);
callback();
}
});
}
if (window.document) {
isPretranslated = (document.documentElement.lang === navigator.language);
// this is a special case for netError bug; see https://bugzil.la/444165
if (document.documentElement.dataset.noCompleteBug) {
pretranslate.call(navigator.mozL10n);
return;
}
if (isPretranslated) {
waitFor('interactive', function() {
window.setTimeout(initResources.bind(navigator.mozL10n));
});
} else {
if (document.readyState === 'complete') {
window.setTimeout(initResources.bind(navigator.mozL10n));
} else {
waitFor('interactive', pretranslate.bind(navigator.mozL10n));
}
}
}
function pretranslate() {
/* jshint -W068 */
if (inlineLocalization.call(this)) {
waitFor('interactive', (function() {
window.setTimeout(initResources.bind(this));
}).bind(this));
} else {
initResources.call(this);
}
}
function inlineLocalization() {
var script = document.documentElement
.querySelector('script[type="application/l10n"]' +
'[lang="' + navigator.language + '"]');
if (!script) {
return false;
}
var locale = this.ctx.getLocale(navigator.language);
// the inline localization is happenning very early, when the ctx is not
// yet ready and when the resources haven't been downloaded yet; add the
// inlined JSON directly to the current locale
locale.addAST(JSON.parse(script.innerHTML));
// localize the visible DOM
var l10n = {
ctx: locale,
language: {
code: locale.id,
direction: getDirection(locale.id)
}
};
translateFragment.call(l10n);
// the visible DOM is now pretranslated
isPretranslated = true;
return true;
}
function initResources() {
var resLinks = document.head
.querySelectorAll('link[type="application/l10n"]');
var iniLinks = [];
var i;
for (i = 0; i < resLinks.length; i++) {
var link = resLinks[i];
var url = link.getAttribute('href');
var type = url.substr(url.lastIndexOf('.') + 1);
if (type === 'ini') {
iniLinks.push(url);
}
this.ctx.resLinks.push(url);
}
var iniLoads = iniLinks.length;
if (iniLoads === 0) {
initLocale.call(this);
return;
}
function onIniLoaded(err) {
if (err) {
this.ctx._emitter.emit('error', err);
}
if (--iniLoads === 0) {
initLocale.call(this);
}
}
for (i = 0; i < iniLinks.length; i++) {
loadINI.call(this, iniLinks[i], onIniLoaded.bind(this));
}
}
function initLocale() {
this.ctx.requestLocales(navigator.language);
window.addEventListener('languagechange', function l10n_langchange() {
navigator.mozL10n.language.code = navigator.language;
});
}
function onReady() {
if (!isPretranslated) {
this.translate();
}
isPretranslated = false;
fireLocalizedEvent.call(this);
}
function fireLocalizedEvent() {
var event = new CustomEvent('localized', {
'bubbles': false,
'cancelable': false,
'detail': {
'language': this.ctx.supportedLocales[0]
}
});
window.dispatchEvent(event);
}
/* jshint -W104 */
function loadINI(url, callback) {
var ctx = this.ctx;
io.load(url, function(err, source) {
var pos = ctx.resLinks.indexOf(url);
if (err) {
// remove the ini link from resLinks
ctx.resLinks.splice(pos, 1);
return callback(err);
}
if (!source) {
ctx.resLinks.splice(pos, 1);
return callback(new Error('Empty file: ' + url));
}
var patterns = parseINI(source, url).resources.map(function(x) {
return x.replace('en-US', '{{locale}}');
});
ctx.resLinks.splice.apply(ctx.resLinks, [pos, 1].concat(patterns));
callback();
});
}
function relativePath(baseUrl, url) {
if (url[0] === '/') {
return url;
}
var dirs = baseUrl.split('/')
.slice(0, -1)
.concat(url.split('/'))
.filter(function(path) {
return path !== '.';
});
return dirs.join('/');
}
var iniPatterns = {
'section': /^\s*\[(.*)\]\s*$/,
'import': /^\s*@import\s+url\((.*)\)\s*$/i,
'entry': /[\r\n]+/
};
function parseINI(source, iniPath) {
var entries = source.split(iniPatterns.entry);
var locales = ['en-US'];
var genericSection = true;
var uris = [];
var match;
for (var i = 0; i < entries.length; i++) {
var line = entries[i];
// we only care about en-US resources
if (genericSection && iniPatterns['import'].test(line)) {
match = iniPatterns['import'].exec(line);
var uri = relativePath(iniPath, match[1]);
uris.push(uri);
continue;
}
// but we need the list of all locales in the ini, too
if (iniPatterns.section.test(line)) {
genericSection = false;
match = iniPatterns.section.exec(line);
locales.push(match[1]);
}
}
return {
locales: locales,
resources: uris
};
}
/* jshint -W104 */
function translateFragment(element) {
if (!element) {
element = document.documentElement;
document.documentElement.lang = this.language.code;
document.documentElement.dir = this.language.direction;
}
translateElement.call(this, element);
var nodes = getTranslatableChildren(element);
for (var i = 0; i < nodes.length; i++ ) {
translateElement.call(this, nodes[i]);
}
}
function getTranslatableChildren(element) {
return element ? element.querySelectorAll('*[data-l10n-id]') : [];
}
function localizeElement(element, id, args) {
if (!element) {
return;
}
if (!id) {
element.removeAttribute('data-l10n-id');
element.removeAttribute('data-l10n-args');
setTextContent(element, '');
return;
}
element.setAttribute('data-l10n-id', id);
if (args && typeof args === 'object') {
element.setAttribute('data-l10n-args', JSON.stringify(args));
} else {
element.removeAttribute('data-l10n-args');
}
if (this.ctx.isReady) {
translateElement.call(this, element);
}
}
function getL10nAttributes(element) {
if (!element) {
return {};
}
var l10nId = element.getAttribute('data-l10n-id');
var l10nArgs = element.getAttribute('data-l10n-args');
var args = l10nArgs ? JSON.parse(l10nArgs) : null;
return {id: l10nId, args: args};
}
function translateElement(element) {
var l10n = getL10nAttributes(element);
if (!l10n.id) {
return;
}
var entity = this.ctx.getEntity(l10n.id, l10n.args);
if (!entity) {
return;
}
if (typeof entity === 'string') {
setTextContent(element, entity);
return true;
}
if (entity.value) {
setTextContent(element, entity.value);
}
for (var key in entity.attributes) {
if (entity.attributes.hasOwnProperty(key)) {
var attr = entity.attributes[key];
var pos = key.indexOf('.');
if (pos !== -1) {
element[key.substr(0, pos)][key.substr(pos + 1)] = attr;
} else if (key === 'ariaLabel') {
element.setAttribute('aria-label', attr);
} else {
element[key] = attr;
}
}
}
return true;
}
function setTextContent(element, text) {
// standard case: no element children
if (!element.firstElementChild) {
element.textContent = text;
return;
}
// this element has element children: replace the content of the first
// (non-blank) child textNode and clear other child textNodes
var found = false;
var reNotBlank = /\S/;
for (var child = element.firstChild; child; child = child.nextSibling) {
if (child.nodeType === Node.TEXT_NODE &&
reNotBlank.test(child.nodeValue)) {
if (found) {
child.nodeValue = '';
} else {
child.nodeValue = text;
found = true;
}
}
}
// if no (non-empty) textNode is found, insert a textNode before the
// element's first child.
if (!found) {
element.insertBefore(document.createTextNode(text), element.firstChild);
}
}
})(this);