--- /dev/null
+"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;
+}
projects / dotfiles / .git / blobdiff