diff options
Diffstat (limited to 'deps/npm/node_modules/npm-profile/node_modules/make-fetch-happen/node_modules/socks-proxy-agent/node_modules/socks/node_modules/smart-buffer/build/smartbuffer.js')
| -rw-r--r-- | deps/npm/node_modules/npm-profile/node_modules/make-fetch-happen/node_modules/socks-proxy-agent/node_modules/socks/node_modules/smart-buffer/build/smartbuffer.js | 726 |
1 files changed, 726 insertions, 0 deletions
diff --git a/deps/npm/node_modules/npm-profile/node_modules/make-fetch-happen/node_modules/socks-proxy-agent/node_modules/socks/node_modules/smart-buffer/build/smartbuffer.js b/deps/npm/node_modules/npm-profile/node_modules/make-fetch-happen/node_modules/socks-proxy-agent/node_modules/socks/node_modules/smart-buffer/build/smartbuffer.js new file mode 100644 index 0000000000..ef53b9fd4d --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/make-fetch-happen/node_modules/socks-proxy-agent/node_modules/socks/node_modules/smart-buffer/build/smartbuffer.js @@ -0,0 +1,726 @@ +"use strict"; +// The default Buffer size if one is not provided. +const DEFAULT_SMARTBUFFER_SIZE = 4096; +// The default string encoding to use for reading/writing strings. +const DEFAULT_SMARTBUFFER_ENCODING = 'utf8'; +class SmartBuffer { + /** + * Creates a new SmartBuffer instance. + * + * @param arg1 { Number | BufferEncoding | Buffer | SmartBufferOptions } + * @param arg2 { BufferEncoding } + */ + constructor(arg1, arg2) { + this.length = 0; + this.encoding = DEFAULT_SMARTBUFFER_ENCODING; + this.writeOffset = 0; + this.readOffset = 0; + // Initial buffer size provided + if (typeof arg1 === 'number') { + if (Number.isFinite(arg1) && Number.isInteger(arg1) && arg1 > 0) { + this.buff = Buffer.allocUnsafe(arg1); + } + else { + throw new Error('Invalid size provided. Size must be a valid integer greater than zero.'); + } + } + else if (typeof arg1 === 'string') { + if (Buffer.isEncoding(arg1)) { + this.buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); + this.encoding = arg1; + } + else { + throw new Error('Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.'); + } + } + else if (arg1 instanceof Buffer) { + this.buff = arg1; + this.length = arg1.length; + } + else if (SmartBuffer.isSmartBufferOptions(arg1)) { + // Checks for encoding + if (arg1.encoding) { + if (Buffer.isEncoding(arg1.encoding)) { + this.encoding = arg1.encoding; + } + else { + throw new Error('Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.'); + } + } + // Checks for initial size length + if (arg1.size) { + if (Number.isFinite(arg1.size) && Number.isInteger(arg1.size) && arg1.size > 0) { + this.buff = Buffer.allocUnsafe(arg1.size); + } + else { + throw new Error('Invalid size provided. Size must be a valid integer greater than zero.'); + } + } + else if (arg1.buff) { + if (arg1.buff instanceof Buffer) { + this.buff = arg1.buff; + this.length = arg1.buff.length; + } + else { + throw new Error('Invalid buffer provided in SmartBufferOptions.'); + } + } + else { + this.buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); + } + } + else if (typeof arg1 === 'object') { + throw new Error('Invalid object supplied to SmartBuffer constructor.'); + } + else { + this.buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); + } + // Check for encoding (Buffer, Encoding) constructor. + if (typeof arg2 === 'string') { + if (Buffer.isEncoding(arg2)) { + this.encoding = arg2; + } + else { + throw new Error('Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.'); + } + } + } + /** + * Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding. + * + * @param size { Number } The size of the internal Buffer. + * @param encoding { String } The BufferEncoding to use for strings. + * + * @return { SmartBuffer } + */ + static fromSize(size, encoding) { + return new this({ + size: size, + encoding: encoding + }); + } + /** + * Creates a new SmartBuffer instance with the provided Buffer and optional encoding. + * + * @param buffer { Buffer } The Buffer to use as the internal Buffer value. + * @param encoding { String } The BufferEncoding to use for strings. + * + * @return { SmartBuffer } + */ + static fromBuffer(buff, encoding) { + return new this({ + buff: buff, + encoding: encoding + }); + } + /** + * Creates a new SmartBuffer instance with the provided SmartBufferOptions options. + * + * @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance. + */ + static fromOptions(options) { + return new this(options); + } + /** + * Ensures that the internal Buffer is large enough to write data. + * + * @param minLength { Number } The minimum length of the data that needs to be written. + * @param offset { Number } The offset of the data to be written. + */ + ensureWriteable(minLength, offset) { + const offsetVal = typeof offset === 'number' ? offset : 0; + // Ensure there is enough internal Buffer capacity. + this.ensureCapacity(this.length + minLength + offsetVal); + // If offset is provided, copy data into appropriate location in regards to the offset. + if (typeof offset === 'number') { + this.buff.copy(this.buff, offsetVal + minLength, offsetVal, this.buff.length); + } + // Adjust instance length. + this.length = Math.max(this.length + minLength, offsetVal + minLength); + } + /** + * Ensures that the internal Buffer is large enough to write at least the given amount of data. + * + * @param minLength { Number } The minimum length of the data needs to be written. + */ + ensureCapacity(minLength) { + const oldLength = this.buff.length; + if (minLength > oldLength) { + let data = this.buff; + let newLength = (oldLength * 3) / 2 + 1; + if (newLength < minLength) { + newLength = minLength; + } + this.buff = Buffer.allocUnsafe(newLength); + data.copy(this.buff, 0, 0, oldLength); + } + } + /** + * Reads a numeric number value using the provided function. + * + * @param func { Function(offset: number) => number } The function to read data on the internal Buffer with. + * @param byteSize { Number } The number of bytes read. + * + * @param { Number } + */ + readNumberValue(func, byteSize) { + // Call Buffer.readXXXX(); + const value = func.call(this.buff, this.readOffset); + // Adjust internal read offset + this.readOffset += byteSize; + return value; + } + /** + * Writes a numeric number value using the provided function. + * + * @param func { Function(offset: number, offset?) => number} The function to write data on the internal Buffer with. + * @param byteSize { Number } The number of bytes written. + * @param value { Number } The number value to write. + * @param offset { Number } the offset to write the number at. + * + */ + writeNumberValue(func, byteSize, value, offset) { + const offsetVal = typeof offset === 'number' ? offset : this.writeOffset; + // Ensure there is enough internal Buffer capacity. (raw offset is passed) + this.ensureWriteable(byteSize, offset); + // Call buffer.writeXXXX(); + func.call(this.buff, value, offsetVal); + // Adjusts internal write offset + this.writeOffset += byteSize; + } + // Signed integers + /** + * Reads an Int8 value from the current read position. + * + * @return { Number } + */ + readInt8() { + return this.readNumberValue(Buffer.prototype.readUInt8, 1); + } + /** + * Reads an Int16BE value from the current read position. + * + * @return { Number } + */ + readInt16BE() { + return this.readNumberValue(Buffer.prototype.readUInt16BE, 2); + } + /** + * Reads an Int16LE value from the current read position. + * + * @return { Number } + */ + readInt16LE() { + return this.readNumberValue(Buffer.prototype.readUInt16LE, 2); + } + /** + * Reads an Int32BE value from the current read position. + * + * @return { Number } + */ + readInt32BE() { + return this.readNumberValue(Buffer.prototype.readUInt32BE, 4); + } + /** + * Reads an Int32LE value from the current read position. + * + * @return { Number } + */ + readInt32LE() { + return this.readNumberValue(Buffer.prototype.readUInt32LE, 4); + } + /** + * Writes an Int8 value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt8(value, offset) { + this.writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset); + return this; + } + /** + * Writes an Int16BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt16BE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset); + return this; + } + /** + * Writes an Int16LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt16LE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset); + return this; + } + /** + * Writes an Int32BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt32BE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset); + return this; + } + /** + * Writes an Int32LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt32LE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset); + return this; + } + // Unsigned Integers + /** + * Reads an UInt8 value from the current read position. + * + * @return { Number } + */ + readUInt8() { + return this.readNumberValue(Buffer.prototype.readUInt8, 1); + } + /** + * Reads an UInt16BE value from the current read position. + * + * @return { Number } + */ + readUInt16BE() { + return this.readNumberValue(Buffer.prototype.readUInt16BE, 2); + } + /** + * Reads an UInt16LE value from the current read position. + * + * @return { Number } + */ + readUInt16LE() { + return this.readNumberValue(Buffer.prototype.readUInt16LE, 2); + } + /** + * Reads an UInt32BE value from the current read position. + * + * @return { Number } + */ + readUInt32BE() { + return this.readNumberValue(Buffer.prototype.readUInt32BE, 4); + } + /** + * Reads an UInt32LE value from the current read position. + * + * @return { Number } + */ + readUInt32LE() { + return this.readNumberValue(Buffer.prototype.readUInt32LE, 4); + } + /** + * Writes an UInt8 value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt8(value, offset) { + this.writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset); + return this; + } + /** + * Writes an UInt16BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt16BE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset); + return this; + } + /** + * Writes an UInt16LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt16LE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset); + return this; + } + /** + * Writes an UInt32BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt32BE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset); + return this; + } + /** + * Writes an UInt32LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt32LE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset); + return this; + } + // Floating Point + /** + * Reads an FloatBE value from the current read position. + * + * @return { Number } + */ + readFloatBE() { + return this.readNumberValue(Buffer.prototype.readFloatBE, 4); + } + /** + * Reads an FloatLE value from the current read position. + * + * @return { Number } + */ + readFloatLE() { + return this.readNumberValue(Buffer.prototype.readFloatLE, 4); + } + /** + * Writes a FloatBE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeFloatBE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset); + return this; + } + /** + * Writes a FloatLE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeFloatLE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset); + return this; + } + // Double Floating Point + /** + * Reads an DoublEBE value from the current read position. + * + * @return { Number } + */ + readDoubleBE() { + return this.readNumberValue(Buffer.prototype.readDoubleBE, 8); + } + /** + * Reads an DoubleLE value from the current read position. + * + * @return { Number } + */ + readDoubleLE() { + return this.readNumberValue(Buffer.prototype.readDoubleLE, 8); + } + /** + * Writes a DoubleBE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeDoubleBE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset); + return this; + } + /** + * Writes a DoubleLE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeDoubleLE(value, offset) { + this.writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset); + return this; + } + // Strings + /** + * Reads a String from the current read position. + * + * @param length { Number } The number of bytes to read as a String. + * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). + * + * @return { String } + */ + readString(length, encoding) { + const lengthVal = Math.min(length, this.length - this.readOffset) || this.length - this.readOffset; + const value = this.buff.slice(this.readOffset, this.readOffset + lengthVal).toString(encoding || this.encoding); + this.readOffset += lengthVal; + return value; + } + /** + * Writes a String to the current write position. + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + */ + writeString(value, arg2, encoding) { + let offsetVal = this.writeOffset; + let encodingVal = this.encoding; + // Check for offset + if (typeof arg2 === 'number') { + offsetVal = arg2; + } + else if (typeof arg2 === 'string') { + if (Buffer.isEncoding(arg2)) { + encodingVal = arg2; + } + else { + throw new Error('Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.'); + } + } + // Check for encoding (third param) + if (typeof encoding === 'string') { + if (Buffer.isEncoding(encoding)) { + encodingVal = encoding; + } + else { + throw new Error('Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.'); + } + } + // Calculate bytelength of string. + const byteLength = Buffer.byteLength(value, encodingVal); + // Ensure there is enough internal Buffer capacity. + this.ensureWriteable(byteLength, offsetVal); + // Write value + this.buff.write(value, offsetVal, byteLength, encodingVal); + // Increment internal Buffer write offset; + this.writeOffset += byteLength; + return this; + } + /** + * Reads a null-terminated String from the current read position. + * + * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). + * + * @return { String } + */ + readStringNT(encoding) { + // Set null character position to the end SmartBuffer instance. + let nullPos = this.length; + // Find next null character (if one is not found, default from above is used) + for (let i = this.readOffset; i < this.length; i++) { + if (this.buff[i] === 0x00) { + nullPos = i; + break; + } + } + // Read string value + const value = this.buff.slice(this.readOffset, nullPos); + // Increment internal Buffer read offset + this.readOffset = nullPos + 1; + return value.toString(encoding || this.encoding); + } + /** + * Writes a null-terminated String to the current write position. + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + */ + writeStringNT(value, offset, encoding) { + // Write Values + this.writeString(value, offset, encoding); + this.writeUInt8(0x00, (typeof offset === 'number' ? offset + value.length : this.writeOffset)); + } + // Buffers + /** + * Reads a Buffer from the internal read position. + * + * @param length { Number } The length of data to read as a Buffer. + * + * @return { Buffer } + */ + readBuffer(length) { + const lengthVal = typeof length === 'number' ? length : this.length; + const endPoint = Math.min(this.length, this.readOffset + lengthVal); + // Read buffer value + const value = this.buff.slice(this.readOffset, endPoint); + // Increment internal Buffer read offset + this.readOffset = endPoint; + return value; + } + /** + * Writes a Buffer to the current write position. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + */ + writeBuffer(value, offset) { + const offsetVal = typeof offset === 'number' ? offset : this.writeOffset; + // Ensure there is enough internal Buffer capacity. + this.ensureWriteable(value.length, offsetVal); + // Write buffer value + value.copy(this.buff, offsetVal); + // Increment internal Buffer write offset + this.writeOffset += value.length; + return this; + } + /** + * Reads a null-terminated Buffer from the current read poisiton. + * + * @return { Buffer } + */ + readBufferNT() { + // Set null character position to the end SmartBuffer instance. + let nullPos = this.length; + // Find next null character (if one is not found, default from above is used) + for (let i = this.readOffset; i < this.length; i++) { + if (this.buff[i] === 0x00) { + nullPos = i; + break; + } + } + // Read value + const value = this.buff.slice(this.readOffset, nullPos); + // Increment internal Buffer read offset + this.readOffset = nullPos + 1; + return value; + } + /** + * Writes a null-terminated Buffer to the current write position. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + */ + writeBufferNT(value, offset) { + // Write Values + this.writeBuffer(value, offset); + this.writeUInt8(0, (typeof offset === 'number' ? offset + value.length : this.writeOffset)); + return this; + } + /** + * Clears the SmartBuffer instance to its original empty state. + */ + clear() { + this.writeOffset = 0; + this.readOffset = 0; + this.length = 0; + } + /** + * Gets the remaining data left to be read from the SmartBuffer instance. + * + * @return { Number } + */ + remaining() { + return this.length - this.readOffset; + } + /** + * Moves the read offset forward. + * + * @param amount { Number } The amount to move the read offset forward by. + */ + skip(amount) { + if (this.readOffset + amount > this.length) { + throw new Error('Target position is beyond the bounds of the SmartBuffer size.'); + } + this.readOffset += amount; + } + /** + * Moves the read offset backwards. + * + * @param amount { Number } The amount to move the read offset backwards by. + */ + rewind(amount) { + if (this.readOffset - amount < 0) { + throw new Error('Target position is beyond the bounds of the SmartBuffer size.'); + } + this.readOffset -= amount; + } + /** + * Moves the read offset to a specific position. + * + * @param position { Number } The position to move the read offset to. + */ + skipTo(position) { + this.moveTo(position); + } + /** + * Moves the read offset to a specific position. + * + * @param position { Number } The position to move the read offset to. + */ + moveTo(position) { + if (position > this.length) { + throw new Error('Target position is beyond the bounds of the SmartBuffer size.'); + } + this.readOffset = position; + } + /** + * Gets the value of the internal managed Buffer + * + * @param { Buffer } + */ + toBuffer() { + return this.buff.slice(0, this.length); + } + /** + * Gets the String value of the internal managed Buffer + * + * @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding). + */ + toString(encoding) { + const encodingVal = typeof encoding === 'string' ? encoding : this.encoding; + if (Buffer.isEncoding(encodingVal)) { + return this.buff.toString(encodingVal, 0, this.length); + } + else { + throw new Error('Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.'); + } + } + /** + * Destroys the SmartBuffer instance. + */ + destroy() { + this.clear(); + } + /** + * Type checking function that determines if an object is a SmartBufferOptions object. + */ + static isSmartBufferOptions(options) { + const castOptions = options; + return castOptions && (castOptions.encoding !== undefined || castOptions.size !== undefined || castOptions.buff !== undefined); + } +} +module.exports = SmartBuffer; +//# sourceMappingURL=smartbuffer.js.map
\ No newline at end of file |