@ttmg/cli 0.3.2-beta.8 → 0.3.2-beta.9

package/dist/index.js

@@ -6,13 +6,18 @@ var inquirer = require('inquirer');
 var path = require('path');
 var os = require('os');
 var axios = require('axios');
-var require$$0$1 = require('net');
+var net = require('net');
 var require$$1$2 = require('tls');
 var require$$2 = require('url');
 var require$$3 = require('assert');
 var require$$1 = require('tty');
 var require$$1$1 = require('util');
 var require$$0 = require('events');
+var require$$0$1 = require('buffer');
+var require$$2$1 = require('stream');
+var http = require('http');
+var https = require('https');
+var dns = require('dns');
 var fs = require('fs');
 var handlebars = require('handlebars');
 var esbuild = require('esbuild');
@@ -30,9 +35,7 @@ var worker_threads = require('worker_threads');
 var glob = require('glob');
 var got = require('got');
 var FormData$1 = require('form-data');
-var stream = require('stream');
 var ttmgPack = require('ttmg-pack');
-var http = require('http');
 var expressStaticGzip = require('express-static-gzip');
 var fileUpload = require('express-fileupload');
 var fs$1 = require('node:fs');
@@ -60,6 +63,10 @@ function _interopNamespaceDefault(e) {
 
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
+var net__namespace = /*#__PURE__*/_interopNamespaceDefault(net);
+var require$$1__namespace = /*#__PURE__*/_interopNamespaceDefault(require$$1$2);
+var http__namespace = /*#__PURE__*/_interopNamespaceDefault(http);
+var dns__namespace = /*#__PURE__*/_interopNamespaceDefault(dns);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var glob__namespace = /*#__PURE__*/_interopNamespaceDefault(glob);
 
@@ -89,6 +96,10 @@ async function openUrl(url) {
     }
 }
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 var agent = {};
 
 var src$1 = {exports: {}};
@@ -266,12 +277,12 @@ function requireMs () {
 	return ms;
 }
 
-var common;
-var hasRequiredCommon;
+var common$1;
+var hasRequiredCommon$1;
 
-function requireCommon () {
-	if (hasRequiredCommon) return common;
-	hasRequiredCommon = 1;
+function requireCommon$1 () {
+	if (hasRequiredCommon$1) return common$1;
+	hasRequiredCommon$1 = 1;
 	/**
 	 * This is the common logic for both the Node.js and web browser
 	 * implementations of `debug()`.
@@ -562,8 +573,8 @@ function requireCommon () {
 		return createDebug;
 	}
 
-	common = setup;
-	return common;
+	common$1 = setup;
+	return common$1;
 }
 
 /* eslint-env browser */
@@ -829,7 +840,7 @@ function requireBrowser () {
 			}
 		}
 
-		module.exports = requireCommon()(exports$1);
+		module.exports = requireCommon$1()(exports$1);
 
 		const {formatters} = module.exports;
 
@@ -1254,7 +1265,7 @@ function requireNode () {
 			}
 		}
 
-		module.exports = requireCommon()(exports$1);
+		module.exports = requireCommon$1()(exports$1);
 
 		const {formatters} = module.exports;
 
@@ -1631,7 +1642,7 @@ function requireAgent () {
 	    return (mod && mod.__esModule) ? mod : { "default": mod };
 	};
 	Object.defineProperty(agent, "__esModule", { value: true });
-	const net_1 = __importDefault(require$$0$1);
+	const net_1 = __importDefault(net);
 	const tls_1 = __importDefault(require$$1$2);
 	const url_1 = __importDefault(require$$2);
 	const assert_1 = __importDefault(require$$3);
