diff --git a/resources/report/js/encoding.js b/resources/report/js/encoding.js new file mode 100644 index 00000000..149aa497 --- /dev/null +++ b/resources/report/js/encoding.js @@ -0,0 +1,2408 @@ +// Copyright 2014 Joshua Bell. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// If we're in node require encoding-indexes and attach it to the global. +/** + * @fileoverview Global `this` required for resolving indexes in node. + * @suppress {globalThis} + */ +if (typeof module !== "undefined" && module.exports) { + this["encoding-indexes"] = + require("./encoding-indexes.js")["encoding-indexes"]; +} + +(function(global) { + 'use strict'; + + // + // Utilities + // + + /** + * @param {number} a The number to test. + * @param {number} min The minimum value in the range, inclusive. + * @param {number} max The maximum value in the range, inclusive. + * @return {boolean} True if a >= min and a <= max. + */ + function inRange(a, min, max) { + return min <= a && a <= max; + } + + /** + * @param {number} n The numerator. + * @param {number} d The denominator. + * @return {number} The result of the integer division of n by d. + */ + function div(n, d) { + return Math.floor(n / d); + } + + /** + * @param {Object=} o + * @return {Object} + * TODO: Use Object() if Closure Compiler can be made to accept it. + */ + function ToDictionary(o) { return o || {}; } + + + // + // Implementation of Encoding specification + // http://dvcs.w3.org/hg/encoding/raw-file/tip/Overview.html + // + + // + // 3. Terminology + // + + // + // 4. Encodings + // + + /** @const */ var EOF_byte = -1; + /** @const */ var EOF_code_point = -1; + + /** + * @constructor + * @param {Uint8Array} bytes Array of bytes that provide the stream. + */ + function ByteInputStream(bytes) { + /** @type {number} */ + var pos = 0; + + /** + * @this {ByteInputStream} + * @return {number} Get the next byte from the stream. + */ + this.get = function() { + return (pos >= bytes.length) ? EOF_byte : Number(bytes[pos]); + }; + + /** @param {number} n Number (positive or negative) by which to + * offset the byte pointer. */ + this.offset = function(n) { + pos += n; + if (pos < 0) + throw Error('Seeking past start of the buffer'); + if (pos > bytes.length) + throw Error('Seeking past EOF'); + }; + + /** + * @param {Array.} test Array of bytes to compare against. + * @return {boolean} True if the start of the stream matches the test + * bytes. + */ + this.match = function(test) { + if (test.length > pos + bytes.length) + return false; + var i; + for (i = 0; i < test.length; i += 1) { + if (Number(bytes[pos + i]) !== test[i]) + return false; + } + return true; + }; + } + + /** + * @constructor + * @param {Array.} bytes The array to write bytes into. + */ + function ByteOutputStream(bytes) { + /** @type {number} */ + var pos = 0; + + /** + * @param {...number} var_args The byte or bytes to emit into the stream. + * @return {number} The last byte emitted. + */ + this.emit = function(var_args) { + /** @type {number} */ + var last = EOF_byte; + var i; + for (i = 0; i < arguments.length; ++i) { + last = Number(arguments[i]); + bytes[pos++] = last; + } + return last; + }; + } + + /** + * @constructor + * @param {string} string The source of code units for the stream. + */ + function CodePointInputStream(string) { + /** + * @param {string} string Input string of UTF-16 code units. + * @return {Array.} Code points. + */ + function stringToCodePoints(string) { + /** @type {Array.} */ + var cps = []; + // Based on http://www.w3.org/TR/WebIDL/#idl-DOMString + var i = 0, n = string.length; + while (i < string.length) { + var c = string.charCodeAt(i); + if (!inRange(c, 0xD800, 0xDFFF)) { + cps.push(c); + } else if (inRange(c, 0xDC00, 0xDFFF)) { + cps.push(0xFFFD); + } else { // (inRange(cu, 0xD800, 0xDBFF)) + if (i === n - 1) { + cps.push(0xFFFD); + } else { + var d = string.charCodeAt(i + 1); + if (inRange(d, 0xDC00, 0xDFFF)) { + var a = c & 0x3FF; + var b = d & 0x3FF; + i += 1; + cps.push(0x10000 + (a << 10) + b); + } else { + cps.push(0xFFFD); + } + } + } + i += 1; + } + return cps; + } + + /** @type {number} */ + var pos = 0; + /** @type {Array.} */ + var cps = stringToCodePoints(string); + + /** @param {number} n The number of bytes (positive or negative) + * to advance the code point pointer by.*/ + this.offset = function(n) { + pos += n; + if (pos < 0) { + throw Error('Seeking past start of the buffer'); + } + if (pos > cps.length) { + throw Error('Seeking past EOF'); + } + }; + + + /** @return {number} Get the next code point from the stream. */ + this.get = function() { + if (pos >= cps.length) { + return EOF_code_point; + } + return cps[pos]; + }; + } + + /** + * @constructor + */ + function CodePointOutputStream() { + /** @type {string} */ + var string = ''; + + /** @return {string} The accumulated string. */ + this.string = function() { + return string; + }; + + /** @param {number} c The code point to encode into the stream. */ + this.emit = function(c) { + if (c <= 0xFFFF) { + string += String.fromCharCode(c); + } else { + c -= 0x10000; + string += String.fromCharCode(0xD800 + ((c >> 10) & 0x3ff)); + string += String.fromCharCode(0xDC00 + (c & 0x3ff)); + } + }; + } + + /** + * @constructor + * @param {string} message Description of the error. + * @return {Error} + */ + function EncodingError(message) { + var that = Error(message); + that.name = 'EncodingError'; + that.code = 0; + return that; + } + EncodingError.prototype = Error.prototype; + + /** + * @param {boolean} fatal If true, decoding errors raise an exception. + * @param {number=} opt_code_point Override the standard fallback code point. + * @return {number} The code point to insert on a decoding error. + */ + function decoderError(fatal, opt_code_point) { + if (fatal) + throw EncodingError('Decoder error'); + return opt_code_point || 0xFFFD; + } + + /** + * @param {number} code_point The code point that could not be encoded. + * @return {number} Always throws, no value is actually returned. + */ + function encoderError(code_point) { + throw EncodingError('The code point ' + code_point + + ' could not be encoded.'); + } + + // TODO: Define @typedef for Encoding: {name:string,labels:Array.} + // https://github.com/google/closure-compiler/issues/247 + + /** + * @param {string} label The encoding label. + * @return {?{name:string,labels:Array.}} + */ + function getEncoding(label) { + label = String(label).trim().toLowerCase(); + if (Object.prototype.hasOwnProperty.call(label_to_encoding, label)) { + return label_to_encoding[label]; + } + return null; + } + + /** @interface */ + function Decoder() {} + Decoder.prototype = { + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + decode: function(byte_pointer) {} + }; + + /** @interface */ + function Encoder() {} + Encoder.prototype = { + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + encode: function(output_byte_stream, code_point_pointer) {} + }; + + /** + * Encodings table: http://encoding.spec.whatwg.org/encodings.json + * @const + * @type {Array.<{ + * heading: string, + * encodings: Array.<{name:string,labels:Array.}> + * }>} + */ + var encodings = [ + { + "encodings": [ + { + "labels": [ + "unicode-1-1-utf-8", + "utf-8", + "utf8" + ], + "name": "utf-8" + } + ], + "heading": "The Encoding" + }, + { + "encodings": [ + { + "labels": [ + "866", + "cp866", + "csibm866", + "ibm866" + ], + "name": "ibm866" + }, + { + "labels": [ + "csisolatin2", + "iso-8859-2", + "iso-ir-101", + "iso8859-2", + "iso88592", + "iso_8859-2", + "iso_8859-2:1987", + "l2", + "latin2" + ], + "name": "iso-8859-2" + }, + { + "labels": [ + "csisolatin3", + "iso-8859-3", + "iso-ir-109", + "iso8859-3", + "iso88593", + "iso_8859-3", + "iso_8859-3:1988", + "l3", + "latin3" + ], + "name": "iso-8859-3" + }, + { + "labels": [ + "csisolatin4", + "iso-8859-4", + "iso-ir-110", + "iso8859-4", + "iso88594", + "iso_8859-4", + "iso_8859-4:1988", + "l4", + "latin4" + ], + "name": "iso-8859-4" + }, + { + "labels": [ + "csisolatincyrillic", + "cyrillic", + "iso-8859-5", + "iso-ir-144", + "iso8859-5", + "iso88595", + "iso_8859-5", + "iso_8859-5:1988" + ], + "name": "iso-8859-5" + }, + { + "labels": [ + "arabic", + "asmo-708", + "csiso88596e", + "csiso88596i", + "csisolatinarabic", + "ecma-114", + "iso-8859-6", + "iso-8859-6-e", + "iso-8859-6-i", + "iso-ir-127", + "iso8859-6", + "iso88596", + "iso_8859-6", + "iso_8859-6:1987" + ], + "name": "iso-8859-6" + }, + { + "labels": [ + "csisolatingreek", + "ecma-118", + "elot_928", + "greek", + "greek8", + "iso-8859-7", + "iso-ir-126", + "iso8859-7", + "iso88597", + "iso_8859-7", + "iso_8859-7:1987", + "sun_eu_greek" + ], + "name": "iso-8859-7" + }, + { + "labels": [ + "csiso88598e", + "csisolatinhebrew", + "hebrew", + "iso-8859-8", + "iso-8859-8-e", + "iso-ir-138", + "iso8859-8", + "iso88598", + "iso_8859-8", + "iso_8859-8:1988", + "visual" + ], + "name": "iso-8859-8" + }, + { + "labels": [ + "csiso88598i", + "iso-8859-8-i", + "logical" + ], + "name": "iso-8859-8-i" + }, + { + "labels": [ + "csisolatin6", + "iso-8859-10", + "iso-ir-157", + "iso8859-10", + "iso885910", + "l6", + "latin6" + ], + "name": "iso-8859-10" + }, + { + "labels": [ + "iso-8859-13", + "iso8859-13", + "iso885913" + ], + "name": "iso-8859-13" + }, + { + "labels": [ + "iso-8859-14", + "iso8859-14", + "iso885914" + ], + "name": "iso-8859-14" + }, + { + "labels": [ + "csisolatin9", + "iso-8859-15", + "iso8859-15", + "iso885915", + "iso_8859-15", + "l9" + ], + "name": "iso-8859-15" + }, + { + "labels": [ + "iso-8859-16" + ], + "name": "iso-8859-16" + }, + { + "labels": [ + "cskoi8r", + "koi", + "koi8", + "koi8-r", + "koi8_r" + ], + "name": "koi8-r" + }, + { + "labels": [ + "koi8-u" + ], + "name": "koi8-u" + }, + { + "labels": [ + "csmacintosh", + "mac", + "macintosh", + "x-mac-roman" + ], + "name": "macintosh" + }, + { + "labels": [ + "dos-874", + "iso-8859-11", + "iso8859-11", + "iso885911", + "tis-620", + "windows-874" + ], + "name": "windows-874" + }, + { + "labels": [ + "cp1250", + "windows-1250", + "x-cp1250" + ], + "name": "windows-1250" + }, + { + "labels": [ + "cp1251", + "windows-1251", + "x-cp1251" + ], + "name": "windows-1251" + }, + { + "labels": [ + "ansi_x3.4-1968", + "ascii", + "cp1252", + "cp819", + "csisolatin1", + "ibm819", + "iso-8859-1", + "iso-ir-100", + "iso8859-1", + "iso88591", + "iso_8859-1", + "iso_8859-1:1987", + "l1", + "latin1", + "us-ascii", + "windows-1252", + "x-cp1252" + ], + "name": "windows-1252" + }, + { + "labels": [ + "cp1253", + "windows-1253", + "x-cp1253" + ], + "name": "windows-1253" + }, + { + "labels": [ + "cp1254", + "csisolatin5", + "iso-8859-9", + "iso-ir-148", + "iso8859-9", + "iso88599", + "iso_8859-9", + "iso_8859-9:1989", + "l5", + "latin5", + "windows-1254", + "x-cp1254" + ], + "name": "windows-1254" + }, + { + "labels": [ + "cp1255", + "windows-1255", + "x-cp1255" + ], + "name": "windows-1255" + }, + { + "labels": [ + "cp1256", + "windows-1256", + "x-cp1256" + ], + "name": "windows-1256" + }, + { + "labels": [ + "cp1257", + "windows-1257", + "x-cp1257" + ], + "name": "windows-1257" + }, + { + "labels": [ + "cp1258", + "windows-1258", + "x-cp1258" + ], + "name": "windows-1258" + }, + { + "labels": [ + "x-mac-cyrillic", + "x-mac-ukrainian" + ], + "name": "x-mac-cyrillic" + } + ], + "heading": "Legacy single-byte encodings" + }, + { + "encodings": [ + { + "labels": [ + "chinese", + "csgb2312", + "csiso58gb231280", + "gb18030", + "gb2312", + "gb_2312", + "gb_2312-80", + "gbk", + "iso-ir-58", + "x-gbk" + ], + "name": "gb18030" + }, + { + "labels": [ + "hz-gb-2312" + ], + "name": "hz-gb-2312" + } + ], + "heading": "Legacy multi-byte Chinese (simplified) encodings" + }, + { + "encodings": [ + { + "labels": [ + "big5", + "big5-hkscs", + "cn-big5", + "csbig5", + "x-x-big5" + ], + "name": "big5" + } + ], + "heading": "Legacy multi-byte Chinese (traditional) encodings" + }, + { + "encodings": [ + { + "labels": [ + "cseucpkdfmtjapanese", + "euc-jp", + "x-euc-jp" + ], + "name": "euc-jp" + }, + { + "labels": [ + "csiso2022jp", + "iso-2022-jp" + ], + "name": "iso-2022-jp" + }, + { + "labels": [ + "csshiftjis", + "ms_kanji", + "shift-jis", + "shift_jis", + "sjis", + "windows-31j", + "x-sjis" + ], + "name": "shift_jis" + } + ], + "heading": "Legacy multi-byte Japanese encodings" + }, + { + "encodings": [ + { + "labels": [ + "cseuckr", + "csksc56011987", + "euc-kr", + "iso-ir-149", + "korean", + "ks_c_5601-1987", + "ks_c_5601-1989", + "ksc5601", + "ksc_5601", + "windows-949" + ], + "name": "euc-kr" + } + ], + "heading": "Legacy multi-byte Korean encodings" + }, + { + "encodings": [ + { + "labels": [ + "csiso2022kr", + "iso-2022-cn", + "iso-2022-cn-ext", + "iso-2022-kr" + ], + "name": "replacement" + }, + { + "labels": [ + "utf-16be" + ], + "name": "utf-16be" + }, + { + "labels": [ + "utf-16", + "utf-16le" + ], + "name": "utf-16le" + }, + { + "labels": [ + "x-user-defined" + ], + "name": "x-user-defined" + } + ], + "heading": "Legacy miscellaneous encodings" + } + ]; + + // Label to encoding registry. + /** @type {Object.}>} */ + var label_to_encoding = {}; + encodings.forEach(function(category) { + category.encodings.forEach(function(encoding) { + encoding.labels.forEach(function(label) { + label_to_encoding[label] = encoding; + }); + }); + }); + + // Registry of of encoder/decoder factories, by encoding name. + /** @type {Object.} */ + var encoders = {}; + /** @type {Object.} */ + var decoders = {}; + + // + // 5. Indexes + // + + /** + * @param {number} pointer The |pointer| to search for. + * @param {Array.|undefined} index The |index| to search within. + * @return {?number} The code point corresponding to |pointer| in |index|, + * or null if |code point| is not in |index|. + */ + function indexCodePointFor(pointer, index) { + if (!index) return null; + return index[pointer] || null; + } + + /** + * @param {number} code_point The |code point| to search for. + * @param {Array.} index The |index| to search within. + * @return {?number} The first pointer corresponding to |code point| in + * |index|, or null if |code point| is not in |index|. + */ + function indexPointerFor(code_point, index) { + var pointer = index.indexOf(code_point); + return pointer === -1 ? null : pointer; + } + + /** + * @param {string} name Name of the index. + * @return {(Array.|Array.>)} + * */ + function index(name) { + if (!('encoding-indexes' in global)) { + throw Error("Indexes missing." + + " Did you forget to include encoding-indexes.js?"); + } + return global['encoding-indexes'][name]; + } + + /** + * @param {number} pointer The |pointer| to search for in the gb18030 index. + * @return {?number} The code point corresponding to |pointer| in |index|, + * or null if |code point| is not in the gb18030 index. + */ + function indexGB18030CodePointFor(pointer) { + if ((pointer > 39419 && pointer < 189000) || (pointer > 1237575)) + return null; + var /** @type {number} */ offset = 0, + /** @type {number} */ code_point_offset = 0, + /** @type {Array.>} */ idx = index('gb18030'); + var i; + for (i = 0; i < idx.length; ++i) { + var entry = idx[i]; + if (entry[0] <= pointer) { + offset = entry[0]; + code_point_offset = entry[1]; + } else { + break; + } + } + return code_point_offset + pointer - offset; + } + + /** + * @param {number} code_point The |code point| to locate in the gb18030 index. + * @return {number} The first pointer corresponding to |code point| in the + * gb18030 index. + */ + function indexGB18030PointerFor(code_point) { + var /** @type {number} */ offset = 0, + /** @type {number} */ pointer_offset = 0, + /** @type {Array.>} */ idx = index('gb18030'); + var i; + for (i = 0; i < idx.length; ++i) { + var entry = idx[i]; + if (entry[1] <= code_point) { + offset = entry[1]; + pointer_offset = entry[0]; + } else { + break; + } + } + return pointer_offset + code_point - offset; + } + + + // + // 7. API + // + + /** @const */ var DEFAULT_ENCODING = 'utf-8'; + + // 7.1 Interface TextDecoder + + /** + * @constructor + * @param {string=} opt_encoding The label of the encoding; + * defaults to 'utf-8'. + * @param {Object=} options + */ + function TextDecoder(opt_encoding, options) { + if (!(this instanceof TextDecoder)) { + return new TextDecoder(opt_encoding, options); + } + opt_encoding = opt_encoding ? String(opt_encoding) : DEFAULT_ENCODING; + options = ToDictionary(options); + /** @private */ + this._encoding = getEncoding(opt_encoding); + if (this._encoding === null || this._encoding.name === 'replacement') + throw TypeError('Unknown encoding: ' + opt_encoding); + + if (!decoders[this._encoding.name]) { + throw Error('Decoder not present.' + + ' Did you forget to include encoding-indexes.js?'); + } + + /** @private @type {boolean} */ + this._streaming = false; + /** @private @type {boolean} */ + this._BOMseen = false; + /** @private @type {?Decoder} */ + this._decoder = null; + /** @private @type {{fatal: boolean}} */ + this._options = {fatal: Boolean(options['fatal'])}; + + if (Object.defineProperty) + Object.defineProperty(this, 'encoding', {value: this._encoding.name}); + else + this.encoding = this._encoding.name; + + return this; + } + + // TODO: Issue if input byte stream is offset by decoder + // TODO: BOM detection will not work if stream header spans multiple calls + // (last N bytes of previous stream may need to be retained?) + TextDecoder.prototype = { + /** + * @param {ArrayBufferView=} opt_view The buffer of bytes to decode. + * @param {Object=} options + * @return {string} The decoded string. + */ + decode: function decode(opt_view, options) { + if (opt_view && !('buffer' in opt_view && 'byteOffset' in opt_view && + 'byteLength' in opt_view)) { + throw TypeError('Expected ArrayBufferView'); + } else if (!opt_view) { + opt_view = new Uint8Array(0); + } + options = ToDictionary(options); + + if (!this._streaming) { + this._decoder = decoders[this._encoding.name](this._options); + this._BOMseen = false; + } + this._streaming = Boolean(options['stream']); + + var bytes = new Uint8Array(opt_view.buffer, + opt_view.byteOffset, + opt_view.byteLength); + var input_stream = new ByteInputStream(bytes); + + var output_stream = new CodePointOutputStream(); + + /** @type {?number} */ + var code_point; + + while (input_stream.get() !== EOF_byte) { + code_point = /** @type {?number} */ (this._decoder.decode(input_stream)); + if (code_point !== null && code_point !== EOF_code_point) + output_stream.emit(code_point); + } + if (!this._streaming) { + do { + code_point = /** @type {?number} */ (this._decoder.decode(input_stream)); + if (code_point !== null && code_point !== EOF_code_point) + output_stream.emit(code_point); + } while (code_point !== EOF_code_point && + input_stream.get() != EOF_byte); + this._decoder = null; + } + + var result = output_stream.string(); + if (!this._BOMseen && result.length) { + this._BOMseen = true; + if (['utf-8', 'utf-16le', 'utf-16be'].indexOf(this.encoding) !== -1 && + result.charCodeAt(0) === 0xFEFF) { + result = result.substring(1); + } + } + + return result; + } + }; + + // 7.2 Interface TextEncoder + + /** + * @constructor + * @param {string=} opt_encoding The label of the encoding; + * defaults to 'utf-8'. + * @param {Object=} options + */ + function TextEncoder(opt_encoding, options) { + if (!(this instanceof TextEncoder)) + return new TextEncoder(opt_encoding, options); + opt_encoding = opt_encoding ? String(opt_encoding) : DEFAULT_ENCODING; + options = ToDictionary(options); + /** @private */ + this._encoding = getEncoding(opt_encoding); + + var allowLegacyEncoding = + Boolean(options['NONSTANDARD_allowLegacyEncoding']); + var isLegacyEncoding = (this._encoding.name !== 'utf-8' && + this._encoding.name !== 'utf-16le' && + this._encoding.name !== 'utf-16be'); + if (this._encoding === null || (isLegacyEncoding && !allowLegacyEncoding)) + throw TypeError('Unknown encoding: ' + opt_encoding); + + if (!encoders[this._encoding.name]) { + throw Error('Encoder not present.' + + ' Did you forget to include encoding-indexes.js?'); + } + + /** @private @type {boolean} */ + this._streaming = false; + /** @private @type {?Encoder} */ + this._encoder = null; + /** @private @type {{fatal: boolean}} */ + this._options = {fatal: Boolean(options['fatal'])}; + + if (Object.defineProperty) + Object.defineProperty(this, 'encoding', {value: this._encoding.name}); + else + this.encoding = this._encoding.name; + + return this; + } + + TextEncoder.prototype = { + /** + * @param {string=} opt_string The string to encode. + * @param {Object=} options + * @return {Uint8Array} Encoded bytes, as a Uint8Array. + */ + encode: function encode(opt_string, options) { + opt_string = opt_string ? String(opt_string) : ''; + options = ToDictionary(options); + // TODO: any options? + if (!this._streaming) + this._encoder = encoders[this._encoding.name](this._options); + this._streaming = Boolean(options['stream']); + + var bytes = []; + var output_stream = new ByteOutputStream(bytes); + var input_stream = new CodePointInputStream(opt_string); + while (input_stream.get() !== EOF_code_point) { + this._encoder.encode(output_stream, input_stream); + } + if (!this._streaming) { + /** @type {number} */ + var last_byte; + do { + last_byte = this._encoder.encode(output_stream, input_stream); + } while (last_byte !== EOF_byte); + this._encoder = null; + } + return new Uint8Array(bytes); + } + }; + + + // + // 8. The encoding + // + + // 8.1 utf-8 + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function UTF8Decoder(options) { + var fatal = options.fatal; + var /** @type {number} */ utf8_code_point = 0, + /** @type {number} */ utf8_bytes_needed = 0, + /** @type {number} */ utf8_bytes_seen = 0, + /** @type {number} */ utf8_lower_boundary = 0; + + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte) { + if (utf8_bytes_needed !== 0) + return decoderError(fatal); + return EOF_code_point; + } + byte_pointer.offset(1); + + if (utf8_bytes_needed === 0) { + if (inRange(bite, 0x00, 0x7F)) + return bite; + if (inRange(bite, 0xC2, 0xDF)) { + utf8_bytes_needed = 1; + utf8_lower_boundary = 0x80; + utf8_code_point = bite - 0xC0; + } else if (inRange(bite, 0xE0, 0xEF)) { + utf8_bytes_needed = 2; + utf8_lower_boundary = 0x800; + utf8_code_point = bite - 0xE0; + } else if (inRange(bite, 0xF0, 0xF4)) { + utf8_bytes_needed = 3; + utf8_lower_boundary = 0x10000; + utf8_code_point = bite - 0xF0; + } else { + return decoderError(fatal); + } + utf8_code_point = utf8_code_point * Math.pow(64, utf8_bytes_needed); + return null; + } + if (!inRange(bite, 0x80, 0xBF)) { + utf8_code_point = 0; + utf8_bytes_needed = 0; + utf8_bytes_seen = 0; + utf8_lower_boundary = 0; + byte_pointer.offset(-1); + return decoderError(fatal); + } + utf8_bytes_seen += 1; + utf8_code_point = utf8_code_point + (bite - 0x80) * + Math.pow(64, utf8_bytes_needed - utf8_bytes_seen); + if (utf8_bytes_seen !== utf8_bytes_needed) + return null; + var code_point = utf8_code_point; + var lower_boundary = utf8_lower_boundary; + utf8_code_point = 0; + utf8_bytes_needed = 0; + utf8_bytes_seen = 0; + utf8_lower_boundary = 0; + if (inRange(code_point, lower_boundary, 0x10FFFF) && + !inRange(code_point, 0xD800, 0xDFFF)) { + return code_point; + } + return decoderError(fatal); + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function UTF8Encoder(options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + /** @type {number} */ + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0xD800, 0xDFFF)) + return encoderError(code_point); + if (inRange(code_point, 0x0000, 0x007f)) + return output_byte_stream.emit(code_point); + var count, offset; + if (inRange(code_point, 0x0080, 0x07FF)) { + count = 1; + offset = 0xC0; + } else if (inRange(code_point, 0x0800, 0xFFFF)) { + count = 2; + offset = 0xE0; + } else if (inRange(code_point, 0x10000, 0x10FFFF)) { + count = 3; + offset = 0xF0; + } + var result = output_byte_stream.emit( + div(code_point, Math.pow(64, count)) + offset); + while (count > 0) { + var temp = div(code_point, Math.pow(64, count - 1)); + result = output_byte_stream.emit(0x80 + (temp % 64)); + count -= 1; + } + return result; + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['utf-8'] = function(options) { + return new UTF8Encoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['utf-8'] = function(options) { + return new UTF8Decoder(options); + }; + + // + // 9. Legacy single-byte encodings + // + + /** + * @constructor + * @implements {Decoder} + * @param {Array.} index The encoding index. + * @param {{fatal: boolean}} options + */ + function SingleByteDecoder(index, options) { + var fatal = options.fatal; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte) + return EOF_code_point; + byte_pointer.offset(1); + if (inRange(bite, 0x00, 0x7F)) + return bite; + var code_point = index[bite - 0x80]; + if (code_point === null) + return decoderError(fatal); + return code_point; + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {Array.} index The encoding index. + * @param {{fatal: boolean}} options + */ + function SingleByteEncoder(index, options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x007F)) + return output_byte_stream.emit(code_point); + var pointer = indexPointerFor(code_point, index); + if (pointer === null) + encoderError(code_point); + return output_byte_stream.emit(pointer + 0x80); + }; + } + + (function() { + if (!('encoding-indexes' in global)) + return; + encodings.forEach(function(category) { + if (category.heading !== 'Legacy single-byte encodings') + return; + category.encodings.forEach(function(encoding) { + var name = encoding.name; + var idx = index(name); + /** @param {{fatal: boolean}} options */ + decoders[name] = function(options) { + return new SingleByteDecoder(idx, options); + }; + /** @param {{fatal: boolean}} options */ + encoders[name] = function(options) { + return new SingleByteEncoder(idx, options); + }; + }); + }); + }()); + + // + // 10. Legacy multi-byte Chinese (simplified) encodings + // + + // 9.1 gb18030 + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function GB18030Decoder(options) { + var fatal = options.fatal; + var /** @type {number} */ gb18030_first = 0x00, + /** @type {number} */ gb18030_second = 0x00, + /** @type {number} */ gb18030_third = 0x00; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte && gb18030_first === 0x00 && + gb18030_second === 0x00 && gb18030_third === 0x00) { + return EOF_code_point; + } + if (bite === EOF_byte && + (gb18030_first !== 0x00 || gb18030_second !== 0x00 || gb18030_third !== 0x00)) { + gb18030_first = 0x00; + gb18030_second = 0x00; + gb18030_third = 0x00; + decoderError(fatal); + } + byte_pointer.offset(1); + var code_point; + if (gb18030_third !== 0x00) { + code_point = null; + if (inRange(bite, 0x30, 0x39)) { + code_point = indexGB18030CodePointFor( + (((gb18030_first - 0x81) * 10 + (gb18030_second - 0x30)) * 126 + + (gb18030_third - 0x81)) * 10 + bite - 0x30); + } + gb18030_first = 0x00; + gb18030_second = 0x00; + gb18030_third = 0x00; + if (code_point === null) { + byte_pointer.offset(-3); + return decoderError(fatal); + } + return code_point; + } + if (gb18030_second !== 0x00) { + if (inRange(bite, 0x81, 0xFE)) { + gb18030_third = bite; + return null; + } + byte_pointer.offset(-2); + gb18030_first = 0x00; + gb18030_second = 0x00; + return decoderError(fatal); + } + if (gb18030_first !== 0x00) { + if (inRange(bite, 0x30, 0x39)) { + gb18030_second = bite; + return null; + } + var lead = gb18030_first; + var pointer = null; + gb18030_first = 0x00; + var offset = bite < 0x7F ? 0x40 : 0x41; + if (inRange(bite, 0x40, 0x7E) || inRange(bite, 0x80, 0xFE)) + pointer = (lead - 0x81) * 190 + (bite - offset); + code_point = pointer === null ? null : + indexCodePointFor(pointer, index('gb18030')); + if (pointer === null) + byte_pointer.offset(-1); + if (code_point === null) + return decoderError(fatal); + return code_point; + } + if (inRange(bite, 0x00, 0x7F)) + return bite; + if (bite === 0x80) + return 0x20AC; + if (inRange(bite, 0x81, 0xFE)) { + gb18030_first = bite; + return null; + } + return decoderError(fatal); + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function GB18030Encoder(options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x007F)) { + return output_byte_stream.emit(code_point); + } + var pointer = indexPointerFor(code_point, index('gb18030')); + if (pointer !== null) { + var lead = div(pointer, 190) + 0x81; + var trail = pointer % 190; + var offset = trail < 0x3F ? 0x40 : 0x41; + return output_byte_stream.emit(lead, trail + offset); + } + pointer = indexGB18030PointerFor(code_point); + var byte1 = div(div(div(pointer, 10), 126), 10); + pointer = pointer - byte1 * 10 * 126 * 10; + var byte2 = div(div(pointer, 10), 126); + pointer = pointer - byte2 * 10 * 126; + var byte3 = div(pointer, 10); + var byte4 = pointer - byte3 * 10; + return output_byte_stream.emit(byte1 + 0x81, + byte2 + 0x30, + byte3 + 0x81, + byte4 + 0x30); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['gb18030'] = function(options) { + return new GB18030Encoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['gb18030'] = function(options) { + return new GB18030Decoder(options); + }; + + // 10.2 hz-gb-2312 + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function HZGB2312Decoder(options) { + var fatal = options.fatal; + var /** @type {boolean} */ hzgb2312 = false, + /** @type {number} */ hzgb2312_lead = 0x00; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte && hzgb2312_lead === 0x00) + return EOF_code_point; + if (bite === EOF_byte && hzgb2312_lead !== 0x00) { + hzgb2312_lead = 0x00; + return decoderError(fatal); + } + byte_pointer.offset(1); + if (hzgb2312_lead === 0x7E) { + hzgb2312_lead = 0x00; + if (bite === 0x7B) { + hzgb2312 = true; + return null; + } + if (bite === 0x7D) { + hzgb2312 = false; + return null; + } + if (bite === 0x7E) + return 0x007E; + if (bite === 0x0A) + return null; + byte_pointer.offset(-1); + return decoderError(fatal); + } + if (hzgb2312_lead !== 0x00) { + var lead = hzgb2312_lead; + hzgb2312_lead = 0x00; + var code_point = null; + if (inRange(bite, 0x21, 0x7E)) { + code_point = indexCodePointFor((lead - 1) * 190 + + (bite + 0x3F), index('gb18030')); + } + if (bite === 0x0A) + hzgb2312 = false; + if (code_point === null) + return decoderError(fatal); + return code_point; + } + if (bite === 0x7E) { + hzgb2312_lead = 0x7E; + return null; + } + if (hzgb2312) { + if (inRange(bite, 0x20, 0x7F)) { + hzgb2312_lead = bite; + return null; + } + if (bite === 0x0A) + hzgb2312 = false; + return decoderError(fatal); + } + if (inRange(bite, 0x00, 0x7F)) + return bite; + return decoderError(fatal); + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function HZGB2312Encoder(options) { + var fatal = options.fatal; + /** @type {boolean} */ + var hzgb2312 = false; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) { + return EOF_byte; + } + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x007F) && hzgb2312) { + code_point_pointer.offset(-1); + hzgb2312 = false; + return output_byte_stream.emit(0x7E, 0x7D); + } + if (code_point === 0x007E) + return output_byte_stream.emit(0x7E, 0x7E); + if (inRange(code_point, 0x0000, 0x007F)) + return output_byte_stream.emit(code_point); + if (!hzgb2312) { + code_point_pointer.offset(-1); + hzgb2312 = true; + return output_byte_stream.emit(0x7E, 0x7B); + } + var pointer = indexPointerFor(code_point, index('gb18030')); + if (pointer === null) + return encoderError(code_point); + var lead = div(pointer, 190) + 1; + var trail = pointer % 190 - 0x3F; + if (!inRange(lead, 0x21, 0x7E) || !inRange(trail, 0x21, 0x7E)) + return encoderError(code_point); + return output_byte_stream.emit(lead, trail); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['hz-gb-2312'] = function(options) { + return new HZGB2312Encoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['hz-gb-2312'] = function(options) { + return new HZGB2312Decoder(options); + }; + + // + // 11. Legacy multi-byte Chinese (traditional) encodings + // + + // 11.1 big5 + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function Big5Decoder(options) { + var fatal = options.fatal; + var /** @type {number} */ big5_lead = 0x00, + /** @type {?number} */ big5_pending = null; + + /** + * @param {ByteInputStream} byte_pointer The byte steram to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + // NOTE: Hack to support emitting two code points + if (big5_pending !== null) { + var pending = big5_pending; + big5_pending = null; + return pending; + } + var bite = byte_pointer.get(); + if (bite === EOF_byte && big5_lead === 0x00) + return EOF_code_point; + if (bite === EOF_byte && big5_lead !== 0x00) { + big5_lead = 0x00; + return decoderError(fatal); + } + byte_pointer.offset(1); + if (big5_lead !== 0x00) { + var lead = big5_lead; + var pointer = null; + big5_lead = 0x00; + var offset = bite < 0x7F ? 0x40 : 0x62; + if (inRange(bite, 0x40, 0x7E) || inRange(bite, 0xA1, 0xFE)) + pointer = (lead - 0x81) * 157 + (bite - offset); + if (pointer === 1133) { + big5_pending = 0x0304; + return 0x00CA; + } + if (pointer === 1135) { + big5_pending = 0x030C; + return 0x00CA; + } + if (pointer === 1164) { + big5_pending = 0x0304; + return 0x00EA; + } + if (pointer === 1166) { + big5_pending = 0x030C; + return 0x00EA; + } + var code_point = (pointer === null) ? null : + indexCodePointFor(pointer, index('big5')); + if (pointer === null) + byte_pointer.offset(-1); + if (code_point === null) + return decoderError(fatal); + return code_point; + } + if (inRange(bite, 0x00, 0x7F)) + return bite; + if (inRange(bite, 0x81, 0xFE)) { + big5_lead = bite; + return null; + } + return decoderError(fatal); + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function Big5Encoder(options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x007F)) + return output_byte_stream.emit(code_point); + var pointer = indexPointerFor(code_point, index('big5')); + if (pointer === null) + return encoderError(code_point); + var lead = div(pointer, 157) + 0x81; + //if (lead < 0xA1) { + // return encoderError(code_point); + //} + var trail = pointer % 157; + var offset = trail < 0x3F ? 0x40 : 0x62; + return output_byte_stream.emit(lead, trail + offset); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['big5'] = function(options) { + return new Big5Encoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['big5'] = function(options) { + return new Big5Decoder(options); + }; + + + // + // 12. Legacy multi-byte Japanese encodings + // + + // 12.1 euc.jp + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function EUCJPDecoder(options) { + var fatal = options.fatal; + var /** @type {number} */ eucjp_first = 0x00, + /** @type {number} */ eucjp_second = 0x00; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte) { + if (eucjp_first === 0x00 && eucjp_second === 0x00) + return EOF_code_point; + eucjp_first = 0x00; + eucjp_second = 0x00; + return decoderError(fatal); + } + byte_pointer.offset(1); + + var lead, code_point; + if (eucjp_second !== 0x00) { + lead = eucjp_second; + eucjp_second = 0x00; + code_point = null; + if (inRange(lead, 0xA1, 0xFE) && inRange(bite, 0xA1, 0xFE)) { + code_point = indexCodePointFor((lead - 0xA1) * 94 + bite - 0xA1, + index('jis0212')); + } + if (!inRange(bite, 0xA1, 0xFE)) + byte_pointer.offset(-1); + if (code_point === null) + return decoderError(fatal); + return code_point; + } + if (eucjp_first === 0x8E && inRange(bite, 0xA1, 0xDF)) { + eucjp_first = 0x00; + return 0xFF61 + bite - 0xA1; + } + if (eucjp_first === 0x8F && inRange(bite, 0xA1, 0xFE)) { + eucjp_first = 0x00; + eucjp_second = bite; + return null; + } + if (eucjp_first !== 0x00) { + lead = eucjp_first; + eucjp_first = 0x00; + code_point = null; + if (inRange(lead, 0xA1, 0xFE) && inRange(bite, 0xA1, 0xFE)) { + code_point = indexCodePointFor((lead - 0xA1) * 94 + bite - 0xA1, + index('jis0208')); + } + if (!inRange(bite, 0xA1, 0xFE)) + byte_pointer.offset(-1); + if (code_point === null) + return decoderError(fatal); + return code_point; + } + if (inRange(bite, 0x00, 0x7F)) + return bite; + if (bite === 0x8E || bite === 0x8F || (inRange(bite, 0xA1, 0xFE))) { + eucjp_first = bite; + return null; + } + return decoderError(fatal); + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function EUCJPEncoder(options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x007F)) + return output_byte_stream.emit(code_point); + if (code_point === 0x00A5) + return output_byte_stream.emit(0x5C); + if (code_point === 0x203E) + return output_byte_stream.emit(0x7E); + if (inRange(code_point, 0xFF61, 0xFF9F)) + return output_byte_stream.emit(0x8E, code_point - 0xFF61 + 0xA1); + + var pointer = indexPointerFor(code_point, index('jis0208')); + if (pointer === null) + return encoderError(code_point); + var lead = div(pointer, 94) + 0xA1; + var trail = pointer % 94 + 0xA1; + return output_byte_stream.emit(lead, trail); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['euc-jp'] = function(options) { + return new EUCJPEncoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['euc-jp'] = function(options) { + return new EUCJPDecoder(options); + }; + + // 12.2 iso-2022-jp + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function ISO2022JPDecoder(options) { + var fatal = options.fatal; + /** @enum */ + var state = { + ASCII: 0, + escape_start: 1, + escape_middle: 2, + escape_final: 3, + lead: 4, + trail: 5, + Katakana: 6 + }; + var /** @type {number} */ iso2022jp_state = state.ASCII, + /** @type {boolean} */ iso2022jp_jis0212 = false, + /** @type {number} */ iso2022jp_lead = 0x00; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite !== EOF_byte) + byte_pointer.offset(1); + switch (iso2022jp_state) { + case state.ASCII: + default: + if (bite === 0x1B) { + iso2022jp_state = state.escape_start; + return null; + } + if (inRange(bite, 0x00, 0x7F)) + return bite; + if (bite === EOF_byte) + return EOF_code_point; + return decoderError(fatal); + + case state.escape_start: + if (bite === 0x24 || bite === 0x28) { + iso2022jp_lead = bite; + iso2022jp_state = state.escape_middle; + return null; + } + if (bite !== EOF_byte) + byte_pointer.offset(-1); + iso2022jp_state = state.ASCII; + return decoderError(fatal); + + case state.escape_middle: + var lead = iso2022jp_lead; + iso2022jp_lead = 0x00; + if (lead === 0x24 && (bite === 0x40 || bite === 0x42)) { + iso2022jp_jis0212 = false; + iso2022jp_state = state.lead; + return null; + } + if (lead === 0x24 && bite === 0x28) { + iso2022jp_state = state.escape_final; + return null; + } + if (lead === 0x28 && (bite === 0x42 || bite === 0x4A)) { + iso2022jp_state = state.ASCII; + return null; + } + if (lead === 0x28 && bite === 0x49) { + iso2022jp_state = state.Katakana; + return null; + } + if (bite === EOF_byte) + byte_pointer.offset(-1); + else + byte_pointer.offset(-2); + iso2022jp_state = state.ASCII; + return decoderError(fatal); + + case state.escape_final: + if (bite === 0x44) { + iso2022jp_jis0212 = true; + iso2022jp_state = state.lead; + return null; + } + if (bite === EOF_byte) + byte_pointer.offset(-2); + else + byte_pointer.offset(-3); + iso2022jp_state = state.ASCII; + return decoderError(fatal); + + case state.lead: + if (bite === 0x0A) { + iso2022jp_state = state.ASCII; + return decoderError(fatal, 0x000A); + } + if (bite === 0x1B) { + iso2022jp_state = state.escape_start; + return null; + } + if (bite === EOF_byte) + return EOF_code_point; + iso2022jp_lead = bite; + iso2022jp_state = state.trail; + return null; + + case state.trail: + iso2022jp_state = state.lead; + if (bite === EOF_byte) + return decoderError(fatal); + var code_point = null; + var pointer = (iso2022jp_lead - 0x21) * 94 + bite - 0x21; + if (inRange(iso2022jp_lead, 0x21, 0x7E) && + inRange(bite, 0x21, 0x7E)) { + code_point = (iso2022jp_jis0212 === false) ? + indexCodePointFor(pointer, index('jis0208')) : + indexCodePointFor(pointer, index('jis0212')); + } + if (code_point === null) + return decoderError(fatal); + return code_point; + + case state.Katakana: + if (bite === 0x1B) { + iso2022jp_state = state.escape_start; + return null; + } + if (inRange(bite, 0x21, 0x5F)) + return 0xFF61 + bite - 0x21; + if (bite === EOF_byte) + return EOF_code_point; + return decoderError(fatal); + } + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function ISO2022JPEncoder(options) { + var fatal = options.fatal; + /** @enum */ + var state = { + ASCII: 0, + lead: 1, + Katakana: 2 + }; + var /** @type {number} */ iso2022jp_state = state.ASCII; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if ((inRange(code_point, 0x0000, 0x007F) || + code_point === 0x00A5 || code_point === 0x203E) && + iso2022jp_state !== state.ASCII) { + code_point_pointer.offset(-1); + iso2022jp_state = state.ASCII; + return output_byte_stream.emit(0x1B, 0x28, 0x42); + } + if (inRange(code_point, 0x0000, 0x007F)) + return output_byte_stream.emit(code_point); + if (code_point === 0x00A5) + return output_byte_stream.emit(0x5C); + if (code_point === 0x203E) + return output_byte_stream.emit(0x7E); + if (inRange(code_point, 0xFF61, 0xFF9F) && + iso2022jp_state !== state.Katakana) { + code_point_pointer.offset(-1); + iso2022jp_state = state.Katakana; + return output_byte_stream.emit(0x1B, 0x28, 0x49); + } + if (inRange(code_point, 0xFF61, 0xFF9F)) + return output_byte_stream.emit(code_point - 0xFF61 - 0x21); + if (iso2022jp_state !== state.lead) { + code_point_pointer.offset(-1); + iso2022jp_state = state.lead; + return output_byte_stream.emit(0x1B, 0x24, 0x42); + } + var pointer = indexPointerFor(code_point, index('jis0208')); + if (pointer === null) + return encoderError(code_point); + var lead = div(pointer, 94) + 0x21; + var trail = pointer % 94 + 0x21; + return output_byte_stream.emit(lead, trail); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['iso-2022-jp'] = function(options) { + return new ISO2022JPEncoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['iso-2022-jp'] = function(options) { + return new ISO2022JPDecoder(options); + }; + + // 12.3 shift_jis + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function ShiftJISDecoder(options) { + var fatal = options.fatal; + var /** @type {number} */ shiftjis_lead = 0x00; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte && shiftjis_lead === 0x00) + return EOF_code_point; + if (bite === EOF_byte && shiftjis_lead !== 0x00) { + shiftjis_lead = 0x00; + return decoderError(fatal); + } + byte_pointer.offset(1); + if (shiftjis_lead !== 0x00) { + var lead = shiftjis_lead; + shiftjis_lead = 0x00; + if (inRange(bite, 0x40, 0x7E) || inRange(bite, 0x80, 0xFC)) { + var offset = (bite < 0x7F) ? 0x40 : 0x41; + var lead_offset = (lead < 0xA0) ? 0x81 : 0xC1; + var code_point = indexCodePointFor((lead - lead_offset) * 188 + + bite - offset, index('jis0208')); + if (code_point === null) + return decoderError(fatal); + return code_point; + } + byte_pointer.offset(-1); + return decoderError(fatal); + } + if (inRange(bite, 0x00, 0x80)) + return bite; + if (inRange(bite, 0xA1, 0xDF)) + return 0xFF61 + bite - 0xA1; + if (inRange(bite, 0x81, 0x9F) || inRange(bite, 0xE0, 0xFC)) { + shiftjis_lead = bite; + return null; + } + return decoderError(fatal); + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function ShiftJISEncoder(options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x0080)) + return output_byte_stream.emit(code_point); + if (code_point === 0x00A5) + return output_byte_stream.emit(0x5C); + if (code_point === 0x203E) + return output_byte_stream.emit(0x7E); + if (inRange(code_point, 0xFF61, 0xFF9F)) + return output_byte_stream.emit(code_point - 0xFF61 + 0xA1); + var pointer = indexPointerFor(code_point, index('jis0208')); + if (pointer === null) + return encoderError(code_point); + var lead = div(pointer, 188); + var lead_offset = lead < 0x1F ? 0x81 : 0xC1; + var trail = pointer % 188; + var offset = trail < 0x3F ? 0x40 : 0x41; + return output_byte_stream.emit(lead + lead_offset, trail + offset); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['shift_jis'] = function(options) { + return new ShiftJISEncoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['shift_jis'] = function(options) { + return new ShiftJISDecoder(options); + }; + + // + // 13. Legacy multi-byte Korean encodings + // + + // 13.1 euc-kr + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function EUCKRDecoder(options) { + var fatal = options.fatal; + var /** @type {number} */ euckr_lead = 0x00; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte && euckr_lead === 0) + return EOF_code_point; + if (bite === EOF_byte && euckr_lead !== 0) { + euckr_lead = 0x00; + return decoderError(fatal); + } + byte_pointer.offset(1); + if (euckr_lead !== 0x00) { + var lead = euckr_lead; + var pointer = null; + euckr_lead = 0x00; + + if (inRange(lead, 0x81, 0xC6)) { + var temp = (26 + 26 + 126) * (lead - 0x81); + if (inRange(bite, 0x41, 0x5A)) + pointer = temp + bite - 0x41; + else if (inRange(bite, 0x61, 0x7A)) + pointer = temp + 26 + bite - 0x61; + else if (inRange(bite, 0x81, 0xFE)) + pointer = temp + 26 + 26 + bite - 0x81; + } + + if (inRange(lead, 0xC7, 0xFD) && inRange(bite, 0xA1, 0xFE)) { + pointer = (26 + 26 + 126) * (0xC7 - 0x81) + (lead - 0xC7) * 94 + + (bite - 0xA1); + } + + var code_point = (pointer === null) ? null : + indexCodePointFor(pointer, index('euc-kr')); + if (pointer === null) + byte_pointer.offset(-1); + if (code_point === null) + return decoderError(fatal); + return code_point; + } + + if (inRange(bite, 0x00, 0x7F)) + return bite; + + if (inRange(bite, 0x81, 0xFD)) { + euckr_lead = bite; + return null; + } + + return decoderError(fatal); + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function EUCKREncoder(options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x007F)) + return output_byte_stream.emit(code_point); + var pointer = indexPointerFor(code_point, index('euc-kr')); + if (pointer === null) + return encoderError(code_point); + var lead, trail; + if (pointer < ((26 + 26 + 126) * (0xC7 - 0x81))) { + lead = div(pointer, (26 + 26 + 126)) + 0x81; + trail = pointer % (26 + 26 + 126); + var offset = trail < 26 ? 0x41 : trail < 26 + 26 ? 0x47 : 0x4D; + return output_byte_stream.emit(lead, trail + offset); + } + pointer = pointer - (26 + 26 + 126) * (0xC7 - 0x81); + lead = div(pointer, 94) + 0xC7; + trail = pointer % 94 + 0xA1; + return output_byte_stream.emit(lead, trail); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['euc-kr'] = function(options) { + return new EUCKREncoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['euc-kr'] = function(options) { + return new EUCKRDecoder(options); + }; + + + // + // 14. Legacy miscellaneous encodings + // + + // 14.1 replacement + + // Not needed - API throws TypeError + + // 14.2 utf-16 + + /** + * @constructor + * @implements {Decoder} + * @param {boolean} utf16_be True if big-endian, false if little-endian. + * @param {{fatal: boolean}} options + */ + function UTF16Decoder(utf16_be, options) { + var fatal = options.fatal; + var /** @type {?number} */ utf16_lead_byte = null, + /** @type {?number} */ utf16_lead_surrogate = null; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte && utf16_lead_byte === null && + utf16_lead_surrogate === null) { + return EOF_code_point; + } + if (bite === EOF_byte && (utf16_lead_byte !== null || + utf16_lead_surrogate !== null)) { + return decoderError(fatal); + } + byte_pointer.offset(1); + if (utf16_lead_byte === null) { + utf16_lead_byte = bite; + return null; + } + var code_point; + if (utf16_be) + code_point = (utf16_lead_byte << 8) + bite; + else + code_point = (bite << 8) + utf16_lead_byte; + utf16_lead_byte = null; + if (utf16_lead_surrogate !== null) { + var lead_surrogate = utf16_lead_surrogate; + utf16_lead_surrogate = null; + if (inRange(code_point, 0xDC00, 0xDFFF)) { + return 0x10000 + (lead_surrogate - 0xD800) * 0x400 + + (code_point - 0xDC00); + } + byte_pointer.offset(-2); + return decoderError(fatal); + } + if (inRange(code_point, 0xD800, 0xDBFF)) { + utf16_lead_surrogate = code_point; + return null; + } + if (inRange(code_point, 0xDC00, 0xDFFF)) + return decoderError(fatal); + return code_point; + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {boolean} utf16_be True if big-endian, false if little-endian. + * @param {{fatal: boolean}} options + */ + function UTF16Encoder(utf16_be, options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + /** + * @param {number} code_unit + * @return {number} last byte emitted + */ + function convert_to_bytes(code_unit) { + var byte1 = code_unit >> 8; + var byte2 = code_unit & 0x00FF; + if (utf16_be) + return output_byte_stream.emit(byte1, byte2); + return output_byte_stream.emit(byte2, byte1); + } + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0xD800, 0xDFFF)) + encoderError(code_point); + if (code_point <= 0xFFFF) + return convert_to_bytes(code_point); + var lead = div((code_point - 0x10000), 0x400) + 0xD800; + var trail = ((code_point - 0x10000) % 0x400) + 0xDC00; + convert_to_bytes(lead); + return convert_to_bytes(trail); + }; + } + + // 14.3 utf-16be + /** @param {{fatal: boolean}} options */ + encoders['utf-16be'] = function(options) { + return new UTF16Encoder(true, options); + }; + /** @param {{fatal: boolean}} options */ + decoders['utf-16be'] = function(options) { + return new UTF16Decoder(true, options); + }; + + // 14.4 utf-16le + /** @param {{fatal: boolean}} options */ + encoders['utf-16le'] = function(options) { + return new UTF16Encoder(false, options); + }; + /** @param {{fatal: boolean}} options */ + decoders['utf-16le'] = function(options) { + return new UTF16Decoder(false, options); + }; + + // 14.5 x-user-defined + + /** + * @constructor + * @implements {Decoder} + * @param {{fatal: boolean}} options + */ + function XUserDefinedDecoder(options) { + var fatal = options.fatal; + /** + * @param {ByteInputStream} byte_pointer The byte stream to decode. + * @return {?number} The next code point decoded, or null if not enough + * data exists in the input stream to decode a complete code point. + */ + this.decode = function(byte_pointer) { + var bite = byte_pointer.get(); + if (bite === EOF_byte) + return EOF_code_point; + byte_pointer.offset(1); + if (inRange(bite, 0x00, 0x7F)) + return bite; + return 0xF780 + bite - 0x80; + }; + } + + /** + * @constructor + * @implements {Encoder} + * @param {{fatal: boolean}} options + */ + function XUserDefinedEncoder(options) { + var fatal = options.fatal; + /** + * @param {ByteOutputStream} output_byte_stream Output byte stream. + * @param {CodePointInputStream} code_point_pointer Input stream. + * @return {number} The last byte emitted. + */ + this.encode = function(output_byte_stream, code_point_pointer) { + var code_point = code_point_pointer.get(); + if (code_point === EOF_code_point) + return EOF_byte; + code_point_pointer.offset(1); + if (inRange(code_point, 0x0000, 0x007F)) + return output_byte_stream.emit(code_point); + if (inRange(code_point, 0xF780, 0xF7FF)) + return output_byte_stream.emit(code_point - 0xF780 + 0x80); + return encoderError(code_point); + }; + } + + /** @param {{fatal: boolean}} options */ + encoders['x-user-defined'] = function(options) { + return new XUserDefinedEncoder(options); + }; + /** @param {{fatal: boolean}} options */ + decoders['x-user-defined'] = function(options) { + return new XUserDefinedDecoder(options); + }; + + // NOTE: currently unused + /** + * @param {string} label The encoding label. + * @param {ByteInputStream} input_stream The byte stream to test. + */ + function detectEncoding(label, input_stream) { + if (input_stream.match([0xFF, 0xFE])) { + input_stream.offset(2); + return 'utf-16le'; + } + if (input_stream.match([0xFE, 0xFF])) { + input_stream.offset(2); + return 'utf-16be'; + } + if (input_stream.match([0xEF, 0xBB, 0xBF])) { + input_stream.offset(3); + return 'utf-8'; + } + return label; + } + + if (!('TextEncoder' in global)) + global['TextEncoder'] = TextEncoder; + if (!('TextDecoder' in global)) + global['TextDecoder'] = TextDecoder; +}(this)); diff --git a/resources/report/js/jed.js b/resources/report/js/jed.js new file mode 100644 index 00000000..dfb21e2c --- /dev/null +++ b/resources/report/js/jed.js @@ -0,0 +1,1015 @@ +/** + * @preserve jed.js v0.5.0beta https://github.com/SlexAxton/Jed + */ +/* +----------- +A gettext compatible i18n library for modern JavaScript Applications + +by Alex Sexton - AlexSexton [at] gmail - @SlexAxton +WTFPL license for use +Dojo CLA for contributions + +Jed offers the entire applicable GNU gettext spec'd set of +functions, but also offers some nicer wrappers around them. +The api for gettext was written for a language with no function +overloading, so Jed allows a little more of that. + +Many thanks to Joshua I. Miller - unrtst@cpan.org - who wrote +gettext.js back in 2008. I was able to vet a lot of my ideas +against his. I also made sure Jed passed against his tests +in order to offer easy upgrades -- jsgettext.berlios.de +*/ +(function (root, undef) { + + // Set up some underscore-style functions, if you already have + // underscore, feel free to delete this section, and use it + // directly, however, the amount of functions used doesn't + // warrant having underscore as a full dependency. + // Underscore 1.3.0 was used to port and is licensed + // under the MIT License by Jeremy Ashkenas. + var ArrayProto = Array.prototype, + ObjProto = Object.prototype, + slice = ArrayProto.slice, + hasOwnProp = ObjProto.hasOwnProperty, + nativeForEach = ArrayProto.forEach, + breaker = {}; + + // We're not using the OOP style _ so we don't need the + // extra level of indirection. This still means that you + // sub out for real `_` though. + var _ = { + forEach : function( obj, iterator, context ) { + var i, l, key; + if ( obj === null ) { + return; + } + + if ( nativeForEach && obj.forEach === nativeForEach ) { + obj.forEach( iterator, context ); + } + else if ( obj.length === +obj.length ) { + for ( i = 0, l = obj.length; i < l; i++ ) { + if ( i in obj && iterator.call( context, obj[i], i, obj ) === breaker ) { + return; + } + } + } + else { + for ( key in obj) { + if ( hasOwnProp.call( obj, key ) ) { + if ( iterator.call (context, obj[key], key, obj ) === breaker ) { + return; + } + } + } + } + }, + extend : function( obj ) { + this.forEach( slice.call( arguments, 1 ), function ( source ) { + for ( var prop in source ) { + obj[prop] = source[prop]; + } + }); + return obj; + } + }; + // END Miniature underscore impl + + // Jed is a constructor function + var Jed = function ( options ) { + // Some minimal defaults + this.defaults = { + "locale_data" : { + "messages" : { + "" : { + "domain" : "messages", + "lang" : "en", + "plural_forms" : "nplurals=2; plural=(n != 1);" + } + // There are no default keys, though + } + }, + // The default domain if one is missing + "domain" : "messages", + // enable debug mode to log untranslated strings to the console + "debug" : false + }; + + // Mix in the sent options with the default options + this.options = _.extend( {}, this.defaults, options ); + this.textdomain( this.options.domain ); + + if ( options.domain && ! this.options.locale_data[ this.options.domain ] ) { + throw new Error('Text domain set to non-existent domain: `' + options.domain + '`'); + } + }; + + // The gettext spec sets this character as the default + // delimiter for context lookups. + // e.g.: context\u0004key + // If your translation company uses something different, + // just change this at any time and it will use that instead. + Jed.context_delimiter = String.fromCharCode( 4 ); + + function getPluralFormFunc ( plural_form_string ) { + return Jed.PF.compile( plural_form_string || "nplurals=2; plural=(n != 1);"); + } + + function Chain( key, i18n ){ + this._key = key; + this._i18n = i18n; + } + + // Create a chainable api for adding args prettily + _.extend( Chain.prototype, { + onDomain : function ( domain ) { + this._domain = domain; + return this; + }, + withContext : function ( context ) { + this._context = context; + return this; + }, + ifPlural : function ( num, pkey ) { + this._val = num; + this._pkey = pkey; + return this; + }, + fetch : function ( sArr ) { + if ( {}.toString.call( sArr ) != '[object Array]' ) { + sArr = [].slice.call(arguments, 0); + } + return ( sArr && sArr.length ? Jed.sprintf : function(x){ return x; } )( + this._i18n.dcnpgettext(this._domain, this._context, this._key, this._pkey, this._val), + sArr + ); + } + }); + + // Add functions to the Jed prototype. + // These will be the functions on the object that's returned + // from creating a `new Jed()` + // These seem redundant, but they gzip pretty well. + _.extend( Jed.prototype, { + // The sexier api start point + translate : function ( key ) { + return new Chain( key, this ); + }, + + textdomain : function ( domain ) { + if ( ! domain ) { + return this._textdomain; + } + this._textdomain = domain; + }, + + gettext : function ( key ) { + return this.dcnpgettext.call( this, undef, undef, key ); + }, + + dgettext : function ( domain, key ) { + return this.dcnpgettext.call( this, domain, undef, key ); + }, + + dcgettext : function ( domain , key /*, category */ ) { + // Ignores the category anyways + return this.dcnpgettext.call( this, domain, undef, key ); + }, + + ngettext : function ( skey, pkey, val ) { + return this.dcnpgettext.call( this, undef, undef, skey, pkey, val ); + }, + + dngettext : function ( domain, skey, pkey, val ) { + return this.dcnpgettext.call( this, domain, undef, skey, pkey, val ); + }, + + dcngettext : function ( domain, skey, pkey, val/*, category */) { + return this.dcnpgettext.call( this, domain, undef, skey, pkey, val ); + }, + + pgettext : function ( context, key ) { + return this.dcnpgettext.call( this, undef, context, key ); + }, + + dpgettext : function ( domain, context, key ) { + return this.dcnpgettext.call( this, domain, context, key ); + }, + + dcpgettext : function ( domain, context, key/*, category */) { + return this.dcnpgettext.call( this, domain, context, key ); + }, + + npgettext : function ( context, skey, pkey, val ) { + return this.dcnpgettext.call( this, undef, context, skey, pkey, val ); + }, + + dnpgettext : function ( domain, context, skey, pkey, val ) { + return this.dcnpgettext.call( this, domain, context, skey, pkey, val ); + }, + + // The most fully qualified gettext function. It has every option. + // Since it has every option, we can use it from every other method. + // This is the bread and butter. + // Technically there should be one more argument in this function for 'Category', + // but since we never use it, we might as well not waste the bytes to define it. + dcnpgettext : function ( domain, context, singular_key, plural_key, val ) { + // Set some defaults + + plural_key = plural_key || singular_key; + + // Use the global domain default if one + // isn't explicitly passed in + domain = domain || this._textdomain; + + // Default the value to the singular case + val = typeof val == 'undefined' ? 1 : val; + + var fallback; + + // Handle special cases + + // No options found + if ( ! this.options ) { + // There's likely something wrong, but we'll return the correct key for english + // We do this by instantiating a brand new Jed instance with the default set + // for everything that could be broken. + fallback = new Jed(); + return fallback.dcnpgettext.call( fallback, undefined, undefined, singular_key, plural_key, val ); + } + + // No translation data provided + if ( ! this.options.locale_data ) { + throw new Error('No locale data provided.'); + } + + if ( ! this.options.locale_data[ domain ] ) { + throw new Error('Domain `' + domain + '` was not found.'); + } + + if ( ! this.options.locale_data[ domain ][ "" ] ) { + throw new Error('No locale meta information provided.'); + } + + // Make sure we have a truthy key. Otherwise we might start looking + // into the empty string key, which is the options for the locale + // data. + if ( ! singular_key ) { + throw new Error('No translation key found.'); + } + + // Handle invalid numbers, but try casting strings for good measure + if ( typeof val != 'number' ) { + val = parseInt( val, 10 ); + + if ( isNaN( val ) ) { + throw new Error('The number that was passed in is not a number.'); + } + } + + var key = context ? context + Jed.context_delimiter + singular_key : singular_key, + locale_data = this.options.locale_data, + dict = locale_data[ domain ], + defaultConf = (locale_data.messages || this.defaults.locale_data.messages)[""], + pluralForms = dict[""].plural_forms || dict[""]["Plural-Forms"] || defaultConf.plural_forms || defaultConf["Plural-Forms"], + val_idx = getPluralFormFunc(pluralForms)(val) + 1, + val_list, + res; + + // Throw an error if a domain isn't found + if ( ! dict ) { + throw new Error('No domain named `' + domain + '` could be found.'); + } + + val_list = dict[ key ]; + + // If there is no match, then revert back to + // english style singular/plural with the keys passed in. + if ( ! val_list || val_idx >= val_list.length ) { + if (this.options.missing_key_callback) { + this.options.missing_key_callback(key, domain); + } + res = [ null, singular_key, plural_key ]; + + // collect untranslated strings + if (this.options.debug===true) { + console.log(res[ getPluralFormFunc(pluralForms)( val ) + 1 ]); + } + return res[ getPluralFormFunc()( val ) + 1 ]; + } + + res = val_list[ val_idx ]; + + // This includes empty strings on purpose + if ( ! res ) { + res = [ null, singular_key, plural_key ]; + return res[ getPluralFormFunc()( val ) + 1 ]; + } + return res; + } + }); + + + // We add in sprintf capabilities for post translation value interolation + // This is not internally used, so you can remove it if you have this + // available somewhere else, or want to use a different system. + + // We _slightly_ modify the normal sprintf behavior to more gracefully handle + // undefined values. + + /** + sprintf() for JavaScript 0.7-beta1 + http://www.diveintojavascript.com/projects/javascript-sprintf + + Copyright (c) Alexandru Marasteanu + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of sprintf() for JavaScript nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL Alexandru Marasteanu BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + var sprintf = (function() { + function get_type(variable) { + return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase(); + } + function str_repeat(input, multiplier) { + for (var output = []; multiplier > 0; output[--multiplier] = input) {/* do nothing */} + return output.join(''); + } + + var str_format = function() { + if (!str_format.cache.hasOwnProperty(arguments[0])) { + str_format.cache[arguments[0]] = str_format.parse(arguments[0]); + } + return str_format.format.call(null, str_format.cache[arguments[0]], arguments); + }; + + str_format.format = function(parse_tree, argv) { + var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length; + for (i = 0; i < tree_length; i++) { + node_type = get_type(parse_tree[i]); + if (node_type === 'string') { + output.push(parse_tree[i]); + } + else if (node_type === 'array') { + match = parse_tree[i]; // convenience purposes only + if (match[2]) { // keyword argument + arg = argv[cursor]; + for (k = 0; k < match[2].length; k++) { + if (!arg.hasOwnProperty(match[2][k])) { + throw(sprintf('[sprintf] property "%s" does not exist', match[2][k])); + } + arg = arg[match[2][k]]; + } + } + else if (match[1]) { // positional argument (explicit) + arg = argv[match[1]]; + } + else { // positional argument (implicit) + arg = argv[cursor++]; + } + + if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) { + throw(sprintf('[sprintf] expecting number but found %s', get_type(arg))); + } + + // Jed EDIT + if ( typeof arg == 'undefined' || arg === null ) { + arg = ''; + } + // Jed EDIT + + switch (match[8]) { + case 'b': arg = arg.toString(2); break; + case 'c': arg = String.fromCharCode(arg); break; + case 'd': arg = parseInt(arg, 10); break; + case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break; + case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break; + case 'o': arg = arg.toString(8); break; + case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break; + case 'u': arg = Math.abs(arg); break; + case 'x': arg = arg.toString(16); break; + case 'X': arg = arg.toString(16).toUpperCase(); break; + } + arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg); + pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' '; + pad_length = match[6] - String(arg).length; + pad = match[6] ? str_repeat(pad_character, pad_length) : ''; + output.push(match[5] ? arg + pad : pad + arg); + } + } + return output.join(''); + }; + + str_format.cache = {}; + + str_format.parse = function(fmt) { + var _fmt = fmt, match = [], parse_tree = [], arg_names = 0; + while (_fmt) { + if ((match = /^[^\x25]+/.exec(_fmt)) !== null) { + parse_tree.push(match[0]); + } + else if ((match = /^\x25{2}/.exec(_fmt)) !== null) { + parse_tree.push('%'); + } + else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) { + if (match[2]) { + arg_names |= 1; + var field_list = [], replacement_field = match[2], field_match = []; + if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') { + if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + } + else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + } + else { + throw('[sprintf] huh?'); + } + } + } + else { + throw('[sprintf] huh?'); + } + match[2] = field_list; + } + else { + arg_names |= 2; + } + if (arg_names === 3) { + throw('[sprintf] mixing positional and named placeholders is not (yet) supported'); + } + parse_tree.push(match); + } + else { + throw('[sprintf] huh?'); + } + _fmt = _fmt.substring(match[0].length); + } + return parse_tree; + }; + + return str_format; + })(); + + var vsprintf = function(fmt, argv) { + argv.unshift(fmt); + return sprintf.apply(null, argv); + }; + + Jed.parse_plural = function ( plural_forms, n ) { + plural_forms = plural_forms.replace(/n/g, n); + return Jed.parse_expression(plural_forms); + }; + + Jed.sprintf = function ( fmt, args ) { + if ( {}.toString.call( args ) == '[object Array]' ) { + return vsprintf( fmt, [].slice.call(args) ); + } + return sprintf.apply(this, [].slice.call(arguments) ); + }; + + Jed.prototype.sprintf = function () { + return Jed.sprintf.apply(this, arguments); + }; + // END sprintf Implementation + + // Start the Plural forms section + // This is a full plural form expression parser. It is used to avoid + // running 'eval' or 'new Function' directly against the plural + // forms. + // + // This can be important if you get translations done through a 3rd + // party vendor. I encourage you to use this instead, however, I + // also will provide a 'precompiler' that you can use at build time + // to output valid/safe function representations of the plural form + // expressions. This means you can build this code out for the most + // part. + Jed.PF = {}; + + Jed.PF.parse = function ( p ) { + var plural_str = Jed.PF.extractPluralExpr( p ); + return Jed.PF.parser.parse.call(Jed.PF.parser, plural_str); + }; + + Jed.PF.compile = function ( p ) { + // Handle trues and falses as 0 and 1 + function imply( val ) { + return (val === true ? 1 : val ? val : 0); + } + + var ast = Jed.PF.parse( p ); + return function ( n ) { + return imply( Jed.PF.interpreter( ast )( n ) ); + }; + }; + + Jed.PF.interpreter = function ( ast ) { + return function ( n ) { + var res; + switch ( ast.type ) { + case 'GROUP': + return Jed.PF.interpreter( ast.expr )( n ); + case 'TERNARY': + if ( Jed.PF.interpreter( ast.expr )( n ) ) { + return Jed.PF.interpreter( ast.truthy )( n ); + } + return Jed.PF.interpreter( ast.falsey )( n ); + case 'OR': + return Jed.PF.interpreter( ast.left )( n ) || Jed.PF.interpreter( ast.right )( n ); + case 'AND': + return Jed.PF.interpreter( ast.left )( n ) && Jed.PF.interpreter( ast.right )( n ); + case 'LT': + return Jed.PF.interpreter( ast.left )( n ) < Jed.PF.interpreter( ast.right )( n ); + case 'GT': + return Jed.PF.interpreter( ast.left )( n ) > Jed.PF.interpreter( ast.right )( n ); + case 'LTE': + return Jed.PF.interpreter( ast.left )( n ) <= Jed.PF.interpreter( ast.right )( n ); + case 'GTE': + return Jed.PF.interpreter( ast.left )( n ) >= Jed.PF.interpreter( ast.right )( n ); + case 'EQ': + return Jed.PF.interpreter( ast.left )( n ) == Jed.PF.interpreter( ast.right )( n ); + case 'NEQ': + return Jed.PF.interpreter( ast.left )( n ) != Jed.PF.interpreter( ast.right )( n ); + case 'MOD': + return Jed.PF.interpreter( ast.left )( n ) % Jed.PF.interpreter( ast.right )( n ); + case 'VAR': + return n; + case 'NUM': + return ast.val; + default: + throw new Error("Invalid Token found."); + } + }; + }; + + Jed.PF.extractPluralExpr = function ( p ) { + // trim first + p = p.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); + + if (! /;\s*$/.test(p)) { + p = p.concat(';'); + } + + var nplurals_re = /nplurals\=(\d+);/, + plural_re = /plural\=(.*);/, + nplurals_matches = p.match( nplurals_re ), + res = {}, + plural_matches; + + // Find the nplurals number + if ( nplurals_matches.length > 1 ) { + res.nplurals = nplurals_matches[1]; + } + else { + throw new Error('nplurals not found in plural_forms string: ' + p ); + } + + // remove that data to get to the formula + p = p.replace( nplurals_re, "" ); + plural_matches = p.match( plural_re ); + + if (!( plural_matches && plural_matches.length > 1 ) ) { + throw new Error('`plural` expression not found: ' + p); + } + return plural_matches[ 1 ]; + }; + + /* Jison generated parser */ + Jed.PF.parser = (function(){ + +var parser = {trace: function trace() { }, +yy: {}, +symbols_: {"error":2,"expressions":3,"e":4,"EOF":5,"?":6,":":7,"||":8,"&&":9,"<":10,"<=":11,">":12,">=":13,"!=":14,"==":15,"%":16,"(":17,")":18,"n":19,"NUMBER":20,"$accept":0,"$end":1}, +terminals_: {2:"error",5:"EOF",6:"?",7:":",8:"||",9:"&&",10:"<",11:"<=",12:">",13:">=",14:"!=",15:"==",16:"%",17:"(",18:")",19:"n",20:"NUMBER"}, +productions_: [0,[3,2],[4,5],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,1],[4,1]], +performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) { + +var $0 = $$.length - 1; +switch (yystate) { +case 1: return { type : 'GROUP', expr: $$[$0-1] }; +break; +case 2:this.$ = { type: 'TERNARY', expr: $$[$0-4], truthy : $$[$0-2], falsey: $$[$0] }; +break; +case 3:this.$ = { type: "OR", left: $$[$0-2], right: $$[$0] }; +break; +case 4:this.$ = { type: "AND", left: $$[$0-2], right: $$[$0] }; +break; +case 5:this.$ = { type: 'LT', left: $$[$0-2], right: $$[$0] }; +break; +case 6:this.$ = { type: 'LTE', left: $$[$0-2], right: $$[$0] }; +break; +case 7:this.$ = { type: 'GT', left: $$[$0-2], right: $$[$0] }; +break; +case 8:this.$ = { type: 'GTE', left: $$[$0-2], right: $$[$0] }; +break; +case 9:this.$ = { type: 'NEQ', left: $$[$0-2], right: $$[$0] }; +break; +case 10:this.$ = { type: 'EQ', left: $$[$0-2], right: $$[$0] }; +break; +case 11:this.$ = { type: 'MOD', left: $$[$0-2], right: $$[$0] }; +break; +case 12:this.$ = { type: 'GROUP', expr: $$[$0-1] }; +break; +case 13:this.$ = { type: 'VAR' }; +break; +case 14:this.$ = { type: 'NUM', val: Number(yytext) }; +break; +} +}, +table: [{3:1,4:2,17:[1,3],19:[1,4],20:[1,5]},{1:[3]},{5:[1,6],6:[1,7],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16]},{4:17,17:[1,3],19:[1,4],20:[1,5]},{5:[2,13],6:[2,13],7:[2,13],8:[2,13],9:[2,13],10:[2,13],11:[2,13],12:[2,13],13:[2,13],14:[2,13],15:[2,13],16:[2,13],18:[2,13]},{5:[2,14],6:[2,14],7:[2,14],8:[2,14],9:[2,14],10:[2,14],11:[2,14],12:[2,14],13:[2,14],14:[2,14],15:[2,14],16:[2,14],18:[2,14]},{1:[2,1]},{4:18,17:[1,3],19:[1,4],20:[1,5]},{4:19,17:[1,3],19:[1,4],20:[1,5]},{4:20,17:[1,3],19:[1,4],20:[1,5]},{4:21,17:[1,3],19:[1,4],20:[1,5]},{4:22,17:[1,3],19:[1,4],20:[1,5]},{4:23,17:[1,3],19:[1,4],20:[1,5]},{4:24,17:[1,3],19:[1,4],20:[1,5]},{4:25,17:[1,3],19:[1,4],20:[1,5]},{4:26,17:[1,3],19:[1,4],20:[1,5]},{4:27,17:[1,3],19:[1,4],20:[1,5]},{6:[1,7],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[1,28]},{6:[1,7],7:[1,29],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16]},{5:[2,3],6:[2,3],7:[2,3],8:[2,3],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,3]},{5:[2,4],6:[2,4],7:[2,4],8:[2,4],9:[2,4],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,4]},{5:[2,5],6:[2,5],7:[2,5],8:[2,5],9:[2,5],10:[2,5],11:[2,5],12:[2,5],13:[2,5],14:[2,5],15:[2,5],16:[1,16],18:[2,5]},{5:[2,6],6:[2,6],7:[2,6],8:[2,6],9:[2,6],10:[2,6],11:[2,6],12:[2,6],13:[2,6],14:[2,6],15:[2,6],16:[1,16],18:[2,6]},{5:[2,7],6:[2,7],7:[2,7],8:[2,7],9:[2,7],10:[2,7],11:[2,7],12:[2,7],13:[2,7],14:[2,7],15:[2,7],16:[1,16],18:[2,7]},{5:[2,8],6:[2,8],7:[2,8],8:[2,8],9:[2,8],10:[2,8],11:[2,8],12:[2,8],13:[2,8],14:[2,8],15:[2,8],16:[1,16],18:[2,8]},{5:[2,9],6:[2,9],7:[2,9],8:[2,9],9:[2,9],10:[2,9],11:[2,9],12:[2,9],13:[2,9],14:[2,9],15:[2,9],16:[1,16],18:[2,9]},{5:[2,10],6:[2,10],7:[2,10],8:[2,10],9:[2,10],10:[2,10],11:[2,10],12:[2,10],13:[2,10],14:[2,10],15:[2,10],16:[1,16],18:[2,10]},{5:[2,11],6:[2,11],7:[2,11],8:[2,11],9:[2,11],10:[2,11],11:[2,11],12:[2,11],13:[2,11],14:[2,11],15:[2,11],16:[2,11],18:[2,11]},{5:[2,12],6:[2,12],7:[2,12],8:[2,12],9:[2,12],10:[2,12],11:[2,12],12:[2,12],13:[2,12],14:[2,12],15:[2,12],16:[2,12],18:[2,12]},{4:30,17:[1,3],19:[1,4],20:[1,5]},{5:[2,2],6:[1,7],7:[2,2],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,2]}], +defaultActions: {6:[2,1]}, +parseError: function parseError(str, hash) { + throw new Error(str); +}, +parse: function parse(input) { + var self = this, + stack = [0], + vstack = [null], // semantic value stack + lstack = [], // location stack + table = this.table, + yytext = '', + yylineno = 0, + yyleng = 0, + recovering = 0, + TERROR = 2, + EOF = 1; + + //this.reductionCount = this.shiftCount = 0; + + this.lexer.setInput(input); + this.lexer.yy = this.yy; + this.yy.lexer = this.lexer; + if (typeof this.lexer.yylloc == 'undefined') + this.lexer.yylloc = {}; + var yyloc = this.lexer.yylloc; + lstack.push(yyloc); + + if (typeof this.yy.parseError === 'function') + this.parseError = this.yy.parseError; + + function popStack (n) { + stack.length = stack.length - 2*n; + vstack.length = vstack.length - n; + lstack.length = lstack.length - n; + } + + function lex() { + var token; + token = self.lexer.lex() || 1; // $end = 1 + // if token isn't its numeric value, convert + if (typeof token !== 'number') { + token = self.symbols_[token] || token; + } + return token; + } + + var symbol, preErrorSymbol, state, action, a, r, yyval={},p,len,newState, expected; + while (true) { + // retreive state number from top of stack + state = stack[stack.length-1]; + + // use default actions if available + if (this.defaultActions[state]) { + action = this.defaultActions[state]; + } else { + if (symbol == null) + symbol = lex(); + // read action for current state and first input + action = table[state] && table[state][symbol]; + } + + // handle parse error + _handle_error: + if (typeof action === 'undefined' || !action.length || !action[0]) { + + if (!recovering) { + // Report error + expected = []; + for (p in table[state]) if (this.terminals_[p] && p > 2) { + expected.push("'"+this.terminals_[p]+"'"); + } + var errStr = ''; + if (this.lexer.showPosition) { + errStr = 'Parse error on line '+(yylineno+1)+":\n"+this.lexer.showPosition()+"\nExpecting "+expected.join(', ') + ", got '" + this.terminals_[symbol]+ "'"; + } else { + errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " + + (symbol == 1 /*EOF*/ ? "end of input" : + ("'"+(this.terminals_[symbol] || symbol)+"'")); + } + this.parseError(errStr, + {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected}); + } + + // just recovered from another error + if (recovering == 3) { + if (symbol == EOF) { + throw new Error(errStr || 'Parsing halted.'); + } + + // discard current lookahead and grab another + yyleng = this.lexer.yyleng; + yytext = this.lexer.yytext; + yylineno = this.lexer.yylineno; + yyloc = this.lexer.yylloc; + symbol = lex(); + } + + // try to recover from error + while (1) { + // check for error recovery rule in this state + if ((TERROR.toString()) in table[state]) { + break; + } + if (state == 0) { + throw new Error(errStr || 'Parsing halted.'); + } + popStack(1); + state = stack[stack.length-1]; + } + + preErrorSymbol = symbol; // save the lookahead token + symbol = TERROR; // insert generic error symbol as new lookahead + state = stack[stack.length-1]; + action = table[state] && table[state][TERROR]; + recovering = 3; // allow 3 real symbols to be shifted before reporting a new error + } + + // this shouldn't happen, unless resolve defaults are off + if (action[0] instanceof Array && action.length > 1) { + throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol); + } + + switch (action[0]) { + + case 1: // shift + //this.shiftCount++; + + stack.push(symbol); + vstack.push(this.lexer.yytext); + lstack.push(this.lexer.yylloc); + stack.push(action[1]); // push state + symbol = null; + if (!preErrorSymbol) { // normal execution/no error + yyleng = this.lexer.yyleng; + yytext = this.lexer.yytext; + yylineno = this.lexer.yylineno; + yyloc = this.lexer.yylloc; + if (recovering > 0) + recovering--; + } else { // error just occurred, resume old lookahead f/ before error + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + + case 2: // reduce + //this.reductionCount++; + + len = this.productions_[action[1]][1]; + + // perform semantic action + yyval.$ = vstack[vstack.length-len]; // default to $$ = $1 + // default location, uses first token for firsts, last for lasts + yyval._$ = { + first_line: lstack[lstack.length-(len||1)].first_line, + last_line: lstack[lstack.length-1].last_line, + first_column: lstack[lstack.length-(len||1)].first_column, + last_column: lstack[lstack.length-1].last_column + }; + r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); + + if (typeof r !== 'undefined') { + return r; + } + + // pop off stack + if (len) { + stack = stack.slice(0,-1*len*2); + vstack = vstack.slice(0, -1*len); + lstack = lstack.slice(0, -1*len); + } + + stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce) + vstack.push(yyval.$); + lstack.push(yyval._$); + // goto new state = table[STATE][NONTERMINAL] + newState = table[stack[stack.length-2]][stack[stack.length-1]]; + stack.push(newState); + break; + + case 3: // accept + return true; + } + + } + + return true; +}};/* Jison generated lexer */ +var lexer = (function(){ + +var lexer = ({EOF:1, +parseError:function parseError(str, hash) { + if (this.yy.parseError) { + this.yy.parseError(str, hash); + } else { + throw new Error(str); + } + }, +setInput:function (input) { + this._input = input; + this._more = this._less = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ''; + this.conditionStack = ['INITIAL']; + this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0}; + return this; + }, +input:function () { + var ch = this._input[0]; + this.yytext+=ch; + this.yyleng++; + this.match+=ch; + this.matched+=ch; + var lines = ch.match(/\n/); + if (lines) this.yylineno++; + this._input = this._input.slice(1); + return ch; + }, +unput:function (ch) { + this._input = ch + this._input; + return this; + }, +more:function () { + this._more = true; + return this; + }, +pastInput:function () { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); + }, +upcomingInput:function () { + var next = this.match; + if (next.length < 20) { + next += this._input.substr(0, 20-next.length); + } + return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, ""); + }, +showPosition:function () { + var pre = this.pastInput(); + var c = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c+"^"; + }, +next:function () { + if (this.done) { + return this.EOF; + } + if (!this._input) this.done = true; + + var token, + match, + col, + lines; + if (!this._more) { + this.yytext = ''; + this.match = ''; + } + var rules = this._currentRules(); + for (var i=0;i < rules.length; i++) { + match = this._input.match(this.rules[rules[i]]); + if (match) { + lines = match[0].match(/\n.*/g); + if (lines) this.yylineno += lines.length; + this.yylloc = {first_line: this.yylloc.last_line, + last_line: this.yylineno+1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length-1].length-1 : this.yylloc.last_column + match[0].length} + this.yytext += match[0]; + this.match += match[0]; + this.matches = match; + this.yyleng = this.yytext.length; + this._more = false; + this._input = this._input.slice(match[0].length); + this.matched += match[0]; + token = this.performAction.call(this, this.yy, this, rules[i],this.conditionStack[this.conditionStack.length-1]); + if (token) return token; + else return; + } + } + if (this._input === "") { + return this.EOF; + } else { + this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), + {text: "", token: null, line: this.yylineno}); + } + }, +lex:function lex() { + var r = this.next(); + if (typeof r !== 'undefined') { + return r; + } else { + return this.lex(); + } + }, +begin:function begin(condition) { + this.conditionStack.push(condition); + }, +popState:function popState() { + return this.conditionStack.pop(); + }, +_currentRules:function _currentRules() { + return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules; + }, +topState:function () { + return this.conditionStack[this.conditionStack.length-2]; + }, +pushState:function begin(condition) { + this.begin(condition); + }}); +lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { + +var YYSTATE=YY_START; +switch($avoiding_name_collisions) { +case 0:/* skip whitespace */ +break; +case 1:return 20 +break; +case 2:return 19 +break; +case 3:return 8 +break; +case 4:return 9 +break; +case 5:return 6 +break; +case 6:return 7 +break; +case 7:return 11 +break; +case 8:return 13 +break; +case 9:return 10 +break; +case 10:return 12 +break; +case 11:return 14 +break; +case 12:return 15 +break; +case 13:return 16 +break; +case 14:return 17 +break; +case 15:return 18 +break; +case 16:return 5 +break; +case 17:return 'INVALID' +break; +} +}; +lexer.rules = [/^\s+/,/^[0-9]+(\.[0-9]+)?\b/,/^n\b/,/^\|\|/,/^&&/,/^\?/,/^:/,/^<=/,/^>=/,/^/,/^!=/,/^==/,/^%/,/^\(/,/^\)/,/^$/,/^./]; +lexer.conditions = {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"inclusive":true}};return lexer;})() +parser.lexer = lexer; +return parser; +})(); +// End parser + + // Handle node, amd, and global systems + if (typeof exports !== 'undefined') { + if (typeof module !== 'undefined' && module.exports) { + exports = module.exports = Jed; + } + exports.Jed = Jed; + } + else { + if (typeof define === 'function' && define.amd) { + define('jed', function() { + return Jed; + }); + } + // Leak a global regardless of module system + root['Jed'] = Jed; + } + +})(this); diff --git a/resources/report/js/jedGettextParser.js b/resources/report/js/jedGettextParser.js new file mode 100644 index 00000000..c46e4c99 --- /dev/null +++ b/resources/report/js/jedGettextParser.js @@ -0,0 +1,210 @@ +/* The text-encoding module is only strictly required for Node.js, and may not + be required in recent browsers, so don't specify it for them. */ +'use strict'; +(function(root, factory) { + if (typeof define === 'function' && define.amd) { + // AMD. Register as an anonymous module. + define([], factory); + } else if (typeof exports === 'object') { + // Node. Does not work with strict CommonJS, but + // only CommonJS-like environments that support module.exports, + // like Node. + module.exports = factory(require('text-encoding')); + } else { + // Browser globals + root.jedGettextParser = factory(); + } +}(this, function(textEncoding) { + /* Return what this module exports. */ + + if (textEncoding) { + var TextDecoder = textEncoding.TextDecoder; + } else { + var TextDecoder = window.TextDecoder; + } + + function Parser() { + this._littleEndian; + this._dataView; + this._encoding; + + this._originalOffset; + this._translationOffset; + } + Parser.prototype._MAGIC = 0x950412de; + + Parser.prototype._getEndianness = function() { + /* MO files can be big or little endian, independent of the source or current platform. Use DataView's optional get*** argument to set the endianness if necessary. */ + if (this._dataView.getUint32(0, true) == this._MAGIC) { + this._littleEndian = true; + } else if (this._dataView.getUint32(0, false) == this._MAGIC){ + this._littleEndian = false; + } else { + throw new Error('Not a gettext binary message catalog file.'); + } + } + + Parser.prototype._readTranslationPair = function(originalOffset, translationOffset) { + var length, position, idBytes, strBytes; + /* Get original byte array, that forms the key. */ + length = this._dataView.getUint32(originalOffset, this._littleEndian); + position = this._dataView.getUint32(originalOffset + 4, this._littleEndian); + try { + idBytes = new Uint8Array(this._dataView.buffer, position, length); + } catch(e) { + throw new Error('The given ArrayBuffer data is corrupt or incomplete.'); + } + + /* Get translation byte array, that forms the value. */ + length = this._dataView.getUint32(translationOffset, this._littleEndian); + position = this._dataView.getUint32(translationOffset + 4, this._littleEndian); + try { + strBytes = new Uint8Array(this._dataView.buffer, position, length); + } catch(e) { + throw new Error('The given ArrayBuffer data is corrupt or incomplete.'); + } + + return { + id: idBytes, + str: strBytes + }; + } + + Parser.prototype._parseHeader = function() { + /* Read translation header. This is stored as a msgstr where the msgid + is '', so it's the first entry in the translation block, since + strings are sorted. Assume that the header is in UTF-8. We only want + the language, encoding and plural forms values, which should all be + ASCII anyway. + */ + var msgBytes = this._readTranslationPair(this._originalOffset, this._translationOffset); + + var language, pluralForms; + if (msgBytes.id.byteLength == 0) { + var decoder = new TextDecoder(); + var str = decoder.decode(msgBytes.str); + + var headers = {}; + str.split("\n").forEach(function(line){ + /* Header format is like HTTP headers. */ + var parts = line.split(':'); + var key = parts.shift().trim(); + var value = parts.join(':').trim(); + headers[key] = value; + }); + + /* Get encoding if not given. */ + if (!this._encoding) { + var pos = headers['Content-Type'].indexOf('charset='); + + if (pos != -1 && pos + 8 < headers['Content-Type'].length) { + /* TextDecoder expects a lowercased encoding name. */ + this._encoding = headers['Content-Type'].substring(pos + 8).toLowerCase(); + } + if (!this._encoding) { + this._encoding = 'utf-8'; + } + } + + /* Get language from header. */ + language = headers['Language']; + + /* Get plural forms from header. */ + pluralForms = headers['Plural-Forms']; + } + + return { + '': { + 'domain': '', + 'lang': language, + 'plural_forms': pluralForms, + } + } + } + + Parser.prototype._splitPlurals = function(msgid, msgstr) { + /* Need to handle plurals. Don't need to handle contexts, because Jed + expects the context-msgid strings to be its keys. However, plural + translations must be split into an array of strings. Jed only wants + the first part of a plural as its key. */ + return { + id: msgid.split('\u0000')[0], + str: msgstr.split('\u0000') + } + } + + Parser.prototype.parse = function(buffer, encoding) { + + /* A mo file can be empty apart from its magic, revision, strings count, + offsets and hash table size, but fields for these must all exist, so + verify the file is large enough. */ + if (buffer.byteLength < 28) { + throw new Error('The given ArrayBuffer is too small to hold a valid .mo file.'); + } + + this._dataView = new DataView(buffer); + this._encoding = encoding; + + this._getEndianness(); + + /* Get size and offsets. Skip the revision and hash table, they're + unnecessary. */ + var stringsCount = this._dataView.getUint32(8, this._littleEndian); + this._originalOffset = this._dataView.getUint32(12, this._littleEndian); + this._translationOffset = this._dataView.getUint32(16, this._littleEndian); + + /* Parse header for info, and use it to create the Jed locale_data + object 'header'. */ + var jedLocaleData = this._parseHeader(); + + /* Create a TextDecoder for encoding conversion. */ + try { + var decoder = new TextDecoder(this._encoding); + } catch(e) { + throw new Error("The encoding label provided ('" + this._encoding + "') is invalid."); + } + + /* Now get translations. */ + var originalOffset = this._originalOffset + 8; + var translationOffset = this._translationOffset + 8; + for (var i = 1; i < stringsCount; ++i) { + var msgBytes = this._readTranslationPair(originalOffset, translationOffset); + var msg = this._splitPlurals( decoder.decode(msgBytes.id), decoder.decode(msgBytes.str) ); + + jedLocaleData[msg.id] = [ null ].concat(msg.str); + + originalOffset += 8; + translationOffset += 8; + } + + return jedLocaleData; + } + + return { + + mo: { + parse: function(buffer, options) { + + /* Leave the encoding undefined if no options are given. */ + options = options || { domain: 'messages' }; + options.domain = options.domain || 'messages'; + + if (buffer && buffer.byteLength == 0) { + throw new Error('Given ArrayBuffer is empty.'); + } + + if (!buffer || Object.prototype.toString.call(buffer) != '[object ArrayBuffer]') { + throw new Error('First argument must be an ArrayBuffer.'); + } + + var parser = new Parser(); + var messages = parser.parse(buffer, options.encoding); + + messages[''].domain = options.domain; + var locale_data = {}; + locale_data[options.domain] = messages; + return locale_data; + } + } + }; +})); \ No newline at end of file diff --git a/resources/report/js/l10n.js b/resources/report/js/l10n.js new file mode 100644 index 00000000..55b631aa --- /dev/null +++ b/resources/report/js/l10n.js @@ -0,0 +1,50 @@ +'use strict'; + +(function (root, factory) { + if (typeof define === 'function' && define.amd) { + // AMD. Register as an anonymous module. + define(['jed', 'jedGettextParser'], factory); + } else { + // Browser globals + root.amdWeb = factory(root.jed, root.jedGettextParser); + } +}(this, function (jed, jedGettextParser) { + //use b in some fashion. + + // Just return a value to define the module export. + // This example returns an object, but the module + // can return a function as the exported value. + return { + + loadLocaleData: function(locale) { + + var url = 'loot://l10n/' + locale + '/LC_MESSAGES/loot.mo'; + + return new Promise(function(resolve, reject){ + var xhr = new XMLHttpRequest(); + xhr.open('GET', url); + xhr.responseType = 'arraybuffer'; + xhr.addEventListener('readystatechange', function(evt){ + if (evt.target.readyState == 4) { + /* Status is 0 for local file URL loading. */ + if (evt.target.status >= 200 && evt.target.status < 400) { + resolve(jedGettextParser.mo.parse(evt.target.response)); + } else { + reject(new Error('XHR Error')); + } + } + }, false); + xhr.send(); + }); + }, + + applyLocale: function(locale) { + this.loadLocaleData(locale).then(function(result){ + console.log(result); + }); + } + + }; +})); + + diff --git a/resources/report/js/script.js b/resources/report/js/script.js index fbe98dc7..bff5786e 100644 --- a/resources/report/js/script.js +++ b/resources/report/js/script.js @@ -23,6 +23,7 @@ */ 'use strict'; var marked; +var l10n; var loot = { hasFocus: true, installedGames: [], @@ -1341,6 +1342,7 @@ function initVars() { try { loot.settings = JSON.parse(results[2]); applySavedFilters(); + l10n.applyLocale(loot.settings.language); } catch (e) { console.log(e); console.log('getSettings response: ' + results[2]); @@ -1441,8 +1443,9 @@ function onFocus(evt) { require.config({ baseUrl: "js", }); -require(['marked', 'order!custom', 'order!plugin'], function(response) { - marked = response; +require(['marked', 'l10n', 'order!custom', 'order!plugin'], function(markedResponse, l10nResponse) { + marked = markedResponse; + l10n = l10nResponse; /* Make sure settings are what I want. */ marked.setOptions({ gfm: true, diff --git a/resources/report/report.html b/resources/report/report.html index 267e6249..46ffcb51 100644 --- a/resources/report/report.html +++ b/resources/report/report.html @@ -564,5 +564,6 @@ along with LOOT. If not, see <http://www.gnu.org/licenses/>.

See LOOT's documentation, accessed through the Help menu, for further details.

+ \ No newline at end of file