twitst4tz

internal.js (6115B)

---

 "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;
 }