@@ -1821,52 +1832,4694 @@ function requireDist () {
 
 var distExports = requireDist();
 
-const CONFIG_PATH$1 = process.env.TTMGRC_PATH || path.join(os.homedir(), '.ttmgrc');
-const getTTMGRC = () => {
-    // only check one time
-    if (!fs.existsSync(CONFIG_PATH$1)) {
-        return null;
-    }
-    else {
-        // safe parse
-        let res = JSON.parse(fs.readFileSync(CONFIG_PATH$1, 'utf8'));
-        return res;
-    }
-};
-const setTTMGRC = (config) => {
-    // updata cache config
-    config = config;
-    const originConfig = getTTMGRC() || {};
-    fs.writeFileSync(CONFIG_PATH$1, JSON.stringify({ ...originConfig, ...config }));
-};
-const resetTTMGRC = (config = {}) => {
-    fs.writeFileSync(CONFIG_PATH$1, JSON.stringify(config));
-};
-const getCurrentUser = () => {
-    try {
-        const config = getTTMGRC();
-        return config;
-    }
-    catch (err) {
-        return null;
-    }
-};
+var build$1 = {};
 
-// ppe_dev_tool
-function getAxiosProxyConfig() {
-    const config = getTTMGRC();
-    const proxyUrl = config?.proxy; // Only use internal config, let axios handle env vars if not set?
-    // User requirement: "内置代理配置".
-    // My logic in previous turn: "Priority: Internal Config > Env Vars".
-    // If I use `https-proxy-agent`, I should probably handle env vars too if I want consistent behavior,
-    // OR just let axios handle env vars if config.proxy is missing.
-    // BUT, if I don't set httpsAgent, axios uses env vars by default.
-    // SO:
-    if (proxyUrl) {
+var socksclient = {};
+
+var smartbuffer = {};
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	Object.defineProperty(utils, "__esModule", { value: true });
+	const buffer_1 = require$$0$1;
+	/**
+	 * Error strings
+	 */
+	const ERRORS = {
+	    INVALID_ENCODING: 'Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.',
+	    INVALID_SMARTBUFFER_SIZE: 'Invalid size provided. Size must be a valid integer greater than zero.',
+	    INVALID_SMARTBUFFER_BUFFER: 'Invalid Buffer provided in SmartBufferOptions.',
+	    INVALID_SMARTBUFFER_OBJECT: 'Invalid SmartBufferOptions object supplied to SmartBuffer constructor or factory methods.',
+	    INVALID_OFFSET: 'An invalid offset value was provided.',
+	    INVALID_OFFSET_NON_NUMBER: 'An invalid offset value was provided. A numeric value is required.',
+	    INVALID_LENGTH: 'An invalid length value was provided.',
+	    INVALID_LENGTH_NON_NUMBER: 'An invalid length value was provived. A numeric value is required.',
+	    INVALID_TARGET_OFFSET: 'Target offset is beyond the bounds of the internal SmartBuffer data.',
+	    INVALID_TARGET_LENGTH: 'Specified length value moves cursor beyong the bounds of the internal SmartBuffer data.',
+	    INVALID_READ_BEYOND_BOUNDS: 'Attempted to read beyond the bounds of the managed data.',
+	    INVALID_WRITE_BEYOND_BOUNDS: 'Attempted to write beyond the bounds of the managed data.'
+	};
+	utils.ERRORS = ERRORS;
+	/**
+	 * Checks if a given encoding is a valid Buffer encoding. (Throws an exception if check fails)
+	 *
+	 * @param { String } encoding The encoding string to check.
+	 */
+	function checkEncoding(encoding) {
+	    if (!buffer_1.Buffer.isEncoding(encoding)) {
+	        throw new Error(ERRORS.INVALID_ENCODING);
+	    }
+	}
+	utils.checkEncoding = checkEncoding;
+	/**
+	 * Checks if a given number is a finite integer. (Throws an exception if check fails)
+	 *
+	 * @param { Number } value The number value to check.
+	 */
+	function isFiniteInteger(value) {
+	    return typeof value === 'number' && isFinite(value) && isInteger(value);
+	}
+	utils.isFiniteInteger = isFiniteInteger;
+	/**
+	 * Checks if an offset/length value is valid. (Throws an exception if check fails)
+	 *
+	 * @param value The value to check.
+	 * @param offset True if checking an offset, false if checking a length.
+	 */
+	function checkOffsetOrLengthValue(value, offset) {
+	    if (typeof value === 'number') {
+	        // Check for non finite/non integers
+	        if (!isFiniteInteger(value) || value < 0) {
+	            throw new Error(offset ? ERRORS.INVALID_OFFSET : ERRORS.INVALID_LENGTH);
+	        }
+	    }
+	    else {
+	        throw new Error(offset ? ERRORS.INVALID_OFFSET_NON_NUMBER : ERRORS.INVALID_LENGTH_NON_NUMBER);
+	    }
+	}
+	/**
+	 * Checks if a length value is valid. (Throws an exception if check fails)
+	 *
+	 * @param { Number } length The value to check.
+	 */
+	function checkLengthValue(length) {
+	    checkOffsetOrLengthValue(length, false);
+	}
+	utils.checkLengthValue = checkLengthValue;
+	/**
+	 * Checks if a offset value is valid. (Throws an exception if check fails)
+	 *
+	 * @param { Number } offset The value to check.
+	 */
+	function checkOffsetValue(offset) {
+	    checkOffsetOrLengthValue(offset, true);
+	}
+	utils.checkOffsetValue = checkOffsetValue;
+	/**
+	 * Checks if a target offset value is out of bounds. (Throws an exception if check fails)
+	 *
+	 * @param { Number } offset The offset value to check.
+	 * @param { SmartBuffer } buff The SmartBuffer instance to check against.
+	 */
+	function checkTargetOffset(offset, buff) {
+	    if (offset < 0 || offset > buff.length) {
+	        throw new Error(ERRORS.INVALID_TARGET_OFFSET);
+	    }
+	}
+	utils.checkTargetOffset = checkTargetOffset;
+	/**
+	 * Determines whether a given number is a integer.
+	 * @param value The number to check.
+	 */
+	function isInteger(value) {
+	    return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+	}
+	/**
+	 * Throws if Node.js version is too low to support bigint
+	 */
+	function bigIntAndBufferInt64Check(bufferMethod) {
+	    if (typeof BigInt === 'undefined') {
+	        throw new Error('Platform does not support JS BigInt type.');
+	    }
+	    if (typeof buffer_1.Buffer.prototype[bufferMethod] === 'undefined') {
+	        throw new Error(`Platform does not support Buffer.prototype.${bufferMethod}.`);
+	    }
+	}
+	utils.bigIntAndBufferInt64Check = bigIntAndBufferInt64Check;
+	
+	return utils;
+}
+
+var hasRequiredSmartbuffer;
+
+function requireSmartbuffer () {
+	if (hasRequiredSmartbuffer) return smartbuffer;
+	hasRequiredSmartbuffer = 1;
+	Object.defineProperty(smartbuffer, "__esModule", { value: true });
+	const utils_1 = requireUtils();
+	// 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 options { SmartBufferOptions } The SmartBufferOptions to apply to this instance.
+	     */
+	    constructor(options) {
+	        this.length = 0;
+	        this._encoding = DEFAULT_SMARTBUFFER_ENCODING;
+	        this._writeOffset = 0;
+	        this._readOffset = 0;
+	        if (SmartBuffer.isSmartBufferOptions(options)) {
+	            // Checks for encoding
+	            if (options.encoding) {
+	                utils_1.checkEncoding(options.encoding);
+	                this._encoding = options.encoding;
+	            }
+	            // Checks for initial size length
+	            if (options.size) {
+	                if (utils_1.isFiniteInteger(options.size) && options.size > 0) {
+	                    this._buff = Buffer.allocUnsafe(options.size);
+	                }
+	                else {
+	                    throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE);
+	                }
+	                // Check for initial Buffer
+	            }
+	            else if (options.buff) {
+	                if (Buffer.isBuffer(options.buff)) {
+	                    this._buff = options.buff;
+	                    this.length = options.buff.length;
+	                }
+	                else {
+	                    throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER);
+	                }
+	            }
+	            else {
+	                this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
+	            }
+	        }
+	        else {
+	            // If something was passed but it's not a SmartBufferOptions object
+	            if (typeof options !== 'undefined') {
+	                throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT);
+	            }
+	            // Otherwise default to sane options
+	            this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
+	        }
+	    }
+	    /**
+	     * 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);
+	    }
+	    /**
+	     * 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));
+	    }
+	    // Signed integers
+	    /**
+	     * Reads an Int8 value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readInt8(offset) {
+	        return this._readNumberValue(Buffer.prototype.readInt8, 1, offset);
+	    }
+	    /**
+	     * Reads an Int16BE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readInt16BE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset);
+	    }
+	    /**
+	     * Reads an Int16LE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readInt16LE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset);
+	    }
+	    /**
+	     * Reads an Int32BE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readInt32BE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset);
+	    }
+	    /**
+	     * Reads an Int32LE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readInt32LE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset);
+	    }
+	    /**
+	     * Reads a BigInt64BE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { BigInt }
+	     */
+	    readBigInt64BE(offset) {
+	        utils_1.bigIntAndBufferInt64Check('readBigInt64BE');
+	        return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset);
+	    }
+	    /**
+	     * Reads a BigInt64LE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { BigInt }
+	     */
+	    readBigInt64LE(offset) {
+	        utils_1.bigIntAndBufferInt64Check('readBigInt64LE');
+	        return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset);
+	    }
+	    /**
+	     * 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;
+	    }
+	    /**
+	     * Inserts an Int8 value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertInt8(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
+	    }
+	    /**
+	     * Inserts an Int16BE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertInt16BE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
+	    }
+	    /**
+	     * Inserts an Int16LE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertInt16LE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
+	    }
+	    /**
+	     * Inserts an Int32BE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertInt32BE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
+	    }
+	    /**
+	     * Inserts an Int32LE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertInt32LE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
+	    }
+	    /**
+	     * Writes a BigInt64BE value to the current write position (or at optional offset).
+	     *
+	     * @param value { BigInt } The value to write.
+	     * @param offset { Number } The offset to write the value at.
+	     *
+	     * @return this
+	     */
+	    writeBigInt64BE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');
+	        return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
+	    }
+	    /**
+	     * Inserts a BigInt64BE value at the given offset value.
+	     *
+	     * @param value { BigInt } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertBigInt64BE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');
+	        return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
+	    }
+	    /**
+	     * Writes a BigInt64LE value to the current write position (or at optional offset).
+	     *
+	     * @param value { BigInt } The value to write.
+	     * @param offset { Number } The offset to write the value at.
+	     *
+	     * @return this
+	     */
+	    writeBigInt64LE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');
+	        return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
+	    }
+	    /**
+	     * Inserts a Int64LE value at the given offset value.
+	     *
+	     * @param value { BigInt } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertBigInt64LE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');
+	        return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
+	    }
+	    // Unsigned Integers
+	    /**
+	     * Reads an UInt8 value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readUInt8(offset) {
+	        return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset);
+	    }
+	    /**
+	     * Reads an UInt16BE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readUInt16BE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset);
+	    }
+	    /**
+	     * Reads an UInt16LE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readUInt16LE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset);
+	    }
+	    /**
+	     * Reads an UInt32BE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readUInt32BE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset);
+	    }
+	    /**
+	     * Reads an UInt32LE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readUInt32LE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset);
+	    }
+	    /**
+	     * Reads a BigUInt64BE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { BigInt }
+	     */
+	    readBigUInt64BE(offset) {
+	        utils_1.bigIntAndBufferInt64Check('readBigUInt64BE');
+	        return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset);
+	    }
+	    /**
+	     * Reads a BigUInt64LE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { BigInt }
+	     */
+	    readBigUInt64LE(offset) {
+	        utils_1.bigIntAndBufferInt64Check('readBigUInt64LE');
+	        return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
+	    }
+	    /**
+	     * Inserts an UInt8 value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertUInt8(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
+	    }
+	    /**
+	     * Inserts an UInt16BE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertUInt16BE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
+	    }
+	    /**
+	     * Inserts an UInt16LE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertUInt16LE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
+	    }
+	    /**
+	     * Inserts an UInt32BE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertUInt32BE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
+	    }
+	    /**
+	     * Inserts an UInt32LE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertUInt32LE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
+	    }
+	    /**
+	     * Writes a BigUInt64BE 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
+	     */
+	    writeBigUInt64BE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');
+	        return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
+	    }
+	    /**
+	     * Inserts a BigUInt64BE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertBigUInt64BE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');
+	        return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
+	    }
+	    /**
+	     * Writes a BigUInt64LE 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
+	     */
+	    writeBigUInt64LE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');
+	        return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
+	    }
+	    /**
+	     * Inserts a BigUInt64LE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertBigUInt64LE(value, offset) {
+	        utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');
+	        return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
+	    }
+	    // Floating Point
+	    /**
+	     * Reads an FloatBE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readFloatBE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset);
+	    }
+	    /**
+	     * Reads an FloatLE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readFloatLE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
+	    }
+	    /**
+	     * Inserts a FloatBE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertFloatBE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
+	    }
+	    /**
+	     * Inserts a FloatLE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertFloatLE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
+	    }
+	    // Double Floating Point
+	    /**
+	     * Reads an DoublEBE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readDoubleBE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset);
+	    }
+	    /**
+	     * Reads an DoubleLE value from the current read position or an optionally provided offset.
+	     *
+	     * @param offset { Number } The offset to read data from (optional)
+	     * @return { Number }
+	     */
+	    readDoubleLE(offset) {
+	        return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
+	    }
+	    /**
+	     * Inserts a DoubleBE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertDoubleBE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
+	    }
+	    /**
+	     * 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) {
+	        return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
+	    }
+	    /**
+	     * Inserts a DoubleLE value at the given offset value.
+	     *
+	     * @param value { Number } The value to insert.
+	     * @param offset { Number } The offset to insert the value at.
+	     *
+	     * @return this
+	     */
+	    insertDoubleLE(value, offset) {
+	        return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
+	    }
+	    // Strings
+	    /**
+	     * Reads a String from the current read position.
+	     *
+	     * @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for
+	     *             the string (Defaults to instance level encoding).
+	     * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding).
+	     *
+	     * @return { String }
+	     */
+	    readString(arg1, encoding) {
+	        let lengthVal;
+	        // Length provided
+	        if (typeof arg1 === 'number') {
+	            utils_1.checkLengthValue(arg1);
+	            lengthVal = Math.min(arg1, this.length - this._readOffset);
+	        }
+	        else {
+	            encoding = arg1;
+	            lengthVal = this.length - this._readOffset;
+	        }
+	        // Check encoding
+	        if (typeof encoding !== 'undefined') {
+	            utils_1.checkEncoding(encoding);
+	        }
+	        const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding);
+	        this._readOffset += lengthVal;
+	        return value;
+	    }
+	    /**
+	     * Inserts a String
+	     *
+	     * @param value { String } The String value to insert.
+	     * @param offset { Number } The offset to insert the string at.
+	     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
+	     *
+	     * @return this
+	     */
+	    insertString(value, offset, encoding) {
+	        utils_1.checkOffsetValue(offset);
+	        return this._handleString(value, true, offset, encoding);
+	    }
+	    /**
+	     * Writes a String
+	     *
+	     * @param value { String } The String value to write.
+	     * @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use.
+	     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
+	     *
+	     * @return this
+	     */
+	    writeString(value, arg2, encoding) {
+	        return this._handleString(value, false, arg2, encoding);
+	    }
+	    /**
+	     * 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) {
+	        if (typeof encoding !== 'undefined') {
+	            utils_1.checkEncoding(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);
+	    }
+	    /**
+	     * Inserts a null-terminated String.
+	     *
+	     * @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).
+	     *
+	     * @return this
+	     */
+	    insertStringNT(value, offset, encoding) {
+	        utils_1.checkOffsetValue(offset);
+	        // Write Values
+	        this.insertString(value, offset, encoding);
+	        this.insertUInt8(0x00, offset + value.length);
+	        return this;
+	    }
+	    /**
+	     * Writes a null-terminated String.
+	     *
+	     * @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).
+	     *
+	     * @return this
+	     */
+	    writeStringNT(value, arg2, encoding) {
+	        // Write Values
+	        this.writeString(value, arg2, encoding);
+	        this.writeUInt8(0x00, typeof arg2 === 'number' ? arg2 + value.length : this.writeOffset);
+	        return this;
+	    }
+	    // 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) {
+	        if (typeof length !== 'undefined') {
+	            utils_1.checkLengthValue(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.
+	     *
+	     * @return this
+	     */
+	    insertBuffer(value, offset) {
+	        utils_1.checkOffsetValue(offset);
+	        return this._handleBuffer(value, true, offset);
+	    }
+	    /**
+	     * 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.
+	     *
+	     * @return this
+	     */
+	    writeBuffer(value, offset) {
+	        return this._handleBuffer(value, false, offset);
+	    }
+	    /**
+	     * 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;
+	    }
+	    /**
+	     * Inserts a null-terminated Buffer.
+	     *
+	     * @param value { Buffer } The Buffer to write.
+	     * @param offset { Number } The offset to write the Buffer to.
+	     *
+	     * @return this
+	     */
+	    insertBufferNT(value, offset) {
+	        utils_1.checkOffsetValue(offset);
+	        // Write Values
+	        this.insertBuffer(value, offset);
+	        this.insertUInt8(0x00, offset + value.length);
+	        return this;
+	    }
+	    /**
+	     * Writes a null-terminated Buffer.
+	     *
+	     * @param value { Buffer } The Buffer to write.
+	     * @param offset { Number } The offset to write the Buffer to.
+	     *
+	     * @return this
+	     */
+	    writeBufferNT(value, offset) {
+	        // Checks for valid numberic value;
+	        if (typeof offset !== 'undefined') {
+	            utils_1.checkOffsetValue(offset);
+	        }
+	        // Write Values
+	        this.writeBuffer(value, offset);
+	        this.writeUInt8(0x00, 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;
+	        return this;
+	    }
+	    /**
+	     * Gets the remaining data left to be read from the SmartBuffer instance.
+	     *
+	     * @return { Number }
+	     */
+	    remaining() {
+	        return this.length - this._readOffset;
+	    }
+	    /**
+	     * Gets the current read offset value of the SmartBuffer instance.
+	     *
+	     * @return { Number }
+	     */
+	    get readOffset() {
+	        return this._readOffset;
+	    }
+	    /**
+	     * Sets the read offset value of the SmartBuffer instance.
+	     *
+	     * @param offset { Number } - The offset value to set.
+	     */
+	    set readOffset(offset) {
+	        utils_1.checkOffsetValue(offset);
+	        // Check for bounds.
+	        utils_1.checkTargetOffset(offset, this);
+	        this._readOffset = offset;
+	    }
+	    /**
+	     * Gets the current write offset value of the SmartBuffer instance.
+	     *
+	     * @return { Number }
+	     */
+	    get writeOffset() {
+	        return this._writeOffset;
+	    }
+	    /**
+	     * Sets the write offset value of the SmartBuffer instance.
+	     *
+	     * @param offset { Number } - The offset value to set.
+	     */
+	    set writeOffset(offset) {
+	        utils_1.checkOffsetValue(offset);
+	        // Check for bounds.
+	        utils_1.checkTargetOffset(offset, this);
+	        this._writeOffset = offset;
+	    }
+	    /**
+	     * Gets the currently set string encoding of the SmartBuffer instance.
+	     *
+	     * @return { BufferEncoding } The string Buffer encoding currently set.
+	     */
+	    get encoding() {
+	        return this._encoding;
+	    }
+	    /**
+	     * Sets the string encoding of the SmartBuffer instance.
+	     *
+	     * @param encoding { BufferEncoding } The string Buffer encoding to set.
+	     */
+	    set encoding(encoding) {
+	        utils_1.checkEncoding(encoding);
+	        this._encoding = encoding;
+	    }
+	    /**
+	     * Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer)
+	     *
+	     * @return { Buffer } The Buffer value.
+	     */
+	    get internalBuffer() {
+	        return this._buff;
+	    }
+	    /**
+	     * Gets the value of the internal managed Buffer (Includes managed data only)
+	     *
+	     * @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;
+	        // Check for invalid encoding.
+	        utils_1.checkEncoding(encodingVal);
+	        return this._buff.toString(encodingVal, 0, this.length);
+	    }
+	    /**
+	     * Destroys the SmartBuffer instance.
+	     */
+	    destroy() {
+	        this.clear();
+	        return this;
+	    }
+	    /**
+	     * Handles inserting and writing strings.
+	     *
+	     * @param value { String } The String value to insert.
+	     * @param isInsert { Boolean } True if inserting a string, false if writing.
+	     * @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use.
+	     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
+	     */
+	    _handleString(value, isInsert, arg3, encoding) {
+	        let offsetVal = this._writeOffset;
+	        let encodingVal = this._encoding;
+	        // Check for offset
+	        if (typeof arg3 === 'number') {
+	            offsetVal = arg3;
+	            // Check for encoding
+	        }
+	        else if (typeof arg3 === 'string') {
+	            utils_1.checkEncoding(arg3);
+	            encodingVal = arg3;
+	        }
+	        // Check for encoding (third param)
+	        if (typeof encoding === 'string') {
+	            utils_1.checkEncoding(encoding);
+	            encodingVal = encoding;
+	        }
+	        // Calculate bytelength of string.
+	        const byteLength = Buffer.byteLength(value, encodingVal);
+	        // Ensure there is enough internal Buffer capacity.
+	        if (isInsert) {
+	            this.ensureInsertable(byteLength, offsetVal);
+	        }
+	        else {
+	            this._ensureWriteable(byteLength, offsetVal);
+	        }
+	        // Write value
+	        this._buff.write(value, offsetVal, byteLength, encodingVal);
+	        // Increment internal Buffer write offset;
+	        if (isInsert) {
+	            this._writeOffset += byteLength;
+	        }
+	        else {
+	            // If an offset was given, check to see if we wrote beyond the current writeOffset.
+	            if (typeof arg3 === 'number') {
+	                this._writeOffset = Math.max(this._writeOffset, offsetVal + byteLength);
+	            }
+	            else {
+	                // If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
+	                this._writeOffset += byteLength;
+	            }
+	        }
+	        return this;
+	    }
+	    /**
+	     * Handles writing or insert of a Buffer.
+	     *
+	     * @param value { Buffer } The Buffer to write.
+	     * @param offset { Number } The offset to write the Buffer to.
+	     */
+	    _handleBuffer(value, isInsert, offset) {
+	        const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
+	        // Ensure there is enough internal Buffer capacity.
+	        if (isInsert) {
+	            this.ensureInsertable(value.length, offsetVal);
+	        }
+	        else {
+	            this._ensureWriteable(value.length, offsetVal);
+	        }
+	        // Write buffer value
+	        value.copy(this._buff, offsetVal);
+	        // Increment internal Buffer write offset;
+	        if (isInsert) {
+	            this._writeOffset += value.length;
+	        }
+	        else {
+	            // If an offset was given, check to see if we wrote beyond the current writeOffset.
+	            if (typeof offset === 'number') {
+	                this._writeOffset = Math.max(this._writeOffset, offsetVal + value.length);
+	            }
+	            else {
+	                // If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
+	                this._writeOffset += value.length;
+	            }
+	        }
+	        return this;
+	    }
+	    /**
+	     * Ensures that the internal Buffer is large enough to read data.
+	     *
+	     * @param length { Number } The length of the data that needs to be read.
+	     * @param offset { Number } The offset of the data that needs to be read.
+	     */
+	    ensureReadable(length, offset) {
+	        // Offset value defaults to managed read offset.
+	        let offsetVal = this._readOffset;
+	        // If an offset was provided, use it.
+	        if (typeof offset !== 'undefined') {
+	            // Checks for valid numberic value;
+	            utils_1.checkOffsetValue(offset);
+	            // Overide with custom offset.
+	            offsetVal = offset;
+	        }
+	        // Checks if offset is below zero, or the offset+length offset is beyond the total length of the managed data.
+	        if (offsetVal < 0 || offsetVal + length > this.length) {
+	            throw new Error(utils_1.ERRORS.INVALID_READ_BEYOND_BOUNDS);
+	        }
+	    }
+	    /**
+	     * Ensures that the internal Buffer is large enough to insert data.
+	     *
+	     * @param dataLength { Number } The length of the data that needs to be written.
+	     * @param offset { Number } The offset of the data to be written.
+	     */
+	    ensureInsertable(dataLength, offset) {
+	        // Checks for valid numberic value;
+	        utils_1.checkOffsetValue(offset);
+	        // Ensure there is enough internal Buffer capacity.
+	        this._ensureCapacity(this.length + dataLength);
+	        // If an offset was provided and its not the very end of the buffer, copy data into appropriate location in regards to the offset.
+	        if (offset < this.length) {
+	            this._buff.copy(this._buff, offset + dataLength, offset, this._buff.length);
+	        }
+	        // Adjust tracked smart buffer length
+	        if (offset + dataLength > this.length) {
+	            this.length = offset + dataLength;
+	        }
+	        else {
+	            this.length += dataLength;
+	        }
+	    }
+	    /**
+	     * Ensures that the internal Buffer is large enough to write data.
+	     *
+	     * @param dataLength { Number } The length of the data that needs to be written.
+	     * @param offset { Number } The offset of the data to be written (defaults to writeOffset).
+	     */
+	    _ensureWriteable(dataLength, offset) {
+	        const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
+	        // Ensure enough capacity to write data.
+	        this._ensureCapacity(offsetVal + dataLength);
+	        // Adjust SmartBuffer length (if offset + length is larger than managed length, adjust length)
+	        if (offsetVal + dataLength > this.length) {
+	            this.length = offsetVal + dataLength;
+	        }
+	    }
+	    /**
+	     * 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.
+	     *
+	     * @typeparam T { number | bigint } The type of the value to be read
+	     *
+	     * @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 offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead.
+	     *
+	     * @returns { T } the number value
+	     */
+	    _readNumberValue(func, byteSize, offset) {
+	        this.ensureReadable(byteSize, offset);
+	        // Call Buffer.readXXXX();
+	        const value = func.call(this._buff, typeof offset === 'number' ? offset : this._readOffset);
+	        // Adjust internal read offset if an optional read offset was not provided.
+	        if (typeof offset === 'undefined') {
+	            this._readOffset += byteSize;
+	        }
+	        return value;
+	    }
+	    /**
+	     * Inserts a numeric number value based on the given offset and value.
+	     *
+	     * @typeparam T { number | bigint } The type of the value to be written
+	     *
+	     * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.
+	     * @param byteSize { Number } The number of bytes written.
+	     * @param value { T } The number value to write.
+	     * @param offset { Number } the offset to write the number at (REQUIRED).
+	     *
+	     * @returns SmartBuffer this buffer
+	     */
+	    _insertNumberValue(func, byteSize, value, offset) {
+	        // Check for invalid offset values.
+	        utils_1.checkOffsetValue(offset);
+	        // Ensure there is enough internal Buffer capacity. (raw offset is passed)
+	        this.ensureInsertable(byteSize, offset);
+	        // Call buffer.writeXXXX();
+	        func.call(this._buff, value, offset);
+	        // Adjusts internally managed write offset.
+	        this._writeOffset += byteSize;
+	        return this;
+	    }
+	    /**
+	     * Writes a numeric number value based on the given offset and value.
+	     *
+	     * @typeparam T { number | bigint } The type of the value to be written
+	     *
+	     * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.
+	     * @param byteSize { Number } The number of bytes written.
+	     * @param value { T } The number value to write.
+	     * @param offset { Number } the offset to write the number at (REQUIRED).
+	     *
+	     * @returns SmartBuffer this buffer
+	     */
+	    _writeNumberValue(func, byteSize, value, offset) {
+	        // If an offset was provided, validate it.
+	        if (typeof offset === 'number') {
+	            // Check if we're writing beyond the bounds of the managed data.
+	            if (offset < 0) {
+	                throw new Error(utils_1.ERRORS.INVALID_WRITE_BEYOND_BOUNDS);
+	            }
+	            utils_1.checkOffsetValue(offset);
+	        }
+	        // Default to writeOffset if no offset value was given.
+	        const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
+	        // Ensure there is enough internal Buffer capacity. (raw offset is passed)
+	        this._ensureWriteable(byteSize, offsetVal);
+	        func.call(this._buff, value, offsetVal);
+	        // If an offset was given, check to see if we wrote beyond the current writeOffset.
+	        if (typeof offset === 'number') {
+	            this._writeOffset = Math.max(this._writeOffset, offsetVal + byteSize);
+	        }
+	        else {
+	            // If no numeric offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
+	            this._writeOffset += byteSize;
+	        }
+	        return this;
+	    }
+	}
+	smartbuffer.SmartBuffer = SmartBuffer;
+	
+	return smartbuffer;
+}
+
+var constants$2 = {};
+
+var hasRequiredConstants$2;
+
+function requireConstants$2 () {
+	if (hasRequiredConstants$2) return constants$2;
+	hasRequiredConstants$2 = 1;
+	Object.defineProperty(constants$2, "__esModule", { value: true });
+	constants$2.SOCKS5_NO_ACCEPTABLE_AUTH = constants$2.SOCKS5_CUSTOM_AUTH_END = constants$2.SOCKS5_CUSTOM_AUTH_START = constants$2.SOCKS_INCOMING_PACKET_SIZES = constants$2.SocksClientState = constants$2.Socks5Response = constants$2.Socks5HostType = constants$2.Socks5Auth = constants$2.Socks4Response = constants$2.SocksCommand = constants$2.ERRORS = constants$2.DEFAULT_TIMEOUT = void 0;
+	const DEFAULT_TIMEOUT = 30000;
+	constants$2.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+	// prettier-ignore
+	const ERRORS = {
+	    InvalidSocksCommand: 'An invalid SOCKS command was provided. Valid options are connect, bind, and associate.',
+	    InvalidSocksCommandForOperation: 'An invalid SOCKS command was provided. Only a subset of commands are supported for this operation.',
+	    InvalidSocksCommandChain: 'An invalid SOCKS command was provided. Chaining currently only supports the connect command.',
+	    InvalidSocksClientOptionsDestination: 'An invalid destination host was provided.',
+	    InvalidSocksClientOptionsExistingSocket: 'An invalid existing socket was provided. This should be an instance of stream.Duplex.',
+	    InvalidSocksClientOptionsProxy: 'Invalid SOCKS proxy details were provided.',
+	    InvalidSocksClientOptionsTimeout: 'An invalid timeout value was provided. Please enter a value above 0 (in ms).',
+	    InvalidSocksClientOptionsProxiesLength: 'At least two socks proxies must be provided for chaining.',
+	    InvalidSocksClientOptionsCustomAuthRange: 'Custom auth must be a value between 0x80 and 0xFE.',
+	    InvalidSocksClientOptionsCustomAuthOptions: 'When a custom_auth_method is provided, custom_auth_request_handler, custom_auth_response_size, and custom_auth_response_handler must also be provided and valid.',
+	    NegotiationError: 'Negotiation error',
+	    SocketClosed: 'Socket closed',
+	    ProxyConnectionTimedOut: 'Proxy connection timed out',
+	    InternalError: 'SocksClient internal error (this should not happen)',
+	    InvalidSocks4HandshakeResponse: 'Received invalid Socks4 handshake response',
+	    Socks4ProxyRejectedConnection: 'Socks4 Proxy rejected connection',
+	    InvalidSocks4IncomingConnectionResponse: 'Socks4 invalid incoming connection response',
+	    Socks4ProxyRejectedIncomingBoundConnection: 'Socks4 Proxy rejected incoming bound connection',
+	    InvalidSocks5InitialHandshakeResponse: 'Received invalid Socks5 initial handshake response',
+	    InvalidSocks5IntiailHandshakeSocksVersion: 'Received invalid Socks5 initial handshake (invalid socks version)',
+	    InvalidSocks5InitialHandshakeNoAcceptedAuthType: 'Received invalid Socks5 initial handshake (no accepted authentication type)',
+	    InvalidSocks5InitialHandshakeUnknownAuthType: 'Received invalid Socks5 initial handshake (unknown authentication type)',
+	    Socks5AuthenticationFailed: 'Socks5 Authentication failed',
+	    InvalidSocks5FinalHandshake: 'Received invalid Socks5 final handshake response',
+	    InvalidSocks5FinalHandshakeRejected: 'Socks5 proxy rejected connection',
+	    InvalidSocks5IncomingConnectionResponse: 'Received invalid Socks5 incoming connection response',
+	    Socks5ProxyRejectedIncomingBoundConnection: 'Socks5 Proxy rejected incoming bound connection',
+	};
+	constants$2.ERRORS = ERRORS;
+	const SOCKS_INCOMING_PACKET_SIZES = {
+	    Socks5InitialHandshakeResponse: 2,
+	    Socks5UserPassAuthenticationResponse: 2,
+	    // Command response + incoming connection (bind)
+	    Socks5ResponseHeader: 5, // We need at least 5 to read the hostname length, then we wait for the address+port information.
+	    Socks5ResponseIPv4: 10, // 4 header + 4 ip + 2 port
+	    Socks5ResponseIPv6: 22, // 4 header + 16 ip + 2 port
+	    Socks5ResponseHostname: (hostNameLength) => hostNameLength + 7, // 4 header + 1 host length + host + 2 port
+	    // Command response + incoming connection (bind)
+	    Socks4Response: 8, // 2 header + 2 port + 4 ip
+	};
+	constants$2.SOCKS_INCOMING_PACKET_SIZES = SOCKS_INCOMING_PACKET_SIZES;
+	var SocksCommand;
+	(function (SocksCommand) {
+	    SocksCommand[SocksCommand["connect"] = 1] = "connect";
+	    SocksCommand[SocksCommand["bind"] = 2] = "bind";
+	    SocksCommand[SocksCommand["associate"] = 3] = "associate";
+	})(SocksCommand || (constants$2.SocksCommand = SocksCommand = {}));
+	var Socks4Response;
+	(function (Socks4Response) {
+	    Socks4Response[Socks4Response["Granted"] = 90] = "Granted";
+	    Socks4Response[Socks4Response["Failed"] = 91] = "Failed";
+	    Socks4Response[Socks4Response["Rejected"] = 92] = "Rejected";
+	    Socks4Response[Socks4Response["RejectedIdent"] = 93] = "RejectedIdent";
+	})(Socks4Response || (constants$2.Socks4Response = Socks4Response = {}));
+	var Socks5Auth;
+	(function (Socks5Auth) {
+	    Socks5Auth[Socks5Auth["NoAuth"] = 0] = "NoAuth";
+	    Socks5Auth[Socks5Auth["GSSApi"] = 1] = "GSSApi";
+	    Socks5Auth[Socks5Auth["UserPass"] = 2] = "UserPass";
+	})(Socks5Auth || (constants$2.Socks5Auth = Socks5Auth = {}));
+	const SOCKS5_CUSTOM_AUTH_START = 0x80;
+	constants$2.SOCKS5_CUSTOM_AUTH_START = SOCKS5_CUSTOM_AUTH_START;
+	const SOCKS5_CUSTOM_AUTH_END = 0xfe;
+	constants$2.SOCKS5_CUSTOM_AUTH_END = SOCKS5_CUSTOM_AUTH_END;
+	const SOCKS5_NO_ACCEPTABLE_AUTH = 0xff;
+	constants$2.SOCKS5_NO_ACCEPTABLE_AUTH = SOCKS5_NO_ACCEPTABLE_AUTH;
+	var Socks5Response;
+	(function (Socks5Response) {
+	    Socks5Response[Socks5Response["Granted"] = 0] = "Granted";
+	    Socks5Response[Socks5Response["Failure"] = 1] = "Failure";
+	    Socks5Response[Socks5Response["NotAllowed"] = 2] = "NotAllowed";
+	    Socks5Response[Socks5Response["NetworkUnreachable"] = 3] = "NetworkUnreachable";
+	    Socks5Response[Socks5Response["HostUnreachable"] = 4] = "HostUnreachable";
+	    Socks5Response[Socks5Response["ConnectionRefused"] = 5] = "ConnectionRefused";
+	    Socks5Response[Socks5Response["TTLExpired"] = 6] = "TTLExpired";
+	    Socks5Response[Socks5Response["CommandNotSupported"] = 7] = "CommandNotSupported";
+	    Socks5Response[Socks5Response["AddressNotSupported"] = 8] = "AddressNotSupported";
+	})(Socks5Response || (constants$2.Socks5Response = Socks5Response = {}));
+	var Socks5HostType;
+	(function (Socks5HostType) {
+	    Socks5HostType[Socks5HostType["IPv4"] = 1] = "IPv4";
+	    Socks5HostType[Socks5HostType["Hostname"] = 3] = "Hostname";
+	    Socks5HostType[Socks5HostType["IPv6"] = 4] = "IPv6";
+	})(Socks5HostType || (constants$2.Socks5HostType = Socks5HostType = {}));
+	var SocksClientState;
+	(function (SocksClientState) {
+	    SocksClientState[SocksClientState["Created"] = 0] = "Created";
+	    SocksClientState[SocksClientState["Connecting"] = 1] = "Connecting";
+	    SocksClientState[SocksClientState["Connected"] = 2] = "Connected";
+	    SocksClientState[SocksClientState["SentInitialHandshake"] = 3] = "SentInitialHandshake";
+	    SocksClientState[SocksClientState["ReceivedInitialHandshakeResponse"] = 4] = "ReceivedInitialHandshakeResponse";
+	    SocksClientState[SocksClientState["SentAuthentication"] = 5] = "SentAuthentication";
+	    SocksClientState[SocksClientState["ReceivedAuthenticationResponse"] = 6] = "ReceivedAuthenticationResponse";
+	    SocksClientState[SocksClientState["SentFinalHandshake"] = 7] = "SentFinalHandshake";
+	    SocksClientState[SocksClientState["ReceivedFinalResponse"] = 8] = "ReceivedFinalResponse";
+	    SocksClientState[SocksClientState["BoundWaitingForConnection"] = 9] = "BoundWaitingForConnection";
+	    SocksClientState[SocksClientState["Established"] = 10] = "Established";
+	    SocksClientState[SocksClientState["Disconnected"] = 11] = "Disconnected";
+	    SocksClientState[SocksClientState["Error"] = 99] = "Error";
+	})(SocksClientState || (constants$2.SocksClientState = SocksClientState = {}));
+	
+	return constants$2;
+}
+
+var helpers$1 = {};
+
+var util = {};
+
+var hasRequiredUtil;
+
+function requireUtil () {
+	if (hasRequiredUtil) return util;
+	hasRequiredUtil = 1;
+	Object.defineProperty(util, "__esModule", { value: true });
+	util.shuffleArray = util.SocksClientError = void 0;
+	/**
+	 * Error wrapper for SocksClient
+	 */
+	class SocksClientError extends Error {
+	    constructor(message, options) {
+	        super(message);
+	        this.options = options;
+	    }
+	}
+	util.SocksClientError = SocksClientError;
+	/**
+	 * Shuffles a given array.
+	 * @param array The array to shuffle.
+	 */
+	function shuffleArray(array) {
+	    for (let i = array.length - 1; i > 0; i--) {
+	        const j = Math.floor(Math.random() * (i + 1));
+	        [array[i], array[j]] = [array[j], array[i]];
+	    }
+	}
+	util.shuffleArray = shuffleArray;
+	
+	return util;
+}
+
+var ipAddress = {};
+
+var ipv4 = {};
+
+var common = {};
+
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
+	Object.defineProperty(common, "__esModule", { value: true });
+	common.isInSubnet = isInSubnet;
+	common.isCorrect = isCorrect;
+	common.numberToPaddedHex = numberToPaddedHex;
+	common.stringToPaddedHex = stringToPaddedHex;
+	common.testBit = testBit;
+	function isInSubnet(address) {
+	    if (this.subnetMask < address.subnetMask) {
+	        return false;
+	    }
+	    if (this.mask(address.subnetMask) === address.mask()) {
+	        return true;
+	    }
+	    return false;
+	}
+	function isCorrect(defaultBits) {
+	    return function () {
+	        if (this.addressMinusSuffix !== this.correctForm()) {
+	            return false;
+	        }
+	        if (this.subnetMask === defaultBits && !this.parsedSubnet) {
+	            return true;
+	        }
+	        return this.parsedSubnet === String(this.subnetMask);
+	    };
+	}
+	function numberToPaddedHex(number) {
+	    return number.toString(16).padStart(2, '0');
+	}
+	function stringToPaddedHex(numberString) {
+	    return numberToPaddedHex(parseInt(numberString, 10));
+	}
+	/**
+	 * @param binaryValue Binary representation of a value (e.g. `10`)
+	 * @param position Byte position, where 0 is the least significant bit
+	 */
+	function testBit(binaryValue, position) {
+	    const { length } = binaryValue;
+	    if (position > length) {
+	        return false;
+	    }
+	    const positionInString = length - position;
+	    return binaryValue.substring(positionInString, positionInString + 1) === '1';
+	}
+	
+	return common;
+}
+
+var constants$1 = {};
+
+var hasRequiredConstants$1;
+
+function requireConstants$1 () {
+	if (hasRequiredConstants$1) return constants$1;
+	hasRequiredConstants$1 = 1;
+	Object.defineProperty(constants$1, "__esModule", { value: true });
+	constants$1.RE_SUBNET_STRING = constants$1.RE_ADDRESS = constants$1.GROUPS = constants$1.BITS = void 0;
+	constants$1.BITS = 32;
+	constants$1.GROUPS = 4;
+	constants$1.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g;
+	constants$1.RE_SUBNET_STRING = /\/\d{1,2}$/;
+	
+	return constants$1;
+}
+
+var addressError = {};
+
+var hasRequiredAddressError;
+
+function requireAddressError () {
+	if (hasRequiredAddressError) return addressError;
+	hasRequiredAddressError = 1;
+	Object.defineProperty(addressError, "__esModule", { value: true });
+	addressError.AddressError = void 0;
+	class AddressError extends Error {
+	    constructor(message, parseMessage) {
+	        super(message);
+	        this.name = 'AddressError';
+	        this.parseMessage = parseMessage;
+	    }
+	}
+	addressError.AddressError = AddressError;
+	
+	return addressError;
+}
+
+var hasRequiredIpv4;
+
+function requireIpv4 () {
+	if (hasRequiredIpv4) return ipv4;
+	hasRequiredIpv4 = 1;
+	/* eslint-disable no-param-reassign */
+	var __createBinding = (ipv4 && ipv4.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __setModuleDefault = (ipv4 && ipv4.__setModuleDefault) || (Object.create ? (function(o, v) {
+	    Object.defineProperty(o, "default", { enumerable: true, value: v });
+	}) : function(o, v) {
+	    o["default"] = v;
+	});
+	var __importStar = (ipv4 && ipv4.__importStar) || function (mod) {
+	    if (mod && mod.__esModule) return mod;
+	    var result = {};
+	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	    __setModuleDefault(result, mod);
+	    return result;
+	};
+	Object.defineProperty(ipv4, "__esModule", { value: true });
+	ipv4.Address4 = void 0;
+	const common = __importStar(requireCommon());
+	const constants = __importStar(requireConstants$1());
+	const address_error_1 = requireAddressError();
+	/**
+	 * Represents an IPv4 address
+	 * @class Address4
+	 * @param {string} address - An IPv4 address string
+	 */
+	class Address4 {
+	    constructor(address) {
+	        this.groups = constants.GROUPS;
+	        this.parsedAddress = [];
+	        this.parsedSubnet = '';
+	        this.subnet = '/32';
+	        this.subnetMask = 32;
+	        this.v4 = true;
+	        /**
+	         * Returns true if the address is correct, false otherwise
+	         * @memberof Address4
+	         * @instance
+	         * @returns {Boolean}
+	         */
+	        this.isCorrect = common.isCorrect(constants.BITS);
+	        /**
+	         * Returns true if the given address is in the subnet of the current address
+	         * @memberof Address4
+	         * @instance
+	         * @returns {boolean}
+	         */
+	        this.isInSubnet = common.isInSubnet;
+	        this.address = address;
+	        const subnet = constants.RE_SUBNET_STRING.exec(address);
+	        if (subnet) {
+	            this.parsedSubnet = subnet[0].replace('/', '');
+	            this.subnetMask = parseInt(this.parsedSubnet, 10);
+	            this.subnet = `/${this.subnetMask}`;
+	            if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {
+	                throw new address_error_1.AddressError('Invalid subnet mask.');
+	            }
+	            address = address.replace(constants.RE_SUBNET_STRING, '');
+	        }
+	        this.addressMinusSuffix = address;
+	        this.parsedAddress = this.parse(address);
+	    }
+	    static isValid(address) {
+	        try {
+	            // eslint-disable-next-line no-new
+	            new Address4(address);
+	            return true;
+	        }
+	        catch (e) {
+	            return false;
+	        }
+	    }
+	    /*
+	     * Parses a v4 address
+	     */
+	    parse(address) {
+	        const groups = address.split('.');
+	        if (!address.match(constants.RE_ADDRESS)) {
+	            throw new address_error_1.AddressError('Invalid IPv4 address.');
+	        }
+	        return groups;
+	    }
+	    /**
+	     * Returns the correct form of an address
+	     * @memberof Address4
+	     * @instance
+	     * @returns {String}
+	     */
+	    correctForm() {
+	        return this.parsedAddress.map((part) => parseInt(part, 10)).join('.');
+	    }
+	    /**
+	     * Converts a hex string to an IPv4 address object
+	     * @memberof Address4
+	     * @static
+	     * @param {string} hex - a hex string to convert
+	     * @returns {Address4}
+	     */
+	    static fromHex(hex) {
+	        const padded = hex.replace(/:/g, '').padStart(8, '0');
+	        const groups = [];
+	        let i;
+	        for (i = 0; i < 8; i += 2) {
+	            const h = padded.slice(i, i + 2);
+	            groups.push(parseInt(h, 16));
+	        }
+	        return new Address4(groups.join('.'));
+	    }
+	    /**
+	     * Converts an integer into a IPv4 address object
+	     * @memberof Address4
+	     * @static
+	     * @param {integer} integer - a number to convert
+	     * @returns {Address4}
+	     */
+	    static fromInteger(integer) {
+	        return Address4.fromHex(integer.toString(16));
+	    }
+	    /**
+	     * Return an address from in-addr.arpa form
+	     * @memberof Address4
+	     * @static
+	     * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address
+	     * @returns {Adress4}
+	     * @example
+	     * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.)
+	     * address.correctForm(); // '192.0.2.42'
+	     */
+	    static fromArpa(arpaFormAddress) {
+	        // remove ending ".in-addr.arpa." or just "."
+	        const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, '');
+	        const address = leader.split('.').reverse().join('.');
+	        return new Address4(address);
+	    }
+	    /**
+	     * Converts an IPv4 address object to a hex string
+	     * @memberof Address4
+	     * @instance
+	     * @returns {String}
+	     */
+	    toHex() {
+	        return this.parsedAddress.map((part) => common.stringToPaddedHex(part)).join(':');
+	    }
+	    /**
+	     * Converts an IPv4 address object to an array of bytes
+	     * @memberof Address4
+	     * @instance
+	     * @returns {Array}
+	     */
+	    toArray() {
+	        return this.parsedAddress.map((part) => parseInt(part, 10));
+	    }
+	    /**
+	     * Converts an IPv4 address object to an IPv6 address group
+	     * @memberof Address4
+	     * @instance
+	     * @returns {String}
+	     */
+	    toGroup6() {
+	        const output = [];
+	        let i;
+	        for (i = 0; i < constants.GROUPS; i += 2) {
+	            output.push(`${common.stringToPaddedHex(this.parsedAddress[i])}${common.stringToPaddedHex(this.parsedAddress[i + 1])}`);
+	        }
+	        return output.join(':');
+	    }
+	    /**
+	     * Returns the address as a `bigint`
+	     * @memberof Address4
+	     * @instance
+	     * @returns {bigint}
+	     */
+	    bigInt() {
+	        return BigInt(`0x${this.parsedAddress.map((n) => common.stringToPaddedHex(n)).join('')}`);
+	    }
+	    /**
+	     * Helper function getting start address.
+	     * @memberof Address4
+	     * @instance
+	     * @returns {bigint}
+	     */
+	    _startAddress() {
+	        return BigInt(`0b${this.mask() + '0'.repeat(constants.BITS - this.subnetMask)}`);
+	    }
+	    /**
+	     * The first address in the range given by this address' subnet.
+	     * Often referred to as the Network Address.
+	     * @memberof Address4
+	     * @instance
+	     * @returns {Address4}
+	     */
+	    startAddress() {
+	        return Address4.fromBigInt(this._startAddress());
+	    }
+	    /**
+	     * The first host address in the range given by this address's subnet ie
+	     * the first address after the Network Address
+	     * @memberof Address4
+	     * @instance
+	     * @returns {Address4}
+	     */
+	    startAddressExclusive() {
+	        const adjust = BigInt('1');
+	        return Address4.fromBigInt(this._startAddress() + adjust);
+	    }
+	    /**
+	     * Helper function getting end address.
+	     * @memberof Address4
+	     * @instance
+	     * @returns {bigint}
+	     */
+	    _endAddress() {
+	        return BigInt(`0b${this.mask() + '1'.repeat(constants.BITS - this.subnetMask)}`);
+	    }
+	    /**
+	     * The last address in the range given by this address' subnet
+	     * Often referred to as the Broadcast
+	     * @memberof Address4
+	     * @instance
+	     * @returns {Address4}
+	     */
+	    endAddress() {
+	        return Address4.fromBigInt(this._endAddress());
+	    }
+	    /**
+	     * The last host address in the range given by this address's subnet ie
+	     * the last address prior to the Broadcast Address
+	     * @memberof Address4
+	     * @instance
+	     * @returns {Address4}
+	     */
+	    endAddressExclusive() {
+	        const adjust = BigInt('1');
+	        return Address4.fromBigInt(this._endAddress() - adjust);
+	    }
+	    /**
+	     * Converts a BigInt to a v4 address object
+	     * @memberof Address4
+	     * @static
+	     * @param {bigint} bigInt - a BigInt to convert
+	     * @returns {Address4}
+	     */
+	    static fromBigInt(bigInt) {
+	        return Address4.fromHex(bigInt.toString(16));
+	    }
+	    /**
+	     * Convert a byte array to an Address4 object
+	     * @memberof Address4
+	     * @static
+	     * @param {Array<number>} bytes - an array of 4 bytes (0-255)
+	     * @returns {Address4}
+	     */
+	    static fromByteArray(bytes) {
+	        if (bytes.length !== 4) {
+	            throw new address_error_1.AddressError('IPv4 addresses require exactly 4 bytes');
+	        }
+	        // Validate that all bytes are within valid range (0-255)
+	        for (let i = 0; i < bytes.length; i++) {
+	            if (!Number.isInteger(bytes[i]) || bytes[i] < 0 || bytes[i] > 255) {
+	                throw new address_error_1.AddressError('All bytes must be integers between 0 and 255');
+	            }
+	        }
+	        return this.fromUnsignedByteArray(bytes);
+	    }
+	    /**
+	     * Convert an unsigned byte array to an Address4 object
+	     * @memberof Address4
+	     * @static
+	     * @param {Array<number>} bytes - an array of 4 unsigned bytes (0-255)
+	     * @returns {Address4}
+	     */
+	    static fromUnsignedByteArray(bytes) {
+	        if (bytes.length !== 4) {
+	            throw new address_error_1.AddressError('IPv4 addresses require exactly 4 bytes');
+	        }
+	        const address = bytes.join('.');
+	        return new Address4(address);
+	    }
+	    /**
+	     * Returns the first n bits of the address, defaulting to the
+	     * subnet mask
+	     * @memberof Address4
+	     * @instance
+	     * @returns {String}
+	     */
+	    mask(mask) {
+	        if (mask === undefined) {
+	            mask = this.subnetMask;
+	        }
+	        return this.getBitsBase2(0, mask);
+	    }
+	    /**
+	     * Returns the bits in the given range as a base-2 string
+	     * @memberof Address4
+	     * @instance
+	     * @returns {string}
+	     */
+	    getBitsBase2(start, end) {
+	        return this.binaryZeroPad().slice(start, end);
+	    }
+	    /**
+	     * Return the reversed ip6.arpa form of the address
+	     * @memberof Address4
+	     * @param {Object} options
+	     * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix
+	     * @instance
+	     * @returns {String}
+	     */
+	    reverseForm(options) {
+	        if (!options) {
+	            options = {};
+	        }
+	        const reversed = this.correctForm().split('.').reverse().join('.');
+	        if (options.omitSuffix) {
+	            return reversed;
+	        }
+	        return `${reversed}.in-addr.arpa.`;
+	    }
+	    /**
+	     * Returns true if the given address is a multicast address
+	     * @memberof Address4
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    isMulticast() {
+	        return this.isInSubnet(new Address4('224.0.0.0/4'));
+	    }
+	    /**
+	     * Returns a zero-padded base-2 string representation of the address
+	     * @memberof Address4
+	     * @instance
+	     * @returns {string}
+	     */
+	    binaryZeroPad() {
+	        return this.bigInt().toString(2).padStart(constants.BITS, '0');
+	    }
+	    /**
+	     * Groups an IPv4 address for inclusion at the end of an IPv6 address
+	     * @returns {String}
+	     */
+	    groupForV6() {
+	        const segments = this.parsedAddress;
+	        return this.address.replace(constants.RE_ADDRESS, `<span class="hover-group group-v4 group-6">${segments
+	            .slice(0, 2)
+	            .join('.')}</span>.<span class="hover-group group-v4 group-7">${segments
+	            .slice(2, 4)
+	            .join('.')}</span>`);
+	    }
+	}
+	ipv4.Address4 = Address4;
+	
+	return ipv4;
+}
+
+var ipv6 = {};
+
+var constants = {};
+
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+	Object.defineProperty(constants, "__esModule", { value: true });
+	constants.RE_URL_WITH_PORT = constants.RE_URL = constants.RE_ZONE_STRING = constants.RE_SUBNET_STRING = constants.RE_BAD_ADDRESS = constants.RE_BAD_CHARACTERS = constants.TYPES = constants.SCOPES = constants.GROUPS = constants.BITS = void 0;
+	constants.BITS = 128;
+	constants.GROUPS = 8;
+	/**
+	 * Represents IPv6 address scopes
+	 * @memberof Address6
+	 * @static
+	 */
+	constants.SCOPES = {
+	    0: 'Reserved',
+	    1: 'Interface local',
+	    2: 'Link local',
+	    4: 'Admin local',
+	    5: 'Site local',
+	    8: 'Organization local',
+	    14: 'Global',
+	    15: 'Reserved',
+	};
+	/**
+	 * Represents IPv6 address types
+	 * @memberof Address6
+	 * @static
+	 */
+	constants.TYPES = {
+	    'ff01::1/128': 'Multicast (All nodes on this interface)',
+	    'ff01::2/128': 'Multicast (All routers on this interface)',
+	    'ff02::1/128': 'Multicast (All nodes on this link)',
+	    'ff02::2/128': 'Multicast (All routers on this link)',
+	    'ff05::2/128': 'Multicast (All routers in this site)',
+	    'ff02::5/128': 'Multicast (OSPFv3 AllSPF routers)',
+	    'ff02::6/128': 'Multicast (OSPFv3 AllDR routers)',
+	    'ff02::9/128': 'Multicast (RIP routers)',
+	    'ff02::a/128': 'Multicast (EIGRP routers)',
+	    'ff02::d/128': 'Multicast (PIM routers)',
+	    'ff02::16/128': 'Multicast (MLDv2 reports)',
+	    'ff01::fb/128': 'Multicast (mDNSv6)',
+	    'ff02::fb/128': 'Multicast (mDNSv6)',
+	    'ff05::fb/128': 'Multicast (mDNSv6)',
+	    'ff02::1:2/128': 'Multicast (All DHCP servers and relay agents on this link)',
+	    'ff05::1:2/128': 'Multicast (All DHCP servers and relay agents in this site)',
+	    'ff02::1:3/128': 'Multicast (All DHCP servers on this link)',
+	    'ff05::1:3/128': 'Multicast (All DHCP servers in this site)',
+	    '::/128': 'Unspecified',
+	    '::1/128': 'Loopback',
+	    'ff00::/8': 'Multicast',
+	    'fe80::/10': 'Link-local unicast',
+	};
+	/**
+	 * A regular expression that matches bad characters in an IPv6 address
+	 * @memberof Address6
+	 * @static
+	 */
+	constants.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi;
+	/**
+	 * A regular expression that matches an incorrect IPv6 address
+	 * @memberof Address6
+	 * @static
+	 */
+	constants.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/gi;
+	/**
+	 * A regular expression that matches an IPv6 subnet
+	 * @memberof Address6
+	 * @static
+	 */
+	constants.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/;
+	/**
+	 * A regular expression that matches an IPv6 zone
+	 * @memberof Address6
+	 * @static
+	 */
+	constants.RE_ZONE_STRING = /%.*$/;
+	constants.RE_URL = /^\[{0,1}([0-9a-f:]+)\]{0,1}/;
+	constants.RE_URL_WITH_PORT = /\[([0-9a-f:]+)\]:([0-9]{1,5})/;
+	
+	return constants;
+}
+
+var helpers = {};
+
+var hasRequiredHelpers$1;
+
+function requireHelpers$1 () {
+	if (hasRequiredHelpers$1) return helpers;
+	hasRequiredHelpers$1 = 1;
+	Object.defineProperty(helpers, "__esModule", { value: true });
+	helpers.spanAllZeroes = spanAllZeroes;
+	helpers.spanAll = spanAll;
+	helpers.spanLeadingZeroes = spanLeadingZeroes;
+	helpers.simpleGroup = simpleGroup;
+	/**
+	 * @returns {String} the string with all zeroes contained in a <span>
+	 */
+	function spanAllZeroes(s) {
+	    return s.replace(/(0+)/g, '<span class="zero">$1</span>');
+	}
+	/**
+	 * @returns {String} the string with each character contained in a <span>
+	 */
+	function spanAll(s, offset = 0) {
+	    const letters = s.split('');
+	    return letters
+	        .map((n, i) => `<span class="digit value-${n} position-${i + offset}">${spanAllZeroes(n)}</span>`)
+	        .join('');
+	}
+	function spanLeadingZeroesSimple(group) {
+	    return group.replace(/^(0+)/, '<span class="zero">$1</span>');
+	}
+	/**
+	 * @returns {String} the string with leading zeroes contained in a <span>
+	 */
+	function spanLeadingZeroes(address) {
+	    const groups = address.split(':');
+	    return groups.map((g) => spanLeadingZeroesSimple(g)).join(':');
+	}
+	/**
+	 * Groups an address
+	 * @returns {String} a grouped address
+	 */
+	function simpleGroup(addressString, offset = 0) {
+	    const groups = addressString.split(':');
+	    return groups.map((g, i) => {
+	        if (/group-v4/.test(g)) {
+	            return g;
+	        }
+	        return `<span class="hover-group group-${i + offset}">${spanLeadingZeroesSimple(g)}</span>`;
+	    });
+	}
+	
+	return helpers;
+}
+
+var regularExpressions = {};
+
+var hasRequiredRegularExpressions;
+
+function requireRegularExpressions () {
+	if (hasRequiredRegularExpressions) return regularExpressions;
+	hasRequiredRegularExpressions = 1;
+	var __createBinding = (regularExpressions && regularExpressions.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __setModuleDefault = (regularExpressions && regularExpressions.__setModuleDefault) || (Object.create ? (function(o, v) {
+	    Object.defineProperty(o, "default", { enumerable: true, value: v });
+	}) : function(o, v) {
+	    o["default"] = v;
+	});
+	var __importStar = (regularExpressions && regularExpressions.__importStar) || function (mod) {
+	    if (mod && mod.__esModule) return mod;
+	    var result = {};
+	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	    __setModuleDefault(result, mod);
+	    return result;
+	};
+	Object.defineProperty(regularExpressions, "__esModule", { value: true });
+	regularExpressions.ADDRESS_BOUNDARY = void 0;
+	regularExpressions.groupPossibilities = groupPossibilities;
+	regularExpressions.padGroup = padGroup;
+	regularExpressions.simpleRegularExpression = simpleRegularExpression;
+	regularExpressions.possibleElisions = possibleElisions;
+	const v6 = __importStar(requireConstants());
+	function groupPossibilities(possibilities) {
+	    return `(${possibilities.join('|')})`;
+	}
+	function padGroup(group) {
+	    if (group.length < 4) {
+	        return `0{0,${4 - group.length}}${group}`;
+	    }
+	    return group;
+	}
+	regularExpressions.ADDRESS_BOUNDARY = '[^A-Fa-f0-9:]';
+	function simpleRegularExpression(groups) {
+	    const zeroIndexes = [];
+	    groups.forEach((group, i) => {
+	        const groupInteger = parseInt(group, 16);
+	        if (groupInteger === 0) {
+	            zeroIndexes.push(i);
+	        }
+	    });
+	    // You can technically elide a single 0, this creates the regular expressions
+	    // to match that eventuality
+	    const possibilities = zeroIndexes.map((zeroIndex) => groups
+	        .map((group, i) => {
+	        if (i === zeroIndex) {
+	            const elision = i === 0 || i === v6.GROUPS - 1 ? ':' : '';
+	            return groupPossibilities([padGroup(group), elision]);
+	        }
+	        return padGroup(group);
+	    })
+	        .join(':'));
+	    // The simplest case
+	    possibilities.push(groups.map(padGroup).join(':'));
+	    return groupPossibilities(possibilities);
+	}
+	function possibleElisions(elidedGroups, moreLeft, moreRight) {
+	    const left = moreLeft ? '' : ':';
+	    const right = moreRight ? '' : ':';
+	    const possibilities = [];
+	    // 1. elision of everything (::)
+	    if (!moreLeft && !moreRight) {
+	        possibilities.push('::');
+	    }
+	    // 2. complete elision of the middle
+	    if (moreLeft && moreRight) {
+	        possibilities.push('');
+	    }
+	    if ((moreRight && !moreLeft) || (!moreRight && moreLeft)) {
+	        // 3. complete elision of one side
+	        possibilities.push(':');
+	    }
+	    // 4. elision from the left side
+	    possibilities.push(`${left}(:0{1,4}){1,${elidedGroups - 1}}`);
+	    // 5. elision from the right side
+	    possibilities.push(`(0{1,4}:){1,${elidedGroups - 1}}${right}`);
+	    // 6. no elision
+	    possibilities.push(`(0{1,4}:){${elidedGroups - 1}}0{1,4}`);
+	    // 7. elision (including sloppy elision) from the middle
+	    for (let groups = 1; groups < elidedGroups - 1; groups++) {
+	        for (let position = 1; position < elidedGroups - groups; position++) {
+	            possibilities.push(`(0{1,4}:){${position}}:(0{1,4}:){${elidedGroups - position - groups - 1}}0{1,4}`);
+	        }
+	    }
+	    return groupPossibilities(possibilities);
+	}
+	
+	return regularExpressions;
+}
+
+var hasRequiredIpv6;
+
+function requireIpv6 () {
+	if (hasRequiredIpv6) return ipv6;
+	hasRequiredIpv6 = 1;
+	/* eslint-disable prefer-destructuring */
+	/* eslint-disable no-param-reassign */
+	var __createBinding = (ipv6 && ipv6.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __setModuleDefault = (ipv6 && ipv6.__setModuleDefault) || (Object.create ? (function(o, v) {
+	    Object.defineProperty(o, "default", { enumerable: true, value: v });
+	}) : function(o, v) {
+	    o["default"] = v;
+	});
+	var __importStar = (ipv6 && ipv6.__importStar) || function (mod) {
+	    if (mod && mod.__esModule) return mod;
+	    var result = {};
+	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	    __setModuleDefault(result, mod);
+	    return result;
+	};
+	Object.defineProperty(ipv6, "__esModule", { value: true });
+	ipv6.Address6 = void 0;
+	const common = __importStar(requireCommon());
+	const constants4 = __importStar(requireConstants$1());
+	const constants6 = __importStar(requireConstants());
+	const helpers = __importStar(requireHelpers$1());
+	const ipv4_1 = requireIpv4();
+	const regular_expressions_1 = requireRegularExpressions();
+	const address_error_1 = requireAddressError();
+	const common_1 = requireCommon();
+	function assert(condition) {
+	    if (!condition) {
+	        throw new Error('Assertion failed.');
+	    }
+	}
+	function addCommas(number) {
+	    const r = /(\d+)(\d{3})/;
+	    while (r.test(number)) {
+	        number = number.replace(r, '$1,$2');
+	    }
+	    return number;
+	}
+	function spanLeadingZeroes4(n) {
+	    n = n.replace(/^(0{1,})([1-9]+)$/, '<span class="parse-error">$1</span>$2');
+	    n = n.replace(/^(0{1,})(0)$/, '<span class="parse-error">$1</span>$2');
+	    return n;
+	}
+	/*
+	 * A helper function to compact an array
+	 */
+	function compact(address, slice) {
+	    const s1 = [];
+	    const s2 = [];
+	    let i;
+	    for (i = 0; i < address.length; i++) {
+	        if (i < slice[0]) {
+	            s1.push(address[i]);
+	        }
+	        else if (i > slice[1]) {
+	            s2.push(address[i]);
+	        }
+	    }
+	    return s1.concat(['compact']).concat(s2);
+	}
+	function paddedHex(octet) {
+	    return parseInt(octet, 16).toString(16).padStart(4, '0');
+	}
+	function unsignByte(b) {
+	    // eslint-disable-next-line no-bitwise
+	    return b & 0xff;
+	}
+	/**
+	 * Represents an IPv6 address
+	 * @class Address6
+	 * @param {string} address - An IPv6 address string
+	 * @param {number} [groups=8] - How many octets to parse
+	 * @example
+	 * var address = new Address6('2001::/32');
+	 */
+	class Address6 {
+	    constructor(address, optionalGroups) {
+	        this.addressMinusSuffix = '';
+	        this.parsedSubnet = '';
+	        this.subnet = '/128';
+	        this.subnetMask = 128;
+	        this.v4 = false;
+	        this.zone = '';
+	        // #region Attributes
+	        /**
+	         * Returns true if the given address is in the subnet of the current address
+	         * @memberof Address6
+	         * @instance
+	         * @returns {boolean}
+	         */
+	        this.isInSubnet = common.isInSubnet;
+	        /**
+	         * Returns true if the address is correct, false otherwise
+	         * @memberof Address6
+	         * @instance
+	         * @returns {boolean}
+	         */
+	        this.isCorrect = common.isCorrect(constants6.BITS);
+	        if (optionalGroups === undefined) {
+	            this.groups = constants6.GROUPS;
+	        }
+	        else {
+	            this.groups = optionalGroups;
+	        }
+	        this.address = address;
+	        const subnet = constants6.RE_SUBNET_STRING.exec(address);
+	        if (subnet) {
+	            this.parsedSubnet = subnet[0].replace('/', '');
+	            this.subnetMask = parseInt(this.parsedSubnet, 10);
+	            this.subnet = `/${this.subnetMask}`;
+	            if (Number.isNaN(this.subnetMask) ||
+	                this.subnetMask < 0 ||
+	                this.subnetMask > constants6.BITS) {
+	                throw new address_error_1.AddressError('Invalid subnet mask.');
+	            }
+	            address = address.replace(constants6.RE_SUBNET_STRING, '');
+	        }
+	        else if (/\//.test(address)) {
+	            throw new address_error_1.AddressError('Invalid subnet mask.');
+	        }
+	        const zone = constants6.RE_ZONE_STRING.exec(address);
+	        if (zone) {
+	            this.zone = zone[0];
+	            address = address.replace(constants6.RE_ZONE_STRING, '');
+	        }
+	        this.addressMinusSuffix = address;
+	        this.parsedAddress = this.parse(this.addressMinusSuffix);
+	    }
+	    static isValid(address) {
+	        try {
+	            // eslint-disable-next-line no-new
+	            new Address6(address);
+	            return true;
+	        }
+	        catch (e) {
+	            return false;
+	        }
+	    }
+	    /**
+	     * Convert a BigInt to a v6 address object
+	     * @memberof Address6
+	     * @static
+	     * @param {bigint} bigInt - a BigInt to convert
+	     * @returns {Address6}
+	     * @example
+	     * var bigInt = BigInt('1000000000000');
+	     * var address = Address6.fromBigInt(bigInt);
+	     * address.correctForm(); // '::e8:d4a5:1000'
+	     */
+	    static fromBigInt(bigInt) {
+	        const hex = bigInt.toString(16).padStart(32, '0');
+	        const groups = [];
+	        let i;
+	        for (i = 0; i < constants6.GROUPS; i++) {
+	            groups.push(hex.slice(i * 4, (i + 1) * 4));
+	        }
+	        return new Address6(groups.join(':'));
+	    }
+	    /**
+	     * Convert a URL (with optional port number) to an address object
+	     * @memberof Address6
+	     * @static
+	     * @param {string} url - a URL with optional port number
+	     * @example
+	     * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');
+	     * addressAndPort.address.correctForm(); // 'ffff::'
+	     * addressAndPort.port; // 8080
+	     */
+	    static fromURL(url) {
+	        let host;
+	        let port = null;
+	        let result;
+	        // If we have brackets parse them and find a port
+	        if (url.indexOf('[') !== -1 && url.indexOf(']:') !== -1) {
+	            result = constants6.RE_URL_WITH_PORT.exec(url);
+	            if (result === null) {
+	                return {
+	                    error: 'failed to parse address with port',
+	                    address: null,
+	                    port: null,
+	                };
+	            }
+	            host = result[1];
+	            port = result[2];
+	            // If there's a URL extract the address
+	        }
+	        else if (url.indexOf('/') !== -1) {
+	            // Remove the protocol prefix
+	            url = url.replace(/^[a-z0-9]+:\/\//, '');
+	            // Parse the address
+	            result = constants6.RE_URL.exec(url);
+	            if (result === null) {
+	                return {
+	                    error: 'failed to parse address from URL',
+	                    address: null,
+	                    port: null,
+	                };
+	            }
+	            host = result[1];
+	            // Otherwise just assign the URL to the host and let the library parse it
+	        }
+	        else {
+	            host = url;
+	        }
+	        // If there's a port convert it to an integer
+	        if (port) {
+	            port = parseInt(port, 10);
+	            // squelch out of range ports
+	            if (port < 0 || port > 65536) {
+	                port = null;
+	            }
+	        }
+	        else {
+	            // Standardize `undefined` to `null`
+	            port = null;
+	        }
+	        return {
+	            address: new Address6(host),
+	            port,
+	        };
+	    }
+	    /**
+	     * Create an IPv6-mapped address given an IPv4 address
+	     * @memberof Address6
+	     * @static
+	     * @param {string} address - An IPv4 address string
+	     * @returns {Address6}
+	     * @example
+	     * var address = Address6.fromAddress4('192.168.0.1');
+	     * address.correctForm(); // '::ffff:c0a8:1'
+	     * address.to4in6(); // '::ffff:192.168.0.1'
+	     */
+	    static fromAddress4(address) {
+	        const address4 = new ipv4_1.Address4(address);
+	        const mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask);
+	        return new Address6(`::ffff:${address4.correctForm()}/${mask6}`);
+	    }
+	    /**
+	     * Return an address from ip6.arpa form
+	     * @memberof Address6
+	     * @static
+	     * @param {string} arpaFormAddress - an 'ip6.arpa' form address
+	     * @returns {Adress6}
+	     * @example
+	     * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.)
+	     * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe'
+	     */
+	    static fromArpa(arpaFormAddress) {
+	        // remove ending ".ip6.arpa." or just "."
+	        let address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, '');
+	        const semicolonAmount = 7;
+	        // correct ip6.arpa form with ending removed will be 63 characters
+	        if (address.length !== 63) {
+	            throw new address_error_1.AddressError("Invalid 'ip6.arpa' form.");
+	        }
+	        const parts = address.split('.').reverse();
+	        for (let i = semicolonAmount; i > 0; i--) {
+	            const insertIndex = i * 4;
+	            parts.splice(insertIndex, 0, ':');
+	        }
+	        address = parts.join('');
+	        return new Address6(address);
+	    }
+	    /**
+	     * Return the Microsoft UNC transcription of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String} the Microsoft UNC transcription of the address
+	     */
+	    microsoftTranscription() {
+	        return `${this.correctForm().replace(/:/g, '-')}.ipv6-literal.net`;
+	    }
+	    /**
+	     * Return the first n bits of the address, defaulting to the subnet mask
+	     * @memberof Address6
+	     * @instance
+	     * @param {number} [mask=subnet] - the number of bits to mask
+	     * @returns {String} the first n bits of the address as a string
+	     */
+	    mask(mask = this.subnetMask) {
+	        return this.getBitsBase2(0, mask);
+	    }
+	    /**
+	     * Return the number of possible subnets of a given size in the address
+	     * @memberof Address6
+	     * @instance
+	     * @param {number} [subnetSize=128] - the subnet size
+	     * @returns {String}
+	     */
+	    // TODO: probably useful to have a numeric version of this too
+	    possibleSubnets(subnetSize = 128) {
+	        const availableBits = constants6.BITS - this.subnetMask;
+	        const subnetBits = Math.abs(subnetSize - constants6.BITS);
+	        const subnetPowers = availableBits - subnetBits;
+	        if (subnetPowers < 0) {
+	            return '0';
+	        }
+	        return addCommas((BigInt('2') ** BigInt(subnetPowers)).toString(10));
+	    }
+	    /**
+	     * Helper function getting start address.
+	     * @memberof Address6
+	     * @instance
+	     * @returns {bigint}
+	     */
+	    _startAddress() {
+	        return BigInt(`0b${this.mask() + '0'.repeat(constants6.BITS - this.subnetMask)}`);
+	    }
+	    /**
+	     * The first address in the range given by this address' subnet
+	     * Often referred to as the Network Address.
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Address6}
+	     */
+	    startAddress() {
+	        return Address6.fromBigInt(this._startAddress());
+	    }
+	    /**
+	     * The first host address in the range given by this address's subnet ie
+	     * the first address after the Network Address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Address6}
+	     */
+	    startAddressExclusive() {
+	        const adjust = BigInt('1');
+	        return Address6.fromBigInt(this._startAddress() + adjust);
+	    }
+	    /**
+	     * Helper function getting end address.
+	     * @memberof Address6
+	     * @instance
+	     * @returns {bigint}
+	     */
+	    _endAddress() {
+	        return BigInt(`0b${this.mask() + '1'.repeat(constants6.BITS - this.subnetMask)}`);
+	    }
+	    /**
+	     * The last address in the range given by this address' subnet
+	     * Often referred to as the Broadcast
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Address6}
+	     */
+	    endAddress() {
+	        return Address6.fromBigInt(this._endAddress());
+	    }
+	    /**
+	     * The last host address in the range given by this address's subnet ie
+	     * the last address prior to the Broadcast Address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Address6}
+	     */
+	    endAddressExclusive() {
+	        const adjust = BigInt('1');
+	        return Address6.fromBigInt(this._endAddress() - adjust);
+	    }
+	    /**
+	     * Return the scope of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    getScope() {
+	        let scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)];
+	        if (this.getType() === 'Global unicast' && scope !== 'Link local') {
+	            scope = 'Global';
+	        }
+	        return scope || 'Unknown';
+	    }
+	    /**
+	     * Return the type of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    getType() {
+	        for (const subnet of Object.keys(constants6.TYPES)) {
+	            if (this.isInSubnet(new Address6(subnet))) {
+	                return constants6.TYPES[subnet];
+	            }
+	        }
+	        return 'Global unicast';
+	    }
+	    /**
+	     * Return the bits in the given range as a BigInt
+	     * @memberof Address6
+	     * @instance
+	     * @returns {bigint}
+	     */
+	    getBits(start, end) {
+	        return BigInt(`0b${this.getBitsBase2(start, end)}`);
+	    }
+	    /**
+	     * Return the bits in the given range as a base-2 string
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    getBitsBase2(start, end) {
+	        return this.binaryZeroPad().slice(start, end);
+	    }
+	    /**
+	     * Return the bits in the given range as a base-16 string
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    getBitsBase16(start, end) {
+	        const length = end - start;
+	        if (length % 4 !== 0) {
+	            throw new Error('Length of bits to retrieve must be divisible by four');
+	        }
+	        return this.getBits(start, end)
+	            .toString(16)
+	            .padStart(length / 4, '0');
+	    }
+	    /**
+	     * Return the bits that are set past the subnet mask length
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    getBitsPastSubnet() {
+	        return this.getBitsBase2(this.subnetMask, constants6.BITS);
+	    }
+	    /**
+	     * Return the reversed ip6.arpa form of the address
+	     * @memberof Address6
+	     * @param {Object} options
+	     * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix
+	     * @instance
+	     * @returns {String}
+	     */
+	    reverseForm(options) {
+	        if (!options) {
+	            options = {};
+	        }
+	        const characters = Math.floor(this.subnetMask / 4);
+	        const reversed = this.canonicalForm()
+	            .replace(/:/g, '')
+	            .split('')
+	            .slice(0, characters)
+	            .reverse()
+	            .join('.');
+	        if (characters > 0) {
+	            if (options.omitSuffix) {
+	                return reversed;
+	            }
+	            return `${reversed}.ip6.arpa.`;
+	        }
+	        if (options.omitSuffix) {
+	            return '';
+	        }
+	        return 'ip6.arpa.';
+	    }
+	    /**
+	     * Return the correct form of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    correctForm() {
+	        let i;
+	        let groups = [];
+	        let zeroCounter = 0;
+	        const zeroes = [];
+	        for (i = 0; i < this.parsedAddress.length; i++) {
+	            const value = parseInt(this.parsedAddress[i], 16);
+	            if (value === 0) {
+	                zeroCounter++;
+	            }
+	            if (value !== 0 && zeroCounter > 0) {
+	                if (zeroCounter > 1) {
+	                    zeroes.push([i - zeroCounter, i - 1]);
+	                }
+	                zeroCounter = 0;
+	            }
+	        }
+	        // Do we end with a string of zeroes?
+	        if (zeroCounter > 1) {
+	            zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]);
+	        }
+	        const zeroLengths = zeroes.map((n) => n[1] - n[0] + 1);
+	        if (zeroes.length > 0) {
+	            const index = zeroLengths.indexOf(Math.max(...zeroLengths));
+	            groups = compact(this.parsedAddress, zeroes[index]);
+	        }
+	        else {
+	            groups = this.parsedAddress;
+	        }
+	        for (i = 0; i < groups.length; i++) {
+	            if (groups[i] !== 'compact') {
+	                groups[i] = parseInt(groups[i], 16).toString(16);
+	            }
+	        }
+	        let correct = groups.join(':');
+	        correct = correct.replace(/^compact$/, '::');
+	        correct = correct.replace(/(^compact)|(compact$)/, ':');
+	        correct = correct.replace(/compact/, '');
+	        return correct;
+	    }
+	    /**
+	     * Return a zero-padded base-2 string representation of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     * @example
+	     * var address = new Address6('2001:4860:4001:803::1011');
+	     * address.binaryZeroPad();
+	     * // '0010000000000001010010000110000001000000000000010000100000000011
+	     * //  0000000000000000000000000000000000000000000000000001000000010001'
+	     */
+	    binaryZeroPad() {
+	        return this.bigInt().toString(2).padStart(constants6.BITS, '0');
+	    }
+	    // TODO: Improve the semantics of this helper function
+	    parse4in6(address) {
+	        const groups = address.split(':');
+	        const lastGroup = groups.slice(-1)[0];
+	        const address4 = lastGroup.match(constants4.RE_ADDRESS);
+	        if (address4) {
+	            this.parsedAddress4 = address4[0];
+	            this.address4 = new ipv4_1.Address4(this.parsedAddress4);
+	            for (let i = 0; i < this.address4.groups; i++) {
+	                if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) {
+	                    throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join('.')));
+	                }
+	            }
+	            this.v4 = true;
+	            groups[groups.length - 1] = this.address4.toGroup6();
+	            address = groups.join(':');
+	        }
+	        return address;
+	    }
+	    // TODO: Make private?
+	    parse(address) {
+	        address = this.parse4in6(address);
+	        const badCharacters = address.match(constants6.RE_BAD_CHARACTERS);
+	        if (badCharacters) {
+	            throw new address_error_1.AddressError(`Bad character${badCharacters.length > 1 ? 's' : ''} detected in address: ${badCharacters.join('')}`, address.replace(constants6.RE_BAD_CHARACTERS, '<span class="parse-error">$1</span>'));
+	        }
+	        const badAddress = address.match(constants6.RE_BAD_ADDRESS);
+	        if (badAddress) {
+	            throw new address_error_1.AddressError(`Address failed regex: ${badAddress.join('')}`, address.replace(constants6.RE_BAD_ADDRESS, '<span class="parse-error">$1</span>'));
+	        }
+	        let groups = [];
+	        const halves = address.split('::');
+	        if (halves.length === 2) {
+	            let first = halves[0].split(':');
+	            let last = halves[1].split(':');
+	            if (first.length === 1 && first[0] === '') {
+	                first = [];
+	            }
+	            if (last.length === 1 && last[0] === '') {
+	                last = [];
+	            }
+	            const remaining = this.groups - (first.length + last.length);
+	            if (!remaining) {
+	                throw new address_error_1.AddressError('Error parsing groups');
+	            }
+	            this.elidedGroups = remaining;
+	            this.elisionBegin = first.length;
+	            this.elisionEnd = first.length + this.elidedGroups;
+	            groups = groups.concat(first);
+	            for (let i = 0; i < remaining; i++) {
+	                groups.push('0');
+	            }
+	            groups = groups.concat(last);
+	        }
+	        else if (halves.length === 1) {
+	            groups = address.split(':');
+	            this.elidedGroups = 0;
+	        }
+	        else {
+	            throw new address_error_1.AddressError('Too many :: groups found');
+	        }
+	        groups = groups.map((group) => parseInt(group, 16).toString(16));
+	        if (groups.length !== this.groups) {
+	            throw new address_error_1.AddressError('Incorrect number of groups found');
+	        }
+	        return groups;
+	    }
+	    /**
+	     * Return the canonical form of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    canonicalForm() {
+	        return this.parsedAddress.map(paddedHex).join(':');
+	    }
+	    /**
+	     * Return the decimal form of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    decimal() {
+	        return this.parsedAddress.map((n) => parseInt(n, 16).toString(10).padStart(5, '0')).join(':');
+	    }
+	    /**
+	     * Return the address as a BigInt
+	     * @memberof Address6
+	     * @instance
+	     * @returns {bigint}
+	     */
+	    bigInt() {
+	        return BigInt(`0x${this.parsedAddress.map(paddedHex).join('')}`);
+	    }
+	    /**
+	     * Return the last two groups of this address as an IPv4 address string
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Address4}
+	     * @example
+	     * var address = new Address6('2001:4860:4001::1825:bf11');
+	     * address.to4().correctForm(); // '24.37.191.17'
+	     */
+	    to4() {
+	        const binary = this.binaryZeroPad().split('');
+	        return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join('')}`).toString(16));
+	    }
+	    /**
+	     * Return the v4-in-v6 form of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {String}
+	     */
+	    to4in6() {
+	        const address4 = this.to4();
+	        const address6 = new Address6(this.parsedAddress.slice(0, 6).join(':'), 6);
+	        const correct = address6.correctForm();
+	        let infix = '';
+	        if (!/:$/.test(correct)) {
+	            infix = ':';
+	        }
+	        return correct + infix + address4.address;
+	    }
+	    /**
+	     * Return an object containing the Teredo properties of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Object}
+	     */
+	    inspectTeredo() {
+	        /*
+	        - Bits 0 to 31 are set to the Teredo prefix (normally 2001:0000::/32).
+	        - Bits 32 to 63 embed the primary IPv4 address of the Teredo server that
+	          is used.
+	        - Bits 64 to 79 can be used to define some flags. Currently only the
+	          higher order bit is used; it is set to 1 if the Teredo client is
+	          located behind a cone NAT, 0 otherwise. For Microsoft's Windows Vista
+	          and Windows Server 2008 implementations, more bits are used. In those
+	          implementations, the format for these 16 bits is "CRAAAAUG AAAAAAAA",
+	          where "C" remains the "Cone" flag. The "R" bit is reserved for future
+	          use. The "U" bit is for the Universal/Local flag (set to 0). The "G" bit
+	          is Individual/Group flag (set to 0). The A bits are set to a 12-bit
+	          randomly generated number chosen by the Teredo client to introduce
+	          additional protection for the Teredo node against IPv6-based scanning
+	          attacks.
+	        - Bits 80 to 95 contains the obfuscated UDP port number. This is the
+	          port number that is mapped by the NAT to the Teredo client with all
+	          bits inverted.
+	        - Bits 96 to 127 contains the obfuscated IPv4 address. This is the
+	          public IPv4 address of the NAT with all bits inverted.
+	        */
+	        const prefix = this.getBitsBase16(0, 32);
+	        const bitsForUdpPort = this.getBits(80, 96);
+	        // eslint-disable-next-line no-bitwise
+	        const udpPort = (bitsForUdpPort ^ BigInt('0xffff')).toString();
+	        const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64));
+	        const bitsForClient4 = this.getBits(96, 128);
+	        // eslint-disable-next-line no-bitwise
+	        const client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt('0xffffffff')).toString(16));
+	        const flagsBase2 = this.getBitsBase2(64, 80);
+	        const coneNat = (0, common_1.testBit)(flagsBase2, 15);
+	        const reserved = (0, common_1.testBit)(flagsBase2, 14);
+	        const groupIndividual = (0, common_1.testBit)(flagsBase2, 8);
+	        const universalLocal = (0, common_1.testBit)(flagsBase2, 9);
+	        const nonce = BigInt(`0b${flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16)}`).toString(10);
+	        return {
+	            prefix: `${prefix.slice(0, 4)}:${prefix.slice(4, 8)}`,
+	            server4: server4.address,
+	            client4: client4.address,
+	            flags: flagsBase2,
+	            coneNat,
+	            microsoft: {
+	                reserved,
+	                universalLocal,
+	                groupIndividual,
+	                nonce,
+	            },
+	            udpPort,
+	        };
+	    }
+	    /**
+	     * Return an object containing the 6to4 properties of the address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Object}
+	     */
+	    inspect6to4() {
+	        /*
+	        - Bits 0 to 15 are set to the 6to4 prefix (2002::/16).
+	        - Bits 16 to 48 embed the IPv4 address of the 6to4 gateway that is used.
+	        */
+	        const prefix = this.getBitsBase16(0, 16);
+	        const gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48));
+	        return {
+	            prefix: prefix.slice(0, 4),
+	            gateway: gateway.address,
+	        };
+	    }
+	    /**
+	     * Return a v6 6to4 address from a v6 v4inv6 address
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Address6}
+	     */
+	    to6to4() {
+	        if (!this.is4()) {
+	            return null;
+	        }
+	        const addr6to4 = [
+	            '2002',
+	            this.getBitsBase16(96, 112),
+	            this.getBitsBase16(112, 128),
+	            '',
+	            '/16',
+	        ].join(':');
+	        return new Address6(addr6to4);
+	    }
+	    /**
+	     * Return a byte array
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Array}
+	     */
+	    toByteArray() {
+	        const valueWithoutPadding = this.bigInt().toString(16);
+	        const leadingPad = '0'.repeat(valueWithoutPadding.length % 2);
+	        const value = `${leadingPad}${valueWithoutPadding}`;
+	        const bytes = [];
+	        for (let i = 0, length = value.length; i < length; i += 2) {
+	            bytes.push(parseInt(value.substring(i, i + 2), 16));
+	        }
+	        return bytes;
+	    }
+	    /**
+	     * Return an unsigned byte array
+	     * @memberof Address6
+	     * @instance
+	     * @returns {Array}
+	     */
+	    toUnsignedByteArray() {
+	        return this.toByteArray().map(unsignByte);
+	    }
+	    /**
+	     * Convert a byte array to an Address6 object
+	     * @memberof Address6
+	     * @static
+	     * @returns {Address6}
+	     */
+	    static fromByteArray(bytes) {
+	        return this.fromUnsignedByteArray(bytes.map(unsignByte));
+	    }
+	    /**
+	     * Convert an unsigned byte array to an Address6 object
+	     * @memberof Address6
+	     * @static
+	     * @returns {Address6}
+	     */
+	    static fromUnsignedByteArray(bytes) {
+	        const BYTE_MAX = BigInt('256');
+	        let result = BigInt('0');
+	        let multiplier = BigInt('1');
+	        for (let i = bytes.length - 1; i >= 0; i--) {
+	            result += multiplier * BigInt(bytes[i].toString(10));
+	            multiplier *= BYTE_MAX;
+	        }
+	        return Address6.fromBigInt(result);
+	    }
+	    /**
+	     * Returns true if the address is in the canonical form, false otherwise
+	     * @memberof Address6
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    isCanonical() {
+	        return this.addressMinusSuffix === this.canonicalForm();
+	    }
+	    /**
+	     * Returns true if the address is a link local address, false otherwise
+	     * @memberof Address6
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    isLinkLocal() {
+	        // Zeroes are required, i.e. we can't check isInSubnet with 'fe80::/10'
+	        if (this.getBitsBase2(0, 64) ===
+	            '1111111010000000000000000000000000000000000000000000000000000000') {
+	            return true;
+	        }
+	        return false;
+	    }
+	    /**
+	     * Returns true if the address is a multicast address, false otherwise
+	     * @memberof Address6
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    isMulticast() {
+	        return this.getType() === 'Multicast';
+	    }
+	    /**
+	     * Returns true if the address is a v4-in-v6 address, false otherwise
+	     * @memberof Address6
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    is4() {
+	        return this.v4;
+	    }
+	    /**
+	     * Returns true if the address is a Teredo address, false otherwise
+	     * @memberof Address6
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    isTeredo() {
+	        return this.isInSubnet(new Address6('2001::/32'));
+	    }
+	    /**
+	     * Returns true if the address is a 6to4 address, false otherwise
+	     * @memberof Address6
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    is6to4() {
+	        return this.isInSubnet(new Address6('2002::/16'));
+	    }
+	    /**
+	     * Returns true if the address is a loopback address, false otherwise
+	     * @memberof Address6
+	     * @instance
+	     * @returns {boolean}
+	     */
+	    isLoopback() {
+	        return this.getType() === 'Loopback';
+	    }
+	    // #endregion
+	    // #region HTML
+	    /**
+	     * @returns {String} the address in link form with a default port of 80
+	     */
+	    href(optionalPort) {
+	        if (optionalPort === undefined) {
+	            optionalPort = '';
+	        }
+	        else {
+	            optionalPort = `:${optionalPort}`;
+	        }
+	        return `http://[${this.correctForm()}]${optionalPort}/`;
+	    }
+	    /**
+	     * @returns {String} a link suitable for conveying the address via a URL hash
+	     */
+	    link(options) {
+	        if (!options) {
+	            options = {};
+	        }
+	        if (options.className === undefined) {
+	            options.className = '';
+	        }
+	        if (options.prefix === undefined) {
+	            options.prefix = '/#address=';
+	        }
+	        if (options.v4 === undefined) {
+	            options.v4 = false;
+	        }
+	        let formFunction = this.correctForm;
+	        if (options.v4) {
+	            formFunction = this.to4in6;
+	        }
+	        const form = formFunction.call(this);
+	        if (options.className) {
+	            return `<a href="${options.prefix}${form}" class="${options.className}">${form}</a>`;
+	        }
+	        return `<a href="${options.prefix}${form}">${form}</a>`;
+	    }
+	    /**
+	     * Groups an address
+	     * @returns {String}
+	     */
+	    group() {
+	        if (this.elidedGroups === 0) {
+	            // The simple case
+	            return helpers.simpleGroup(this.address).join(':');
+	        }
+	        assert(typeof this.elidedGroups === 'number');
+	        assert(typeof this.elisionBegin === 'number');
+	        // The elided case
+	        const output = [];
+	        const [left, right] = this.address.split('::');
+	        if (left.length) {
+	            output.push(...helpers.simpleGroup(left));
+	        }
+	        else {
+	            output.push('');
+	        }
+	        const classes = ['hover-group'];
+	        for (let i = this.elisionBegin; i < this.elisionBegin + this.elidedGroups; i++) {
+	            classes.push(`group-${i}`);
+	        }
+	        output.push(`<span class="${classes.join(' ')}"></span>`);
+	        if (right.length) {
+	            output.push(...helpers.simpleGroup(right, this.elisionEnd));
+	        }
+	        else {
+	            output.push('');
+	        }
+	        if (this.is4()) {
+	            assert(this.address4 instanceof ipv4_1.Address4);
+	            output.pop();
+	            output.push(this.address4.groupForV6());
+	        }
+	        return output.join(':');
+	    }
+	    // #endregion
+	    // #region Regular expressions
+	    /**
+	     * Generate a regular expression string that can be used to find or validate
+	     * all variations of this address
+	     * @memberof Address6
+	     * @instance
+	     * @param {boolean} substringSearch
+	     * @returns {string}
+	     */
+	    regularExpressionString(substringSearch = false) {
+	        let output = [];
+	        // TODO: revisit why this is necessary
+	        const address6 = new Address6(this.correctForm());
+	        if (address6.elidedGroups === 0) {
+	            // The simple case
+	            output.push((0, regular_expressions_1.simpleRegularExpression)(address6.parsedAddress));
+	        }
+	        else if (address6.elidedGroups === constants6.GROUPS) {
+	            // A completely elided address
+	            output.push((0, regular_expressions_1.possibleElisions)(constants6.GROUPS));
+	        }
+	        else {
+	            // A partially elided address
+	            const halves = address6.address.split('::');
+	            if (halves[0].length) {
+	                output.push((0, regular_expressions_1.simpleRegularExpression)(halves[0].split(':')));
+	            }
+	            assert(typeof address6.elidedGroups === 'number');
+	            output.push((0, regular_expressions_1.possibleElisions)(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0));
+	            if (halves[1].length) {
+	                output.push((0, regular_expressions_1.simpleRegularExpression)(halves[1].split(':')));
+	            }
+	            output = [output.join(':')];
+	        }
+	        if (!substringSearch) {
+	            output = [
+	                '(?=^|',
+	                regular_expressions_1.ADDRESS_BOUNDARY,
+	                '|[^\\w\\:])(',
+	                ...output,
+	                ')(?=[^\\w\\:]|',
+	                regular_expressions_1.ADDRESS_BOUNDARY,
+	                '|$)',
+	            ];
+	        }
+	        return output.join('');
+	    }
+	    /**
+	     * Generate a regular expression that can be used to find or validate all
+	     * variations of this address.
+	     * @memberof Address6
+	     * @instance
+	     * @param {boolean} substringSearch
+	     * @returns {RegExp}
+	     */
+	    regularExpression(substringSearch = false) {
+	        return new RegExp(this.regularExpressionString(substringSearch), 'i');
+	    }
+	}
+	ipv6.Address6 = Address6;
+	
+	return ipv6;
+}
+
+var hasRequiredIpAddress;
+
+function requireIpAddress () {
+	if (hasRequiredIpAddress) return ipAddress;
+	hasRequiredIpAddress = 1;
+	(function (exports$1) {
+		var __createBinding = (ipAddress && ipAddress.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __setModuleDefault = (ipAddress && ipAddress.__setModuleDefault) || (Object.create ? (function(o, v) {
+		    Object.defineProperty(o, "default", { enumerable: true, value: v });
+		}) : function(o, v) {
+		    o["default"] = v;
+		});
+		var __importStar = (ipAddress && ipAddress.__importStar) || function (mod) {
+		    if (mod && mod.__esModule) return mod;
+		    var result = {};
+		    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+		    __setModuleDefault(result, mod);
+		    return result;
+		};
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.v6 = exports$1.AddressError = exports$1.Address6 = exports$1.Address4 = void 0;
+		var ipv4_1 = requireIpv4();
+		Object.defineProperty(exports$1, "Address4", { enumerable: true, get: function () { return ipv4_1.Address4; } });
+		var ipv6_1 = requireIpv6();
+		Object.defineProperty(exports$1, "Address6", { enumerable: true, get: function () { return ipv6_1.Address6; } });
+		var address_error_1 = requireAddressError();
+		Object.defineProperty(exports$1, "AddressError", { enumerable: true, get: function () { return address_error_1.AddressError; } });
+		const helpers = __importStar(requireHelpers$1());
+		exports$1.v6 = { helpers };
+		
+	} (ipAddress));
+	return ipAddress;
+}
+
+var hasRequiredHelpers;
+
+function requireHelpers () {
+	if (hasRequiredHelpers) return helpers$1;
+	hasRequiredHelpers = 1;
+	Object.defineProperty(helpers$1, "__esModule", { value: true });
+	helpers$1.ipToBuffer = helpers$1.int32ToIpv4 = helpers$1.ipv4ToInt32 = helpers$1.validateSocksClientChainOptions = helpers$1.validateSocksClientOptions = void 0;
+	const util_1 = requireUtil();
+	const constants_1 = requireConstants$2();
+	const stream = require$$2$1;
+	const ip_address_1 = requireIpAddress();
+	const net$1 = net;
+	/**
+	 * Validates the provided SocksClientOptions
+	 * @param options { SocksClientOptions }
+	 * @param acceptedCommands { string[] } A list of accepted SocksProxy commands.
+	 */
+	function validateSocksClientOptions(options, acceptedCommands = ['connect', 'bind', 'associate']) {
+	    // Check SOCKs command option.
+	    if (!constants_1.SocksCommand[options.command]) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommand, options);
+	    }
+	    // Check SocksCommand for acceptable command.
+	    if (acceptedCommands.indexOf(options.command) === -1) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandForOperation, options);
+	    }
+	    // Check destination
+	    if (!isValidSocksRemoteHost(options.destination)) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options);
+	    }
+	    // Check SOCKS proxy to use
+	    if (!isValidSocksProxy(options.proxy)) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options);
+	    }
+	    // Validate custom auth (if set)
+	    validateCustomProxyAuth(options.proxy, options);
+	    // Check timeout
+	    if (options.timeout && !isValidTimeoutValue(options.timeout)) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options);
+	    }
+	    // Check existing_socket (if provided)
+	    if (options.existing_socket &&
+	        !(options.existing_socket instanceof stream.Duplex)) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsExistingSocket, options);
+	    }
+	}
+	helpers$1.validateSocksClientOptions = validateSocksClientOptions;
+	/**
+	 * Validates the SocksClientChainOptions
+	 * @param options { SocksClientChainOptions }
+	 */
+	function validateSocksClientChainOptions(options) {
+	    // Only connect is supported when chaining.
+	    if (options.command !== 'connect') {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandChain, options);
+	    }
+	    // Check destination
+	    if (!isValidSocksRemoteHost(options.destination)) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options);
+	    }
+	    // Validate proxies (length)
+	    if (!(options.proxies &&
+	        Array.isArray(options.proxies) &&
+	        options.proxies.length >= 2)) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxiesLength, options);
+	    }
+	    // Validate proxies
+	    options.proxies.forEach((proxy) => {
+	        if (!isValidSocksProxy(proxy)) {
+	            throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options);
+	        }
+	        // Validate custom auth (if set)
+	        validateCustomProxyAuth(proxy, options);
+	    });
+	    // Check timeout
+	    if (options.timeout && !isValidTimeoutValue(options.timeout)) {
+	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options);
+	    }
+	}
+	helpers$1.validateSocksClientChainOptions = validateSocksClientChainOptions;
+	function validateCustomProxyAuth(proxy, options) {
+	    if (proxy.custom_auth_method !== undefined) {
+	        // Invalid auth method range
+	        if (proxy.custom_auth_method < constants_1.SOCKS5_CUSTOM_AUTH_START ||
+	            proxy.custom_auth_method > constants_1.SOCKS5_CUSTOM_AUTH_END) {
+	            throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthRange, options);
+	        }
+	        // Missing custom_auth_request_handler
+	        if (proxy.custom_auth_request_handler === undefined ||
+	            typeof proxy.custom_auth_request_handler !== 'function') {
+	            throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options);
+	        }
+	        // Missing custom_auth_response_size
+	        if (proxy.custom_auth_response_size === undefined) {
+	            throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options);
+	        }
+	        // Missing/invalid custom_auth_response_handler
+	        if (proxy.custom_auth_response_handler === undefined ||
+	            typeof proxy.custom_auth_response_handler !== 'function') {
+	            throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options);
+	        }
+	    }
+	}
+	/**
+	 * Validates a SocksRemoteHost
+	 * @param remoteHost { SocksRemoteHost }
+	 */
+	function isValidSocksRemoteHost(remoteHost) {
+	    return (remoteHost &&
+	        typeof remoteHost.host === 'string' &&
+	        Buffer.byteLength(remoteHost.host) < 256 &&
+	        typeof remoteHost.port === 'number' &&
+	        remoteHost.port >= 0 &&
+	        remoteHost.port <= 65535);
+	}
+	/**
+	 * Validates a SocksProxy
+	 * @param proxy { SocksProxy }
+	 */
+	function isValidSocksProxy(proxy) {
+	    return (proxy &&
+	        (typeof proxy.host === 'string' || typeof proxy.ipaddress === 'string') &&
+	        typeof proxy.port === 'number' &&
+	        proxy.port >= 0 &&
+	        proxy.port <= 65535 &&
+	        (proxy.type === 4 || proxy.type === 5));
+	}
+	/**
+	 * Validates a timeout value.
+	 * @param value { Number }
+	 */
+	function isValidTimeoutValue(value) {
+	    return typeof value === 'number' && value > 0;
+	}
+	function ipv4ToInt32(ip) {
+	    const address = new ip_address_1.Address4(ip);
+	    // Convert the IPv4 address parts to an integer
+	    return address.toArray().reduce((acc, part) => (acc << 8) + part, 0) >>> 0;
+	}
+	helpers$1.ipv4ToInt32 = ipv4ToInt32;
+	function int32ToIpv4(int32) {
+	    // Extract each byte (octet) from the 32-bit integer
+	    const octet1 = (int32 >>> 24) & 0xff;
+	    const octet2 = (int32 >>> 16) & 0xff;
+	    const octet3 = (int32 >>> 8) & 0xff;
+	    const octet4 = int32 & 0xff;
+	    // Combine the octets into a string in IPv4 format
+	    return [octet1, octet2, octet3, octet4].join('.');
+	}
+	helpers$1.int32ToIpv4 = int32ToIpv4;
+	function ipToBuffer(ip) {
+	    if (net$1.isIPv4(ip)) {
+	        // Handle IPv4 addresses
+	        const address = new ip_address_1.Address4(ip);
+	        return Buffer.from(address.toArray());
+	    }
+	    else if (net$1.isIPv6(ip)) {
+	        // Handle IPv6 addresses
+	        const address = new ip_address_1.Address6(ip);
+	        return Buffer.from(address
+	            .canonicalForm()
+	            .split(':')
+	            .map((segment) => segment.padStart(4, '0'))
+	            .join(''), 'hex');
+	    }
+	    else {
+	        throw new Error('Invalid IP address format');
+	    }
+	}
+	helpers$1.ipToBuffer = ipToBuffer;
+	
+	return helpers$1;
+}
+
+var receivebuffer = {};
+
+var hasRequiredReceivebuffer;
+
+function requireReceivebuffer () {
+	if (hasRequiredReceivebuffer) return receivebuffer;
+	hasRequiredReceivebuffer = 1;
+	Object.defineProperty(receivebuffer, "__esModule", { value: true });
+	receivebuffer.ReceiveBuffer = void 0;
+	class ReceiveBuffer {
+	    constructor(size = 4096) {
+	        this.buffer = Buffer.allocUnsafe(size);
+	        this.offset = 0;
+	        this.originalSize = size;
+	    }
+	    get length() {
+	        return this.offset;
+	    }
+	    append(data) {
+	        if (!Buffer.isBuffer(data)) {
+	            throw new Error('Attempted to append a non-buffer instance to ReceiveBuffer.');
+	        }
+	        if (this.offset + data.length >= this.buffer.length) {
+	            const tmp = this.buffer;
+	            this.buffer = Buffer.allocUnsafe(Math.max(this.buffer.length + this.originalSize, this.buffer.length + data.length));
+	            tmp.copy(this.buffer);
+	        }
+	        data.copy(this.buffer, this.offset);
+	        return (this.offset += data.length);
+	    }
+	    peek(length) {
+	        if (length > this.offset) {
+	            throw new Error('Attempted to read beyond the bounds of the managed internal data.');
+	        }
+	        return this.buffer.slice(0, length);
+	    }
+	    get(length) {
+	        if (length > this.offset) {
+	            throw new Error('Attempted to read beyond the bounds of the managed internal data.');
+	        }
+	        const value = Buffer.allocUnsafe(length);
+	        this.buffer.slice(0, length).copy(value);
+	        this.buffer.copyWithin(0, length, length + this.offset - length);
+	        this.offset -= length;
+	        return value;
+	    }
+	}
+	receivebuffer.ReceiveBuffer = ReceiveBuffer;
+	
+	return receivebuffer;
+}
+
+var hasRequiredSocksclient;
+
+function requireSocksclient () {
+	if (hasRequiredSocksclient) return socksclient;
+	hasRequiredSocksclient = 1;
+	(function (exports$1) {
+		var __awaiter = (socksclient && socksclient.__awaiter) || function (thisArg, _arguments, P, generator) {
+		    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+		    return new (P || (P = Promise))(function (resolve, reject) {
+		        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+		        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+		        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+		        step((generator = generator.apply(thisArg, _arguments || [])).next());
+		    });
+		};
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.SocksClientError = exports$1.SocksClient = void 0;
+		const events_1 = require$$0;
+		const net$1 = net;
+		const smart_buffer_1 = requireSmartbuffer();
+		const constants_1 = requireConstants$2();
+		const helpers_1 = requireHelpers();
+		const receivebuffer_1 = requireReceivebuffer();
+		const util_1 = requireUtil();
+		Object.defineProperty(exports$1, "SocksClientError", { enumerable: true, get: function () { return util_1.SocksClientError; } });
+		const ip_address_1 = requireIpAddress();
+		class SocksClient extends events_1.EventEmitter {
+		    constructor(options) {
+		        super();
+		        this.options = Object.assign({}, options);
+		        // Validate SocksClientOptions
+		        (0, helpers_1.validateSocksClientOptions)(options);
+		        // Default state
+		        this.setState(constants_1.SocksClientState.Created);
+		    }
+		    /**
+		     * Creates a new SOCKS connection.
+		     *
+		     * Note: Supports callbacks and promises. Only supports the connect command.
+		     * @param options { SocksClientOptions } Options.
+		     * @param callback { Function } An optional callback function.
+		     * @returns { Promise }
+		     */
+		    static createConnection(options, callback) {
+		        return new Promise((resolve, reject) => {
+		            // Validate SocksClientOptions
+		            try {
+		                (0, helpers_1.validateSocksClientOptions)(options, ['connect']);
+		            }
+		            catch (err) {
+		                if (typeof callback === 'function') {
+		                    callback(err);
+		                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+		                    return resolve(err); // Resolves pending promise (prevents memory leaks).
+		                }
+		                else {
+		                    return reject(err);
+		                }
+		            }
+		            const client = new SocksClient(options);
+		            client.connect(options.existing_socket);
+		            client.once('established', (info) => {
+		                client.removeAllListeners();
+		                if (typeof callback === 'function') {
+		                    callback(null, info);
+		                    resolve(info); // Resolves pending promise (prevents memory leaks).
+		                }
+		                else {
+		                    resolve(info);
+		                }
+		            });
+		            // Error occurred, failed to establish connection.
+		            client.once('error', (err) => {
+		                client.removeAllListeners();
+		                if (typeof callback === 'function') {
+		                    callback(err);
+		                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+		                    resolve(err); // Resolves pending promise (prevents memory leaks).
+		                }
+		                else {
+		                    reject(err);
+		                }
+		            });
+		        });
+		    }
+		    /**
+		     * Creates a new SOCKS connection chain to a destination host through 2 or more SOCKS proxies.
+		     *
+		     * Note: Supports callbacks and promises. Only supports the connect method.
+		     * Note: Implemented via createConnection() factory function.
+		     * @param options { SocksClientChainOptions } Options
+		     * @param callback { Function } An optional callback function.
+		     * @returns { Promise }
+		     */
+		    static createConnectionChain(options, callback) {
+		        // eslint-disable-next-line no-async-promise-executor
+		        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+		            // Validate SocksClientChainOptions
+		            try {
+		                (0, helpers_1.validateSocksClientChainOptions)(options);
+		            }
+		            catch (err) {
+		                if (typeof callback === 'function') {
+		                    callback(err);
+		                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+		                    return resolve(err); // Resolves pending promise (prevents memory leaks).
+		                }
+		                else {
+		                    return reject(err);
+		                }
+		            }
+		            // Shuffle proxies
+		            if (options.randomizeChain) {
+		                (0, util_1.shuffleArray)(options.proxies);
+		            }
+		            try {
+		                let sock;
+		                for (let i = 0; i < options.proxies.length; i++) {
+		                    const nextProxy = options.proxies[i];
+		                    // If we've reached the last proxy in the chain, the destination is the actual destination, otherwise it's the next proxy.
+		                    const nextDestination = i === options.proxies.length - 1
+		                        ? options.destination
+		                        : {
+		                            host: options.proxies[i + 1].host ||
+		                                options.proxies[i + 1].ipaddress,
+		                            port: options.proxies[i + 1].port,
+		                        };
+		                    // Creates the next connection in the chain.
+		                    const result = yield SocksClient.createConnection({
+		                        command: 'connect',
+		                        proxy: nextProxy,
+		                        destination: nextDestination,
+		                        existing_socket: sock,
+		                    });
+		                    // If sock is undefined, assign it here.
+		                    sock = sock || result.socket;
+		                }
+		                if (typeof callback === 'function') {
+		                    callback(null, { socket: sock });
+		                    resolve({ socket: sock }); // Resolves pending promise (prevents memory leaks).
+		                }
+		                else {
+		                    resolve({ socket: sock });
+		                }
+		            }
+		            catch (err) {
+		                if (typeof callback === 'function') {
+		                    callback(err);
+		                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+		                    resolve(err); // Resolves pending promise (prevents memory leaks).
+		                }
+		                else {
+		                    reject(err);
+		                }
+		            }
+		        }));
+		    }
+		    /**
+		     * Creates a SOCKS UDP Frame.
+		     * @param options
+		     */
+		    static createUDPFrame(options) {
+		        const buff = new smart_buffer_1.SmartBuffer();
+		        buff.writeUInt16BE(0);
+		        buff.writeUInt8(options.frameNumber || 0);
+		        // IPv4/IPv6/Hostname
+		        if (net$1.isIPv4(options.remoteHost.host)) {
+		            buff.writeUInt8(constants_1.Socks5HostType.IPv4);
+		            buff.writeUInt32BE((0, helpers_1.ipv4ToInt32)(options.remoteHost.host));
+		        }
+		        else if (net$1.isIPv6(options.remoteHost.host)) {
+		            buff.writeUInt8(constants_1.Socks5HostType.IPv6);
+		            buff.writeBuffer((0, helpers_1.ipToBuffer)(options.remoteHost.host));
+		        }
+		        else {
+		            buff.writeUInt8(constants_1.Socks5HostType.Hostname);
+		            buff.writeUInt8(Buffer.byteLength(options.remoteHost.host));
+		            buff.writeString(options.remoteHost.host);
+		        }
+		        // Port
+		        buff.writeUInt16BE(options.remoteHost.port);
+		        // Data
+		        buff.writeBuffer(options.data);
+		        return buff.toBuffer();
+		    }
+		    /**
+		     * Parses a SOCKS UDP frame.
+		     * @param data
+		     */
+		    static parseUDPFrame(data) {
+		        const buff = smart_buffer_1.SmartBuffer.fromBuffer(data);
+		        buff.readOffset = 2;
+		        const frameNumber = buff.readUInt8();
+		        const hostType = buff.readUInt8();
+		        let remoteHost;
+		        if (hostType === constants_1.Socks5HostType.IPv4) {
+		            remoteHost = (0, helpers_1.int32ToIpv4)(buff.readUInt32BE());
+		        }
+		        else if (hostType === constants_1.Socks5HostType.IPv6) {
+		            remoteHost = ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm();
+		        }
+		        else {
+		            remoteHost = buff.readString(buff.readUInt8());
+		        }
+		        const remotePort = buff.readUInt16BE();
+		        return {
+		            frameNumber,
+		            remoteHost: {
+		                host: remoteHost,
+		                port: remotePort,
+		            },
+		            data: buff.readBuffer(),
+		        };
+		    }
+		    /**
+		     * Internal state setter. If the SocksClient is in an error state, it cannot be changed to a non error state.
+		     */
+		    setState(newState) {
+		        if (this.state !== constants_1.SocksClientState.Error) {
+		            this.state = newState;
+		        }
+		    }
+		    /**
+		     * Starts the connection establishment to the proxy and destination.
+		     * @param existingSocket Connected socket to use instead of creating a new one (internal use).
+		     */
+		    connect(existingSocket) {
+		        this.onDataReceived = (data) => this.onDataReceivedHandler(data);
+		        this.onClose = () => this.onCloseHandler();
+		        this.onError = (err) => this.onErrorHandler(err);
+		        this.onConnect = () => this.onConnectHandler();
+		        // Start timeout timer (defaults to 30 seconds)
+		        const timer = setTimeout(() => this.onEstablishedTimeout(), this.options.timeout || constants_1.DEFAULT_TIMEOUT);
+		        // check whether unref is available as it differs from browser to NodeJS (#33)
+		        if (timer.unref && typeof timer.unref === 'function') {
+		            timer.unref();
+		        }
+		        // If an existing socket is provided, use it to negotiate SOCKS handshake. Otherwise create a new Socket.
+		        if (existingSocket) {
+		            this.socket = existingSocket;
+		        }
+		        else {
+		            this.socket = new net$1.Socket();
+		        }
+		        // Attach Socket error handlers.
+		        this.socket.once('close', this.onClose);
+		        this.socket.once('error', this.onError);
+		        this.socket.once('connect', this.onConnect);
+		        this.socket.on('data', this.onDataReceived);
+		        this.setState(constants_1.SocksClientState.Connecting);
+		        this.receiveBuffer = new receivebuffer_1.ReceiveBuffer();
+		        if (existingSocket) {
+		            this.socket.emit('connect');
+		        }
+		        else {
+		            this.socket.connect(this.getSocketOptions());
+		            if (this.options.set_tcp_nodelay !== undefined &&
+		                this.options.set_tcp_nodelay !== null) {
+		                this.socket.setNoDelay(!!this.options.set_tcp_nodelay);
+		            }
+		        }
+		        // Listen for established event so we can re-emit any excess data received during handshakes.
+		        this.prependOnceListener('established', (info) => {
+		            setImmediate(() => {
+		                if (this.receiveBuffer.length > 0) {
+		                    const excessData = this.receiveBuffer.get(this.receiveBuffer.length);
+		                    info.socket.emit('data', excessData);
+		                }
+		                info.socket.resume();
+		            });
+		        });
+		    }
+		    // Socket options (defaults host/port to options.proxy.host/options.proxy.port)
+		    getSocketOptions() {
+		        return Object.assign(Object.assign({}, this.options.socket_options), { host: this.options.proxy.host || this.options.proxy.ipaddress, port: this.options.proxy.port });
+		    }
+		    /**
+		     * Handles internal Socks timeout callback.
+		     * Note: If the Socks client is not BoundWaitingForConnection or Established, the connection will be closed.
+		     */
+		    onEstablishedTimeout() {
+		        if (this.state !== constants_1.SocksClientState.Established &&
+		            this.state !== constants_1.SocksClientState.BoundWaitingForConnection) {
+		            this.closeSocket(constants_1.ERRORS.ProxyConnectionTimedOut);
+		        }
+		    }
+		    /**
+		     * Handles Socket connect event.
+		     */
+		    onConnectHandler() {
+		        this.setState(constants_1.SocksClientState.Connected);
+		        // Send initial handshake.
+		        if (this.options.proxy.type === 4) {
+		            this.sendSocks4InitialHandshake();
+		        }
+		        else {
+		            this.sendSocks5InitialHandshake();
+		        }
+		        this.setState(constants_1.SocksClientState.SentInitialHandshake);
+		    }
+		    /**
+		     * Handles Socket data event.
+		     * @param data
+		     */
+		    onDataReceivedHandler(data) {
+		        /*
+		          All received data is appended to a ReceiveBuffer.
+		          This makes sure that all the data we need is received before we attempt to process it.
+		        */
+		        this.receiveBuffer.append(data);
+		        // Process data that we have.
+		        this.processData();
+		    }
+		    /**
+		     * Handles processing of the data we have received.
+		     */
+		    processData() {
+		        // If we have enough data to process the next step in the SOCKS handshake, proceed.
+		        while (this.state !== constants_1.SocksClientState.Established &&
+		            this.state !== constants_1.SocksClientState.Error &&
+		            this.receiveBuffer.length >= this.nextRequiredPacketBufferSize) {
+		            // Sent initial handshake, waiting for response.
+		            if (this.state === constants_1.SocksClientState.SentInitialHandshake) {
+		                if (this.options.proxy.type === 4) {
+		                    // Socks v4 only has one handshake response.
+		                    this.handleSocks4FinalHandshakeResponse();
+		                }
+		                else {
+		                    // Socks v5 has two handshakes, handle initial one here.
+		                    this.handleInitialSocks5HandshakeResponse();
+		                }
+		                // Sent auth request for Socks v5, waiting for response.
+		            }
+		            else if (this.state === constants_1.SocksClientState.SentAuthentication) {
+		                this.handleInitialSocks5AuthenticationHandshakeResponse();
+		                // Sent final Socks v5 handshake, waiting for final response.
+		            }
+		            else if (this.state === constants_1.SocksClientState.SentFinalHandshake) {
+		                this.handleSocks5FinalHandshakeResponse();
+		                // Socks BIND established. Waiting for remote connection via proxy.
+		            }
+		            else if (this.state === constants_1.SocksClientState.BoundWaitingForConnection) {
+		                if (this.options.proxy.type === 4) {
+		                    this.handleSocks4IncomingConnectionResponse();
+		                }
+		                else {
+		                    this.handleSocks5IncomingConnectionResponse();
+		                }
+		            }
+		            else {
+		                this.closeSocket(constants_1.ERRORS.InternalError);
+		                break;
+		            }
+		        }
+		    }
+		    /**
+		     * Handles Socket close event.
+		     * @param had_error
+		     */
+		    onCloseHandler() {
+		        this.closeSocket(constants_1.ERRORS.SocketClosed);
+		    }
+		    /**
+		     * Handles Socket error event.
+		     * @param err
+		     */
+		    onErrorHandler(err) {
+		        this.closeSocket(err.message);
+		    }
+		    /**
+		     * Removes internal event listeners on the underlying Socket.
+		     */
+		    removeInternalSocketHandlers() {
+		        // Pauses data flow of the socket (this is internally resumed after 'established' is emitted)
+		        this.socket.pause();
+		        this.socket.removeListener('data', this.onDataReceived);
+		        this.socket.removeListener('close', this.onClose);
+		        this.socket.removeListener('error', this.onError);
+		        this.socket.removeListener('connect', this.onConnect);
+		    }
+		    /**
+		     * Closes and destroys the underlying Socket. Emits an error event.
+		     * @param err { String } An error string to include in error event.
+		     */
+		    closeSocket(err) {
+		        // Make sure only one 'error' event is fired for the lifetime of this SocksClient instance.
+		        if (this.state !== constants_1.SocksClientState.Error) {
+		            // Set internal state to Error.
+		            this.setState(constants_1.SocksClientState.Error);
+		            // Destroy Socket
+		            this.socket.destroy();
+		            // Remove internal listeners
+		            this.removeInternalSocketHandlers();
+		            // Fire 'error' event.
+		            this.emit('error', new util_1.SocksClientError(err, this.options));
+		        }
+		    }
+		    /**
+		     * Sends initial Socks v4 handshake request.
+		     */
+		    sendSocks4InitialHandshake() {
+		        const userId = this.options.proxy.userId || '';
+		        const buff = new smart_buffer_1.SmartBuffer();
+		        buff.writeUInt8(0x04);
+		        buff.writeUInt8(constants_1.SocksCommand[this.options.command]);
+		        buff.writeUInt16BE(this.options.destination.port);
+		        // Socks 4 (IPv4)
+		        if (net$1.isIPv4(this.options.destination.host)) {
+		            buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host));
+		            buff.writeStringNT(userId);
+		            // Socks 4a (hostname)
+		        }
+		        else {
+		            buff.writeUInt8(0x00);
+		            buff.writeUInt8(0x00);
+		            buff.writeUInt8(0x00);
+		            buff.writeUInt8(0x01);
+		            buff.writeStringNT(userId);
+		            buff.writeStringNT(this.options.destination.host);
+		        }
+		        this.nextRequiredPacketBufferSize =
+		            constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks4Response;
+		        this.socket.write(buff.toBuffer());
+		    }
+		    /**
+		     * Handles Socks v4 handshake response.
+		     * @param data
+		     */
+		    handleSocks4FinalHandshakeResponse() {
+		        const data = this.receiveBuffer.get(8);
+		        if (data[1] !== constants_1.Socks4Response.Granted) {
+		            this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedConnection} - (${constants_1.Socks4Response[data[1]]})`);
+		        }
+		        else {
+		            // Bind response
+		            if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) {
+		                const buff = smart_buffer_1.SmartBuffer.fromBuffer(data);
+		                buff.readOffset = 2;
+		                const remoteHost = {
+		                    port: buff.readUInt16BE(),
+		                    host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()),
+		                };
+		                // If host is 0.0.0.0, set to proxy host.
+		                if (remoteHost.host === '0.0.0.0') {
+		                    remoteHost.host = this.options.proxy.ipaddress;
+		                }
+		                this.setState(constants_1.SocksClientState.BoundWaitingForConnection);
+		                this.emit('bound', { remoteHost, socket: this.socket });
+		                // Connect response
+		            }
+		            else {
+		                this.setState(constants_1.SocksClientState.Established);
+		                this.removeInternalSocketHandlers();
+		                this.emit('established', { socket: this.socket });
+		            }
+		        }
+		    }
+		    /**
+		     * Handles Socks v4 incoming connection request (BIND)
+		     * @param data
+		     */
+		    handleSocks4IncomingConnectionResponse() {
+		        const data = this.receiveBuffer.get(8);
+		        if (data[1] !== constants_1.Socks4Response.Granted) {
+		            this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedIncomingBoundConnection} - (${constants_1.Socks4Response[data[1]]})`);
+		        }
+		        else {
+		            const buff = smart_buffer_1.SmartBuffer.fromBuffer(data);
+		            buff.readOffset = 2;
+		            const remoteHost = {
+		                port: buff.readUInt16BE(),
+		                host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()),
+		            };
+		            this.setState(constants_1.SocksClientState.Established);
+		            this.removeInternalSocketHandlers();
+		            this.emit('established', { remoteHost, socket: this.socket });
+		        }
+		    }
+		    /**
+		     * Sends initial Socks v5 handshake request.
+		     */
+		    sendSocks5InitialHandshake() {
+		        const buff = new smart_buffer_1.SmartBuffer();
+		        // By default we always support no auth.
+		        const supportedAuthMethods = [constants_1.Socks5Auth.NoAuth];
+		        // We should only tell the proxy we support user/pass auth if auth info is actually provided.
+		        // Note: As of Tor v0.3.5.7+, if user/pass auth is an option from the client, by default it will always take priority.
+		        if (this.options.proxy.userId || this.options.proxy.password) {
+		            supportedAuthMethods.push(constants_1.Socks5Auth.UserPass);
+		        }
+		        // Custom auth method?
+		        if (this.options.proxy.custom_auth_method !== undefined) {
+		            supportedAuthMethods.push(this.options.proxy.custom_auth_method);
+		        }
+		        // Build handshake packet
+		        buff.writeUInt8(0x05);
+		        buff.writeUInt8(supportedAuthMethods.length);
+		        for (const authMethod of supportedAuthMethods) {
+		            buff.writeUInt8(authMethod);
+		        }
+		        this.nextRequiredPacketBufferSize =
+		            constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5InitialHandshakeResponse;
+		        this.socket.write(buff.toBuffer());
+		        this.setState(constants_1.SocksClientState.SentInitialHandshake);
+		    }
+		    /**
+		     * Handles initial Socks v5 handshake response.
+		     * @param data
+		     */
+		    handleInitialSocks5HandshakeResponse() {
+		        const data = this.receiveBuffer.get(2);
+		        if (data[0] !== 0x05) {
+		            this.closeSocket(constants_1.ERRORS.InvalidSocks5IntiailHandshakeSocksVersion);
+		        }
+		        else if (data[1] === constants_1.SOCKS5_NO_ACCEPTABLE_AUTH) {
+		            this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeNoAcceptedAuthType);
+		        }
+		        else {
+		            // If selected Socks v5 auth method is no auth, send final handshake request.
+		            if (data[1] === constants_1.Socks5Auth.NoAuth) {
+		                this.socks5ChosenAuthType = constants_1.Socks5Auth.NoAuth;
+		                this.sendSocks5CommandRequest();
+		                // If selected Socks v5 auth method is user/password, send auth handshake.
+		            }
+		            else if (data[1] === constants_1.Socks5Auth.UserPass) {
+		                this.socks5ChosenAuthType = constants_1.Socks5Auth.UserPass;
+		                this.sendSocks5UserPassAuthentication();
+		                // If selected Socks v5 auth method is the custom_auth_method, send custom handshake.
+		            }
+		            else if (data[1] === this.options.proxy.custom_auth_method) {
+		                this.socks5ChosenAuthType = this.options.proxy.custom_auth_method;
+		                this.sendSocks5CustomAuthentication();
+		            }
+		            else {
+		                this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeUnknownAuthType);
+		            }
+		        }
+		    }
+		    /**
+		     * Sends Socks v5 user & password auth handshake.
+		     *
+		     * Note: No auth and user/pass are currently supported.
+		     */
+		    sendSocks5UserPassAuthentication() {
+		        const userId = this.options.proxy.userId || '';
+		        const password = this.options.proxy.password || '';
+		        const buff = new smart_buffer_1.SmartBuffer();
+		        buff.writeUInt8(0x01);
+		        buff.writeUInt8(Buffer.byteLength(userId));
+		        buff.writeString(userId);
+		        buff.writeUInt8(Buffer.byteLength(password));
+		        buff.writeString(password);
+		        this.nextRequiredPacketBufferSize =
+		            constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5UserPassAuthenticationResponse;
+		        this.socket.write(buff.toBuffer());
+		        this.setState(constants_1.SocksClientState.SentAuthentication);
+		    }
+		    sendSocks5CustomAuthentication() {
+		        return __awaiter(this, void 0, void 0, function* () {
+		            this.nextRequiredPacketBufferSize =
+		                this.options.proxy.custom_auth_response_size;
+		            this.socket.write(yield this.options.proxy.custom_auth_request_handler());
+		            this.setState(constants_1.SocksClientState.SentAuthentication);
+		        });
+		    }
+		    handleSocks5CustomAuthHandshakeResponse(data) {
+		        return __awaiter(this, void 0, void 0, function* () {
+		            return yield this.options.proxy.custom_auth_response_handler(data);
+		        });
+		    }
+		    handleSocks5AuthenticationNoAuthHandshakeResponse(data) {
+		        return __awaiter(this, void 0, void 0, function* () {
+		            return data[1] === 0x00;
+		        });
+		    }
+		    handleSocks5AuthenticationUserPassHandshakeResponse(data) {
+		        return __awaiter(this, void 0, void 0, function* () {
+		            return data[1] === 0x00;
+		        });
+		    }
+		    /**
+		     * Handles Socks v5 auth handshake response.
+		     * @param data
+		     */
+		    handleInitialSocks5AuthenticationHandshakeResponse() {
+		        return __awaiter(this, void 0, void 0, function* () {
+		            this.setState(constants_1.SocksClientState.ReceivedAuthenticationResponse);
+		            let authResult = false;
+		            if (this.socks5ChosenAuthType === constants_1.Socks5Auth.NoAuth) {
+		                authResult = yield this.handleSocks5AuthenticationNoAuthHandshakeResponse(this.receiveBuffer.get(2));
+		            }
+		            else if (this.socks5ChosenAuthType === constants_1.Socks5Auth.UserPass) {
+		                authResult =
+		                    yield this.handleSocks5AuthenticationUserPassHandshakeResponse(this.receiveBuffer.get(2));
+		            }
+		            else if (this.socks5ChosenAuthType === this.options.proxy.custom_auth_method) {
+		                authResult = yield this.handleSocks5CustomAuthHandshakeResponse(this.receiveBuffer.get(this.options.proxy.custom_auth_response_size));
+		            }
+		            if (!authResult) {
+		                this.closeSocket(constants_1.ERRORS.Socks5AuthenticationFailed);
+		            }
+		            else {
+		                this.sendSocks5CommandRequest();
+		            }
+		        });
+		    }
+		    /**
+		     * Sends Socks v5 final handshake request.
+		     */
+		    sendSocks5CommandRequest() {
+		        const buff = new smart_buffer_1.SmartBuffer();
+		        buff.writeUInt8(0x05);
+		        buff.writeUInt8(constants_1.SocksCommand[this.options.command]);
+		        buff.writeUInt8(0x00);
+		        // ipv4, ipv6, domain?
+		        if (net$1.isIPv4(this.options.destination.host)) {
+		            buff.writeUInt8(constants_1.Socks5HostType.IPv4);
+		            buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host));
+		        }
+		        else if (net$1.isIPv6(this.options.destination.host)) {
+		            buff.writeUInt8(constants_1.Socks5HostType.IPv6);
+		            buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host));
+		        }
+		        else {
+		            buff.writeUInt8(constants_1.Socks5HostType.Hostname);
+		            buff.writeUInt8(this.options.destination.host.length);
+		            buff.writeString(this.options.destination.host);
+		        }
+		        buff.writeUInt16BE(this.options.destination.port);
+		        this.nextRequiredPacketBufferSize =
+		            constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader;
+		        this.socket.write(buff.toBuffer());
+		        this.setState(constants_1.SocksClientState.SentFinalHandshake);
+		    }
+		    /**
+		     * Handles Socks v5 final handshake response.
+		     * @param data
+		     */
+		    handleSocks5FinalHandshakeResponse() {
+		        // Peek at available data (we need at least 5 bytes to get the hostname length)
+		        const header = this.receiveBuffer.peek(5);
+		        if (header[0] !== 0x05 || header[1] !== constants_1.Socks5Response.Granted) {
+		            this.closeSocket(`${constants_1.ERRORS.InvalidSocks5FinalHandshakeRejected} - ${constants_1.Socks5Response[header[1]]}`);
+		        }
+		        else {
+		            // Read address type
+		            const addressType = header[3];
+		            let remoteHost;
+		            let buff;
+		            // IPv4
+		            if (addressType === constants_1.Socks5HostType.IPv4) {
+		                // Check if data is available.
+		                const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4;
+		                if (this.receiveBuffer.length < dataNeeded) {
+		                    this.nextRequiredPacketBufferSize = dataNeeded;
+		                    return;
+		                }
+		                buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
+		                remoteHost = {
+		                    host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()),
+		                    port: buff.readUInt16BE(),
+		                };
+		                // If given host is 0.0.0.0, assume remote proxy ip instead.
+		                if (remoteHost.host === '0.0.0.0') {
+		                    remoteHost.host = this.options.proxy.ipaddress;
+		                }
+		                // Hostname
+		            }
+		            else if (addressType === constants_1.Socks5HostType.Hostname) {
+		                const hostLength = header[4];
+		                const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); // header + host length + host + port
+		                // Check if data is available.
+		                if (this.receiveBuffer.length < dataNeeded) {
+		                    this.nextRequiredPacketBufferSize = dataNeeded;
+		                    return;
+		                }
+		                buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5));
+		                remoteHost = {
+		                    host: buff.readString(hostLength),
+		                    port: buff.readUInt16BE(),
+		                };
+		                // IPv6
+		            }
+		            else if (addressType === constants_1.Socks5HostType.IPv6) {
+		                // Check if data is available.
+		                const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6;
+		                if (this.receiveBuffer.length < dataNeeded) {
+		                    this.nextRequiredPacketBufferSize = dataNeeded;
+		                    return;
+		                }
+		                buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
+		                remoteHost = {
+		                    host: ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(),
+		                    port: buff.readUInt16BE(),
+		                };
+		            }
+		            // We have everything we need
+		            this.setState(constants_1.SocksClientState.ReceivedFinalResponse);
+		            // If using CONNECT, the client is now in the established state.
+		            if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.connect) {
+		                this.setState(constants_1.SocksClientState.Established);
+		                this.removeInternalSocketHandlers();
+		                this.emit('established', { remoteHost, socket: this.socket });
+		            }
+		            else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) {
+		                /* If using BIND, the Socks client is now in BoundWaitingForConnection state.
+		                   This means that the remote proxy server is waiting for a remote connection to the bound port. */
+		                this.setState(constants_1.SocksClientState.BoundWaitingForConnection);
+		                this.nextRequiredPacketBufferSize =
+		                    constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader;
+		                this.emit('bound', { remoteHost, socket: this.socket });
+		                /*
+		                  If using Associate, the Socks client is now Established. And the proxy server is now accepting UDP packets at the
+		                  given bound port. This initial Socks TCP connection must remain open for the UDP relay to continue to work.
+		                */
+		            }
+		            else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.associate) {
+		                this.setState(constants_1.SocksClientState.Established);
+		                this.removeInternalSocketHandlers();
+		                this.emit('established', {
+		                    remoteHost,
+		                    socket: this.socket,
+		                });
+		            }
+		        }
+		    }
+		    /**
+		     * Handles Socks v5 incoming connection request (BIND).
+		     */
+		    handleSocks5IncomingConnectionResponse() {
+		        // Peek at available data (we need at least 5 bytes to get the hostname length)
+		        const header = this.receiveBuffer.peek(5);
+		        if (header[0] !== 0x05 || header[1] !== constants_1.Socks5Response.Granted) {
+		            this.closeSocket(`${constants_1.ERRORS.Socks5ProxyRejectedIncomingBoundConnection} - ${constants_1.Socks5Response[header[1]]}`);
+		        }
+		        else {
+		            // Read address type
+		            const addressType = header[3];
+		            let remoteHost;
+		            let buff;
+		            // IPv4
+		            if (addressType === constants_1.Socks5HostType.IPv4) {
+		                // Check if data is available.
+		                const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4;
+		                if (this.receiveBuffer.length < dataNeeded) {
+		                    this.nextRequiredPacketBufferSize = dataNeeded;
+		                    return;
+		                }
+		                buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
+		                remoteHost = {
+		                    host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()),
+		                    port: buff.readUInt16BE(),
+		                };
+		                // If given host is 0.0.0.0, assume remote proxy ip instead.
+		                if (remoteHost.host === '0.0.0.0') {
+		                    remoteHost.host = this.options.proxy.ipaddress;
+		                }
+		                // Hostname
+		            }
+		            else if (addressType === constants_1.Socks5HostType.Hostname) {
+		                const hostLength = header[4];
+		                const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); // header + host length + port
+		                // Check if data is available.
+		                if (this.receiveBuffer.length < dataNeeded) {
+		                    this.nextRequiredPacketBufferSize = dataNeeded;
+		                    return;
+		                }
+		                buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5));
+		                remoteHost = {
+		                    host: buff.readString(hostLength),
+		                    port: buff.readUInt16BE(),
+		                };
+		                // IPv6
+		            }
+		            else if (addressType === constants_1.Socks5HostType.IPv6) {
+		                // Check if data is available.
+		                const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6;
+		                if (this.receiveBuffer.length < dataNeeded) {
+		                    this.nextRequiredPacketBufferSize = dataNeeded;
+		                    return;
+		                }
+		                buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
+		                remoteHost = {
+		                    host: ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(),
+		                    port: buff.readUInt16BE(),
+		                };
+		            }
+		            this.setState(constants_1.SocksClientState.Established);
+		            this.removeInternalSocketHandlers();
+		            this.emit('established', { remoteHost, socket: this.socket });
+		        }
+		    }
+		    get socksClientOptions() {
+		        return Object.assign({}, this.options);
+		    }
+		}
+		exports$1.SocksClient = SocksClient;
+		
+	} (socksclient));
+	return socksclient;
+}
+
+var hasRequiredBuild;
+
+function requireBuild () {
+	if (hasRequiredBuild) return build$1;
+	hasRequiredBuild = 1;
+	(function (exports$1) {
+		var __createBinding = (build$1 && build$1.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (build$1 && build$1.__exportStar) || function(m, exports$1) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+		};
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		__exportStar(requireSocksclient(), exports$1);
+		
+	} (build$1));
+	return build$1;
+}
+
+var buildExports = requireBuild();
+
+const INTERNAL = Symbol('AgentBaseInternalState');
+class Agent extends http__namespace.Agent {
+    constructor(opts) {
+        super(opts);
+        this[INTERNAL] = {};
+    }
+    /**
+     * Determine whether this is an `http` or `https` request.
+     */
+    isSecureEndpoint(options) {
+        if (options) {
+            // First check the `secureEndpoint` property explicitly, since this
+            // means that a parent `Agent` is "passing through" to this instance.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (typeof options.secureEndpoint === 'boolean') {
+                return options.secureEndpoint;
+            }
+            // If no explicit `secure` endpoint, check if `protocol` property is
+            // set. This will usually be the case since using a full string URL
+            // or `URL` instance should be the most common usage.
+            if (typeof options.protocol === 'string') {
+                return options.protocol === 'https:';
+            }
+        }
+        // Finally, if no `protocol` property was set, then fall back to
+        // checking the stack trace of the current call stack, and try to
+        // detect the "https" module.
+        const { stack } = new Error();
+        if (typeof stack !== 'string')
+            return false;
+        return stack
+            .split('\n')
+            .some((l) => l.indexOf('(https.js:') !== -1 ||
+            l.indexOf('node:https:') !== -1);
+    }
+    // In order to support async signatures in `connect()` and Node's native
+    // connection pooling in `http.Agent`, the array of sockets for each origin
+    // has to be updated synchronously. This is so the length of the array is
+    // accurate when `addRequest()` is next called. We achieve this by creating a
+    // fake socket and adding it to `sockets[origin]` and incrementing
+    // `totalSocketCount`.
+    incrementSockets(name) {
+        // If `maxSockets` and `maxTotalSockets` are both Infinity then there is no
+        // need to create a fake socket because Node.js native connection pooling
+        // will never be invoked.
+        if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
+            return null;
+        }
+        // All instances of `sockets` are expected TypeScript errors. The
+        // alternative is to add it as a private property of this class but that
+        // will break TypeScript subclassing.
+        if (!this.sockets[name]) {
+            // @ts-expect-error `sockets` is readonly in `@types/node`
+            this.sockets[name] = [];
+        }
+        const fakeSocket = new net__namespace.Socket({ writable: false });
+        this.sockets[name].push(fakeSocket);
+        // @ts-expect-error `totalSocketCount` isn't defined in `@types/node`
+        this.totalSocketCount++;
+        return fakeSocket;
+    }
+    decrementSockets(name, socket) {
+        if (!this.sockets[name] || socket === null) {
+            return;
+        }
+        const sockets = this.sockets[name];
+        const index = sockets.indexOf(socket);
+        if (index !== -1) {
+            sockets.splice(index, 1);
+            // @ts-expect-error  `totalSocketCount` isn't defined in `@types/node`
+            this.totalSocketCount--;
+            if (sockets.length === 0) {
+                // @ts-expect-error `sockets` is readonly in `@types/node`
+                delete this.sockets[name];
+            }
+        }
+    }
+    // In order to properly update the socket pool, we need to call `getName()` on
+    // the core `https.Agent` if it is a secureEndpoint.
+    getName(options) {
+        const secureEndpoint = this.isSecureEndpoint(options);
+        if (secureEndpoint) {
+            return https.Agent.prototype.getName.call(this, options);
+        }
+        return super.getName(options);
+    }
+    createSocket(req, options, cb) {
+        const connectOpts = {
+            ...options,
+            secureEndpoint: this.isSecureEndpoint(options),
+        };
+        const name = this.getName(connectOpts);
+        const fakeSocket = this.incrementSockets(name);
+        Promise.resolve()
+            .then(() => this.connect(req, connectOpts))
+            .then((socket) => {
+            this.decrementSockets(name, fakeSocket);
+            if (socket instanceof http__namespace.Agent) {
+                try {
+                    // @ts-expect-error `addRequest()` isn't defined in `@types/node`
+                    return socket.addRequest(req, connectOpts);
+                }
+                catch (err) {
+                    return cb(err);
+                }
+            }
+            this[INTERNAL].currentSocket = socket;
+            // @ts-expect-error `createSocket()` isn't defined in `@types/node`
+            super.createSocket(req, options, cb);
+        }, (err) => {
+            this.decrementSockets(name, fakeSocket);
+            cb(err);
+        });
+    }
+    createConnection() {
+        const socket = this[INTERNAL].currentSocket;
+        this[INTERNAL].currentSocket = undefined;
+        if (!socket) {
+            throw new Error('No socket was returned in the `connect()` function');
+        }
+        return socket;
+    }
+    get defaultPort() {
+        return (this[INTERNAL].defaultPort ??
+            (this.protocol === 'https:' ? 443 : 80));
+    }
+    set defaultPort(v) {
+        if (this[INTERNAL]) {
+            this[INTERNAL].defaultPort = v;
+        }
+    }
+    get protocol() {
+        return (this[INTERNAL].protocol ??
+            (this.isSecureEndpoint() ? 'https:' : 'http:'));
+    }
+    set protocol(v) {
+        if (this[INTERNAL]) {
+            this[INTERNAL].protocol = v;
+        }
+    }
+}
+
+var srcExports = requireSrc$1();
+var createDebug = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+
+const debug = createDebug('socks-proxy-agent');
+const setServernameFromNonIpHost = (options) => {
+    if (options.servername === undefined &&
+        options.host &&
+        !net__namespace.isIP(options.host)) {
+        return {
+            ...options,
+            servername: options.host,
+        };
+    }
+    return options;
+};
+function parseSocksURL(url) {
+    let lookup = false;
+    let type = 5;
+    const host = url.hostname;
+    // From RFC 1928, Section 3: https://tools.ietf.org/html/rfc1928#section-3
+    // "The SOCKS service is conventionally located on TCP port 1080"
+    const port = parseInt(url.port, 10) || 1080;
+    // figure out if we want socks v4 or v5, based on the "protocol" used.
+    // Defaults to 5.
+    switch (url.protocol.replace(':', '')) {
+        case 'socks4':
+            lookup = true;
+            type = 4;
+            break;
+        // pass through
+        case 'socks4a':
+            type = 4;
+            break;
+        case 'socks5':
+            lookup = true;
+            type = 5;
+            break;
+        // pass through
+        case 'socks': // no version specified, default to 5h
+            type = 5;
+            break;
+        case 'socks5h':
+            type = 5;
+            break;
+        default:
+            throw new TypeError(`A "socks" protocol must be specified! Got: ${String(url.protocol)}`);
+    }
+    const proxy = {
+        host,
+        port,
+        type,
+    };
+    if (url.username) {
+        Object.defineProperty(proxy, 'userId', {
+            value: decodeURIComponent(url.username),
+            enumerable: false,
+        });
+    }
+    if (url.password != null) {
+        Object.defineProperty(proxy, 'password', {
+            value: decodeURIComponent(url.password),
+            enumerable: false,
+        });
+    }
+    return { lookup, proxy };
+}
+class SocksProxyAgent extends Agent {
+    constructor(uri, opts) {
+        super(opts);
+        const url = typeof uri === 'string' ? new require$$2.URL(uri) : uri;
+        const { proxy, lookup } = parseSocksURL(url);
+        this.shouldLookup = lookup;
+        this.proxy = proxy;
+        this.timeout = opts?.timeout ?? null;
+        this.socketOptions = opts?.socketOptions ?? null;
+    }
+    /**
+     * Initiates a SOCKS connection to the specified SOCKS proxy server,
+     * which in turn connects to the specified remote host and port.
+     */
+    async connect(req, opts) {
+        const { shouldLookup, proxy, timeout } = this;
+        if (!opts.host) {
+            throw new Error('No `host` defined!');
+        }
+        let { host } = opts;
+        const { port, lookup: lookupFn = dns__namespace.lookup } = opts;
+        if (shouldLookup) {
+            // Client-side DNS resolution for "4" and "5" socks proxy versions.
+            host = await new Promise((resolve, reject) => {
+                // Use the request's custom lookup, if one was configured:
+                lookupFn(host, {}, (err, address) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(typeof address === 'string'
+                            ? address
+                            : address[0].address);
+                    }
+                });
+            });
+        }
+        const socksOpts = {
+            proxy,
+            destination: {
+                host,
+                port: typeof port === 'number' ? port : parseInt(port, 10),
+            },
+            command: 'connect',
+            timeout: timeout ?? undefined,
+            // @ts-expect-error the type supplied by socks for socket_options is wider
+            // than necessary since socks will always override the host and port
+            socket_options: this.socketOptions ?? undefined,
+        };
+        const cleanup = (tlsSocket) => {
+            req.destroy();
+            socket.destroy();
+            if (tlsSocket)
+                tlsSocket.destroy();
+        };
+        debug('Creating socks proxy connection: %o', socksOpts);
+        const { socket } = await buildExports.SocksClient.createConnection(socksOpts);
+        debug('Successfully created socks proxy connection');
+        if (timeout !== null) {
+            socket.setTimeout(timeout);
+            socket.on('timeout', () => cleanup());
+        }
+        if (opts.secureEndpoint) {
+            // The proxy is connecting to a TLS server, so upgrade
+            // this socket connection to a TLS connection.
+            debug('Upgrading socket connection to TLS');
+            const tlsSocket = require$$1__namespace.connect({
+                ...omit(setServernameFromNonIpHost(opts), 'host', 'path', 'port'),
+                socket,
+            });
+            tlsSocket.once('error', (error) => {
+                debug('Socket TLS error', error.message);
+                cleanup(tlsSocket);
+            });
+            return tlsSocket;
+        }
+        return socket;
+    }
+}
+SocksProxyAgent.protocols = [
+    'socks',
+    'socks4',
+    'socks4a',
+    'socks5',
+    'socks5h',
+];
+function omit(obj, ...keys) {
+    const ret = {};
+    let key;
+    for (key in obj) {
+        if (!keys.includes(key)) {
+            ret[key] = obj[key];
+        }
+    }
+    return ret;
+}
+
+const CONFIG_PATH$1 = process.env.TTMGRC_PATH || path.join(os.homedir(), '.ttmgrc');
+const getTTMGRC = () => {
+    // only check one time
+    if (!fs.existsSync(CONFIG_PATH$1)) {
+        return null;
+    }
+    else {
+        // safe parse
+        let res = JSON.parse(fs.readFileSync(CONFIG_PATH$1, 'utf8'));
+        return res;
+    }
+};
+const setTTMGRC = (config) => {
+    // updata cache config
+    config = config;
+    const originConfig = getTTMGRC() || {};
+    fs.writeFileSync(CONFIG_PATH$1, JSON.stringify({ ...originConfig, ...config }));
+};
+const resetTTMGRC = (config = {}) => {
+    fs.writeFileSync(CONFIG_PATH$1, JSON.stringify(config));
+};
+const getCurrentUser = () => {
+    try {
+        const config = getTTMGRC();
+        return config;
+    }
+    catch (err) {
+        return null;
+    }
+};
+
+// ppe_dev_tool
+function getAxiosProxyConfig() {
+    const config = getTTMGRC();
+    const proxyUrl = config?.proxy;
+    if (proxyUrl) {
+        let agent;
+        if (proxyUrl.startsWith('socks')) {
+            agent = new SocksProxyAgent(proxyUrl);
+        }
+        else {
+            agent = new distExports.HttpsProxyAgent(proxyUrl);
+        }
         // 兼容 http/https 协议
         return {
-            httpsAgent: new distExports.HttpsProxyAgent(proxyUrl),
-            httpAgent: new distExports.HttpsProxyAgent(proxyUrl),
+            httpsAgent: agent,
+            httpAgent: agent,
             proxy: false,
         };
     }
@@ -3816,7 +8469,7 @@ function showTips(context) {
 const zipCwdToBuffer = (customIgnores = []) => {
     return new Promise((resolve, reject) => {
         const chunks = [];
-        const output = new stream.Writable({
+        const output = new require$$2$1.Writable({
             write(chunk, encoding, next) {
                 chunks.push(chunk);
                 next();
@@ -5862,7 +10515,7 @@ const config = {
     }
 };
 
-var version = "0.3.2-beta.8";
+var version = "0.3.2-beta.9";
 var pkg = {
 	version: version};