extend-node.js (8701B)
1 "use strict"; 2 var Buffer = require("buffer").Buffer; 3 // Note: not polyfilled with safer-buffer on a purpose, as overrides Buffer 4 5 // == Extend Node primitives to use iconv-lite ================================= 6 7 module.exports = function (iconv) { 8 var original = undefined; // Place to keep original methods. 9 10 // Node authors rewrote Buffer internals to make it compatible with 11 // Uint8Array and we cannot patch key functions since then. 12 // Note: this does use older Buffer API on a purpose 13 iconv.supportsNodeEncodingsExtension = !(Buffer.from || new Buffer(0) instanceof Uint8Array); 14 15 iconv.extendNodeEncodings = function extendNodeEncodings() { 16 if (original) return; 17 original = {}; 18 19 if (!iconv.supportsNodeEncodingsExtension) { 20 console.error("ACTION NEEDED: require('iconv-lite').extendNodeEncodings() is not supported in your version of Node"); 21 console.error("See more info at https://github.com/ashtuchkin/iconv-lite/wiki/Node-v4-compatibility"); 22 return; 23 } 24 25 var nodeNativeEncodings = { 26 'hex': true, 'utf8': true, 'utf-8': true, 'ascii': true, 'binary': true, 27 'base64': true, 'ucs2': true, 'ucs-2': true, 'utf16le': true, 'utf-16le': true, 28 }; 29 30 Buffer.isNativeEncoding = function(enc) { 31 return enc && nodeNativeEncodings[enc.toLowerCase()]; 32 } 33 34 // -- SlowBuffer ----------------------------------------------------------- 35 var SlowBuffer = require('buffer').SlowBuffer; 36 37 original.SlowBufferToString = SlowBuffer.prototype.toString; 38 SlowBuffer.prototype.toString = function(encoding, start, end) { 39 encoding = String(encoding || 'utf8').toLowerCase(); 40 41 // Use native conversion when possible 42 if (Buffer.isNativeEncoding(encoding)) 43 return original.SlowBufferToString.call(this, encoding, start, end); 44 45 // Otherwise, use our decoding method. 46 if (typeof start == 'undefined') start = 0; 47 if (typeof end == 'undefined') end = this.length; 48 return iconv.decode(this.slice(start, end), encoding); 49 } 50 51 original.SlowBufferWrite = SlowBuffer.prototype.write; 52 SlowBuffer.prototype.write = function(string, offset, length, encoding) { 53 // Support both (string, offset, length, encoding) 54 // and the legacy (string, encoding, offset, length) 55 if (isFinite(offset)) { 56 if (!isFinite(length)) { 57 encoding = length; 58 length = undefined; 59 } 60 } else { // legacy 61 var swap = encoding; 62 encoding = offset; 63 offset = length; 64 length = swap; 65 } 66 67 offset = +offset || 0; 68 var remaining = this.length - offset; 69 if (!length) { 70 length = remaining; 71 } else { 72 length = +length; 73 if (length > remaining) { 74 length = remaining; 75 } 76 } 77 encoding = String(encoding || 'utf8').toLowerCase(); 78 79 // Use native conversion when possible 80 if (Buffer.isNativeEncoding(encoding)) 81 return original.SlowBufferWrite.call(this, string, offset, length, encoding); 82 83 if (string.length > 0 && (length < 0 || offset < 0)) 84 throw new RangeError('attempt to write beyond buffer bounds'); 85 86 // Otherwise, use our encoding method. 87 var buf = iconv.encode(string, encoding); 88 if (buf.length < length) length = buf.length; 89 buf.copy(this, offset, 0, length); 90 return length; 91 } 92 93 // -- Buffer --------------------------------------------------------------- 94 95 original.BufferIsEncoding = Buffer.isEncoding; 96 Buffer.isEncoding = function(encoding) { 97 return Buffer.isNativeEncoding(encoding) || iconv.encodingExists(encoding); 98 } 99 100 original.BufferByteLength = Buffer.byteLength; 101 Buffer.byteLength = SlowBuffer.byteLength = function(str, encoding) { 102 encoding = String(encoding || 'utf8').toLowerCase(); 103 104 // Use native conversion when possible 105 if (Buffer.isNativeEncoding(encoding)) 106 return original.BufferByteLength.call(this, str, encoding); 107 108 // Slow, I know, but we don't have a better way yet. 109 return iconv.encode(str, encoding).length; 110 } 111 112 original.BufferToString = Buffer.prototype.toString; 113 Buffer.prototype.toString = function(encoding, start, end) { 114 encoding = String(encoding || 'utf8').toLowerCase(); 115 116 // Use native conversion when possible 117 if (Buffer.isNativeEncoding(encoding)) 118 return original.BufferToString.call(this, encoding, start, end); 119 120 // Otherwise, use our decoding method. 121 if (typeof start == 'undefined') start = 0; 122 if (typeof end == 'undefined') end = this.length; 123 return iconv.decode(this.slice(start, end), encoding); 124 } 125 126 original.BufferWrite = Buffer.prototype.write; 127 Buffer.prototype.write = function(string, offset, length, encoding) { 128 var _offset = offset, _length = length, _encoding = encoding; 129 // Support both (string, offset, length, encoding) 130 // and the legacy (string, encoding, offset, length) 131 if (isFinite(offset)) { 132 if (!isFinite(length)) { 133 encoding = length; 134 length = undefined; 135 } 136 } else { // legacy 137 var swap = encoding; 138 encoding = offset; 139 offset = length; 140 length = swap; 141 } 142 143 encoding = String(encoding || 'utf8').toLowerCase(); 144 145 // Use native conversion when possible 146 if (Buffer.isNativeEncoding(encoding)) 147 return original.BufferWrite.call(this, string, _offset, _length, _encoding); 148 149 offset = +offset || 0; 150 var remaining = this.length - offset; 151 if (!length) { 152 length = remaining; 153 } else { 154 length = +length; 155 if (length > remaining) { 156 length = remaining; 157 } 158 } 159 160 if (string.length > 0 && (length < 0 || offset < 0)) 161 throw new RangeError('attempt to write beyond buffer bounds'); 162 163 // Otherwise, use our encoding method. 164 var buf = iconv.encode(string, encoding); 165 if (buf.length < length) length = buf.length; 166 buf.copy(this, offset, 0, length); 167 return length; 168 169 // TODO: Set _charsWritten. 170 } 171 172 173 // -- Readable ------------------------------------------------------------- 174 if (iconv.supportsStreams) { 175 var Readable = require('stream').Readable; 176 177 original.ReadableSetEncoding = Readable.prototype.setEncoding; 178 Readable.prototype.setEncoding = function setEncoding(enc, options) { 179 // Use our own decoder, it has the same interface. 180 // We cannot use original function as it doesn't handle BOM-s. 181 this._readableState.decoder = iconv.getDecoder(enc, options); 182 this._readableState.encoding = enc; 183 } 184 185 Readable.prototype.collect = iconv._collect; 186 } 187 } 188 189 // Remove iconv-lite Node primitive extensions. 190 iconv.undoExtendNodeEncodings = function undoExtendNodeEncodings() { 191 if (!iconv.supportsNodeEncodingsExtension) 192 return; 193 if (!original) 194 throw new Error("require('iconv-lite').undoExtendNodeEncodings(): Nothing to undo; extendNodeEncodings() is not called.") 195 196 delete Buffer.isNativeEncoding; 197 198 var SlowBuffer = require('buffer').SlowBuffer; 199 200 SlowBuffer.prototype.toString = original.SlowBufferToString; 201 SlowBuffer.prototype.write = original.SlowBufferWrite; 202 203 Buffer.isEncoding = original.BufferIsEncoding; 204 Buffer.byteLength = original.BufferByteLength; 205 Buffer.prototype.toString = original.BufferToString; 206 Buffer.prototype.write = original.BufferWrite; 207 208 if (iconv.supportsStreams) { 209 var Readable = require('stream').Readable; 210 211 Readable.prototype.setEncoding = original.ReadableSetEncoding; 212 delete Readable.prototype.collect; 213 } 214 215 original = undefined; 216 } 217 }