"use strict";
|
var Buffer = require("safer-buffer").Buffer;
|
|
// Export Node.js internal encodings.
|
|
module.exports = {
|
// Encodings
|
utf8: { type: "_internal", bomAware: true},
|
cesu8: { type: "_internal", bomAware: true},
|
unicode11utf8: "utf8",
|
|
ucs2: { type: "_internal", bomAware: true},
|
utf16le: "ucs2",
|
|
binary: { type: "_internal" },
|
base64: { type: "_internal" },
|
hex: { type: "_internal" },
|
|
// Codec.
|
_internal: InternalCodec,
|
};
|
|
//------------------------------------------------------------------------------
|
|
function InternalCodec(codecOptions, iconv) {
|
this.enc = codecOptions.encodingName;
|
this.bomAware = codecOptions.bomAware;
|
|
if (this.enc === "base64")
|
this.encoder = InternalEncoderBase64;
|
else if (this.enc === "cesu8") {
|
this.enc = "utf8"; // Use utf8 for decoding.
|
this.encoder = InternalEncoderCesu8;
|
|
// Add decoder for versions of Node not supporting CESU-8
|
if (Buffer.from('eda0bdedb2a9', 'hex').toString() !== '💩') {
|
this.decoder = InternalDecoderCesu8;
|
this.defaultCharUnicode = iconv.defaultCharUnicode;
|
}
|
}
|
}
|
|
InternalCodec.prototype.encoder = InternalEncoder;
|
InternalCodec.prototype.decoder = InternalDecoder;
|
|
//------------------------------------------------------------------------------
|
|
// We use node.js internal decoder. Its signature is the same as ours.
|
var StringDecoder = require('string_decoder').StringDecoder;
|
|
if (!StringDecoder.prototype.end) // Node v0.8 doesn't have this method.
|
StringDecoder.prototype.end = function() {};
|
|
|
function InternalDecoder(options, codec) {
|
StringDecoder.call(this, codec.enc);
|
}
|
|
InternalDecoder.prototype = StringDecoder.prototype;
|
|
|
//------------------------------------------------------------------------------
|
// Encoder is mostly trivial
|
|
function InternalEncoder(options, codec) {
|
this.enc = codec.enc;
|
}
|
|
InternalEncoder.prototype.write = function(str) {
|
return Buffer.from(str, this.enc);
|
}
|
|
InternalEncoder.prototype.end = function() {
|
}
|
|
|
//------------------------------------------------------------------------------
|
// Except base64 encoder, which must keep its state.
|
|
function InternalEncoderBase64(options, codec) {
|
this.prevStr = '';
|
}
|
|
InternalEncoderBase64.prototype.write = function(str) {
|
str = this.prevStr + str;
|
var completeQuads = str.length - (str.length % 4);
|
this.prevStr = str.slice(completeQuads);
|
str = str.slice(0, completeQuads);
|
|
return Buffer.from(str, "base64");
|
}
|
|
InternalEncoderBase64.prototype.end = function() {
|
return Buffer.from(this.prevStr, "base64");
|
}
|
|
|
//------------------------------------------------------------------------------
|
// CESU-8 encoder is also special.
|
|
function InternalEncoderCesu8(options, codec) {
|
}
|
|
InternalEncoderCesu8.prototype.write = function(str) {
|
var buf = Buffer.alloc(str.length * 3), bufIdx = 0;
|
for (var i = 0; i < str.length; i++) {
|
var charCode = str.charCodeAt(i);
|
// Naive implementation, but it works because CESU-8 is especially easy
|
// to convert from UTF-16 (which all JS strings are encoded in).
|
if (charCode < 0x80)
|
buf[bufIdx++] = charCode;
|
else if (charCode < 0x800) {
|
buf[bufIdx++] = 0xC0 + (charCode >>> 6);
|
buf[bufIdx++] = 0x80 + (charCode & 0x3f);
|
}
|
else { // charCode will always be < 0x10000 in javascript.
|
buf[bufIdx++] = 0xE0 + (charCode >>> 12);
|
buf[bufIdx++] = 0x80 + ((charCode >>> 6) & 0x3f);
|
buf[bufIdx++] = 0x80 + (charCode & 0x3f);
|
}
|
}
|
return buf.slice(0, bufIdx);
|
}
|
|
InternalEncoderCesu8.prototype.end = function() {
|
}
|
|
//------------------------------------------------------------------------------
|
// CESU-8 decoder is not implemented in Node v4.0+
|
|
function InternalDecoderCesu8(options, codec) {
|
this.acc = 0;
|
this.contBytes = 0;
|
this.accBytes = 0;
|
this.defaultCharUnicode = codec.defaultCharUnicode;
|
}
|
|
InternalDecoderCesu8.prototype.write = function(buf) {
|
var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes,
|
res = '';
|
for (var i = 0; i < buf.length; i++) {
|
var curByte = buf[i];
|
if ((curByte & 0xC0) !== 0x80) { // Leading byte
|
if (contBytes > 0) { // Previous code is invalid
|
res += this.defaultCharUnicode;
|
contBytes = 0;
|
}
|
|
if (curByte < 0x80) { // Single-byte code
|
res += String.fromCharCode(curByte);
|
} else if (curByte < 0xE0) { // Two-byte code
|
acc = curByte & 0x1F;
|
contBytes = 1; accBytes = 1;
|
} else if (curByte < 0xF0) { // Three-byte code
|
acc = curByte & 0x0F;
|
contBytes = 2; accBytes = 1;
|
} else { // Four or more are not supported for CESU-8.
|
res += this.defaultCharUnicode;
|
}
|
} else { // Continuation byte
|
if (contBytes > 0) { // We're waiting for it.
|
acc = (acc << 6) | (curByte & 0x3f);
|
contBytes--; accBytes++;
|
if (contBytes === 0) {
|
// Check for overlong encoding, but support Modified UTF-8 (encoding NULL as C0 80)
|
if (accBytes === 2 && acc < 0x80 && acc > 0)
|
res += this.defaultCharUnicode;
|
else if (accBytes === 3 && acc < 0x800)
|
res += this.defaultCharUnicode;
|
else
|
// Actually add character.
|
res += String.fromCharCode(acc);
|
}
|
} else { // Unexpected continuation byte
|
res += this.defaultCharUnicode;
|
}
|
}
|
}
|
this.acc = acc; this.contBytes = contBytes; this.accBytes = accBytes;
|
return res;
|
}
|
|
InternalDecoderCesu8.prototype.end = function() {
|
var res = 0;
|
if (this.contBytes > 0)
|
res += this.defaultCharUnicode;
|
return res;
|
}
|
