@ttmg/cli 0.3.8-beta.2 → 0.3.8-beta.3

package/dist/index.js

@@ -584,17 +584,17 @@ var hasRequiredBrowser;
 function requireBrowser () {
 	if (hasRequiredBrowser) return browser.exports;
 	hasRequiredBrowser = 1;
-	(function (module, exports$1) {
+	(function (module, exports) {
 		/**
 		 * This is the web browser implementation of `debug()`.
 		 */
 
-		exports$1.formatArgs = formatArgs;
-		exports$1.save = save;
-		exports$1.load = load;
-		exports$1.useColors = useColors;
-		exports$1.storage = localstorage();
-		exports$1.destroy = (() => {
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
 			let warned = false;
 
 			return () => {
@@ -609,7 +609,7 @@ function requireBrowser () {
 		 * Colors.
 		 */
 
-		exports$1.colors = [
+		exports.colors = [
 			'#0000CC',
 			'#0000FF',
 			'#0033CC',
@@ -774,7 +774,7 @@ function requireBrowser () {
 		 *
 		 * @api public
 		 */
-		exports$1.log = console.debug || console.log || (() => {});
+		exports.log = console.debug || console.log || (() => {});
 
 		/**
 		 * Save `namespaces`.
@@ -785,9 +785,9 @@ function requireBrowser () {
 		function save(namespaces) {
 			try {
 				if (namespaces) {
-					exports$1.storage.setItem('debug', namespaces);
+					exports.storage.setItem('debug', namespaces);
 				} else {
-					exports$1.storage.removeItem('debug');
+					exports.storage.removeItem('debug');
 				}
 			} catch (error) {
 				// Swallow
@@ -804,7 +804,7 @@ function requireBrowser () {
 		function load() {
 			let r;
 			try {
-				r = exports$1.storage.getItem('debug') || exports$1.storage.getItem('DEBUG') ;
+				r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
 			} catch (error) {
 				// Swallow
 				// XXX (@Qix-) should we be logging these?
@@ -840,7 +840,7 @@ function requireBrowser () {
 			}
 		}
 
-		module.exports = requireCommon$1()(exports$1);
+		module.exports = requireCommon$1()(exports);
 
 		const {formatters} = module.exports;
 
@@ -1029,7 +1029,7 @@ var hasRequiredNode;
 function requireNode () {
 	if (hasRequiredNode) return node.exports;
 	hasRequiredNode = 1;
-	(function (module, exports$1) {
+	(function (module, exports) {
 		const tty = require$$1;
 		const util = require$$1$1;
 
@@ -1037,13 +1037,13 @@ function requireNode () {
 		 * This is the Node.js implementation of `debug()`.
 		 */
 
-		exports$1.init = init;
-		exports$1.log = log;
-		exports$1.formatArgs = formatArgs;
-		exports$1.save = save;
-		exports$1.load = load;
-		exports$1.useColors = useColors;
-		exports$1.destroy = util.deprecate(
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.destroy = util.deprecate(
 			() => {},
 			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
 		);
@@ -1052,7 +1052,7 @@ function requireNode () {
 		 * Colors.
 		 */
 
-		exports$1.colors = [6, 2, 3, 4, 5, 1];
+		exports.colors = [6, 2, 3, 4, 5, 1];
 
 		try {
 			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
@@ -1060,7 +1060,7 @@ function requireNode () {
 			const supportsColor = requireSupportsColor();
 
 			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
-				exports$1.colors = [
+				exports.colors = [
 					20,
 					21,
 					26,
@@ -1149,7 +1149,7 @@ function requireNode () {
 		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
 		 */
 
-		exports$1.inspectOpts = Object.keys(process.env).filter(key => {
+		exports.inspectOpts = Object.keys(process.env).filter(key => {
 			return /^debug_/i.test(key);
 		}).reduce((obj, key) => {
 			// Camel-case
@@ -1181,8 +1181,8 @@ function requireNode () {
 		 */
 
 		function useColors() {
-			return 'colors' in exports$1.inspectOpts ?
-				Boolean(exports$1.inspectOpts.colors) :
+			return 'colors' in exports.inspectOpts ?
+				Boolean(exports.inspectOpts.colors) :
 				tty.isatty(process.stderr.fd);
 		}
 
@@ -1208,7 +1208,7 @@ function requireNode () {
 		}
 
 		function getDate() {
-			if (exports$1.inspectOpts.hideDate) {
+			if (exports.inspectOpts.hideDate) {
 				return '';
 			}
 			return new Date().toISOString() + ' ';
@@ -1219,7 +1219,7 @@ function requireNode () {
 		 */
 
 		function log(...args) {
-			return process.stderr.write(util.formatWithOptions(exports$1.inspectOpts, ...args) + '\n');
+			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
 		}
 
 		/**
@@ -1259,13 +1259,13 @@ function requireNode () {
 		function init(debug) {
 			debug.inspectOpts = {};
 
-			const keys = Object.keys(exports$1.inspectOpts);
+			const keys = Object.keys(exports.inspectOpts);
 			for (let i = 0; i < keys.length; i++) {
-				debug.inspectOpts[keys[i]] = exports$1.inspectOpts[keys[i]];
+				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
 			}
 		}
 
-		module.exports = requireCommon$1()(exports$1);
+		module.exports = requireCommon$1()(exports);
 
 		const {formatters} = module.exports;
 
@@ -3354,6 +3354,27 @@ var ipv4 = {};
 
 var common = {};
 
+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 hasRequiredCommon;
 
 function requireCommon () {
@@ -3362,9 +3383,11 @@ function requireCommon () {
 	Object.defineProperty(common, "__esModule", { value: true });
 	common.isInSubnet = isInSubnet;
 	common.isCorrect = isCorrect;
+	common.prefixLengthFromMask = prefixLengthFromMask;
 	common.numberToPaddedHex = numberToPaddedHex;
 	common.stringToPaddedHex = stringToPaddedHex;
 	common.testBit = testBit;
+	const address_error_1 = /*@__PURE__*/ requireAddressError();
 	function isInSubnet(address) {
 	    if (this.subnetMask < address.subnetMask) {
 	        return false;
@@ -3385,6 +3408,25 @@ function requireCommon () {
 	        return this.parsedSubnet === String(this.subnetMask);
 	    };
 	}
+	/**
+	 * Returns the prefix length (number of leading 1 bits) of a contiguous
+	 * subnet mask. Throws `AddressError` if the mask is non-contiguous (e.g.
+	 * `255.0.255.0`).
+	 */
+	function prefixLengthFromMask(value, totalBits) {
+	    const binary = value.toString(2).padStart(totalBits, '0');
+	    if (binary.length > totalBits) {
+	        throw new address_error_1.AddressError('Invalid subnet mask.');
+	    }
+	    const firstZero = binary.indexOf('0');
+	    if (firstZero === -1) {
+	        return totalBits;
+	    }
+	    if (binary.slice(firstZero).includes('1')) {
+	        throw new address_error_1.AddressError('Invalid subnet mask.');
+	    }
+	    return firstZero;
+	}
 	function numberToPaddedHex(number) {
 	    return number.toString(16).padStart(2, '0');
 	}
@@ -3424,27 +3466,6 @@ function requireConstants$1 () {
 	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 () {
@@ -3476,12 +3497,12 @@ function requireIpv4 () {
 	};
 	Object.defineProperty(ipv4, "__esModule", { value: true });
 	ipv4.Address4 = void 0;
-	const common = __importStar(requireCommon());
-	const constants = __importStar(requireConstants$1());
-	const address_error_1 = requireAddressError();
+	const common = __importStar(/*@__PURE__*/ requireCommon());
+	const constants = __importStar(/*@__PURE__*/ requireConstants$1());
+	const address_error_1 = /*@__PURE__*/ requireAddressError();
+	const isCorrect4 = common.isCorrect(constants.BITS);
 	/**
 	 * Represents an IPv4 address
-	 * @class Address4
 	 * @param {string} address - An IPv4 address string
 	 */
 	class Address4 {
@@ -3494,15 +3515,11 @@ function requireIpv4 () {
 	        this.v4 = true;
 	        /**
 	         * Returns true if the address is correct, false otherwise
-	         * @memberof Address4
-	         * @instance
 	         * @returns {Boolean}
 	         */
-	        this.isCorrect = common.isCorrect(constants.BITS);
+	        this.isCorrect = isCorrect4;
 	        /**
 	         * Returns true if the given address is in the subnet of the current address
-	         * @memberof Address4
-	         * @instance
 	         * @returns {boolean}
 	         */
 	        this.isInSubnet = common.isInSubnet;
@@ -3520,6 +3537,13 @@ function requireIpv4 () {
 	        this.addressMinusSuffix = address;
 	        this.parsedAddress = this.parse(address);
 	    }
+	    /**
+	     * Returns true if the given string is a valid IPv4 address (with optional
+	     * CIDR subnet), false otherwise. Host bits in the subnet portion are
+	     * allowed (e.g. `192.168.1.5/24` is valid); for strict network-address
+	     * validation compare `correctForm()` to `startAddress().correctForm()`,
+	     * or use `networkForm()`.
+	     */
 	    static isValid(address) {
 	        try {
 	            // eslint-disable-next-line no-new
@@ -3530,8 +3554,11 @@ function requireIpv4 () {
 	            return false;
 	        }
 	    }
-	    /*
-	     * Parses a v4 address
+	    /**
+	     * Parses an IPv4 address string into its four octet groups and stores the
+	     * result on `this.parsedAddress`. Called automatically by the constructor;
+	     * you typically don't need to call it directly. Throws `AddressError` if
+	     * the input is not a valid IPv4 address.
 	     */
 	    parse(address) {
 	        const groups = address.split('.');
@@ -3541,45 +3568,110 @@ function requireIpv4 () {
 	        return groups;
 	    }
 	    /**
-	     * Returns the correct form of an address
-	     * @memberof Address4
-	     * @instance
-	     * @returns {String}
+	     * Returns the address in correct form: octets joined with `.` and any
+	     * leading zeros stripped (e.g. `192.168.1.1`). For IPv4 this matches the
+	     * canonical dotted-decimal representation.
 	     */
 	    correctForm() {
 	        return this.parsedAddress.map((part) => parseInt(part, 10)).join('.');
 	    }
 	    /**
-	     * Converts a hex string to an IPv4 address object
-	     * @memberof Address4
-	     * @static
+	     * Construct an `Address4` from an address and a dotted-decimal subnet
+	     * mask given as separate strings (e.g. as returned by Node's
+	     * `os.networkInterfaces()`). Throws `AddressError` if the mask is
+	     * non-contiguous (e.g. `255.0.255.0`).
+	     * @example
+	     * var address = Address4.fromAddressAndMask('192.168.1.1', '255.255.255.0');
+	     * address.subnetMask; // 24
+	     */
+	    static fromAddressAndMask(address, mask) {
+	        const bits = common.prefixLengthFromMask(new Address4(mask).bigInt(), constants.BITS);
+	        return new Address4(`${address}/${bits}`);
+	    }
+	    /**
+	     * Construct an `Address4` from an address and a Cisco-style wildcard mask
+	     * given as separate strings (e.g. `0.0.0.255` for a `/24`). The wildcard
+	     * mask is the bitwise inverse of the subnet mask. Throws `AddressError`
+	     * if the mask is non-contiguous (e.g. `0.255.0.255`).
+	     * @example
+	     * var address = Address4.fromAddressAndWildcardMask('10.0.0.1', '0.0.0.255');
+	     * address.subnetMask; // 24
+	     */
+	    static fromAddressAndWildcardMask(address, wildcardMask) {
+	        const wildcard = new Address4(wildcardMask).bigInt();
+	        const allOnes = (BigInt(1) << BigInt(constants.BITS)) - BigInt(1);
+	        // eslint-disable-next-line no-bitwise
+	        const mask = wildcard ^ allOnes;
+	        const bits = common.prefixLengthFromMask(mask, constants.BITS);
+	        return new Address4(`${address}/${bits}`);
+	    }
+	    /**
+	     * Construct an `Address4` from a wildcard pattern with trailing `*`
+	     * octets. The number of trailing wildcards determines the prefix
+	     * length: each `*` represents 8 bits.
+	     *
+	     * Only trailing whole-octet wildcards are supported. Partial-octet
+	     * wildcards (e.g. `192.168.0.1*`) and interior wildcards (e.g.
+	     * `192.*.0.1`) throw `AddressError`.
+	     * @example
+	     * Address4.fromWildcard('192.168.0.*').subnet;   // '/24'
+	     * Address4.fromWildcard('192.168.*.*').subnet;   // '/16'
+	     * Address4.fromWildcard('*.*.*.*').subnet;       // '/0'
+	     */
+	    static fromWildcard(input) {
+	        const groups = input.split('.');
+	        if (groups.length !== constants.GROUPS) {
+	            throw new address_error_1.AddressError('Wildcard pattern must have 4 octets');
+	        }
+	        let firstWildcard = -1;
+	        for (let i = 0; i < groups.length; i++) {
+	            if (groups[i] === '*') {
+	                if (firstWildcard === -1) {
+	                    firstWildcard = i;
+	                }
+	            }
+	            else if (firstWildcard !== -1) {
+	                throw new address_error_1.AddressError('Wildcard `*` must only appear in trailing octets (e.g. `192.168.0.*`)');
+	            }
+	        }
+	        const trailing = firstWildcard === -1 ? 0 : groups.length - firstWildcard;
+	        const replaced = groups.map((g) => (g === '*' ? '0' : g));
+	        const subnetBits = constants.BITS - trailing * 8;
+	        return new Address4(`${replaced.join('.')}/${subnetBits}`);
+	    }
+	    /**
+	     * Converts a hex string to an IPv4 address object. Accepts 8 hex digits
+	     * with optional `:` separators (e.g. `'7f000001'` or `'7f:00:00:01'`).
+	     * Throws `AddressError` for any other length or for non-hex characters.
 	     * @param {string} hex - a hex string to convert
 	     * @returns {Address4}
 	     */
 	    static fromHex(hex) {
-	        const padded = hex.replace(/:/g, '').padStart(8, '0');
+	        const stripped = hex.replace(/:/g, '');
+	        if (!/^[0-9a-fA-F]{8}$/.test(stripped)) {
+	            throw new address_error_1.AddressError('IPv4 hex must be exactly 8 hex digits');
+	        }
 	        const groups = [];
-	        let i;
-	        for (i = 0; i < 8; i += 2) {
-	            const h = padded.slice(i, i + 2);
-	            groups.push(parseInt(h, 16));
+	        for (let i = 0; i < 8; i += 2) {
+	            groups.push(parseInt(stripped.slice(i, i + 2), 16));
 	        }
 	        return new Address4(groups.join('.'));
 	    }
 	    /**
-	     * Converts an integer into a IPv4 address object
-	     * @memberof Address4
-	     * @static
+	     * Converts an integer into a IPv4 address object. The integer must be a
+	     * non-negative safe integer in the range `[0, 2**32 - 1]`; otherwise
+	     * `AddressError` is thrown.
 	     * @param {integer} integer - a number to convert
 	     * @returns {Address4}
 	     */
 	    static fromInteger(integer) {
-	        return Address4.fromHex(integer.toString(16));
+	        if (!Number.isInteger(integer) || integer < 0 || integer > 0xffffffff) {
+	            throw new address_error_1.AddressError('IPv4 integer must be in the range 0 to 2**32 - 1');
+	        }
+	        return Address4.fromHex(integer.toString(16).padStart(8, '0'));
 	    }
 	    /**
 	     * Return an address from in-addr.arpa form
-	     * @memberof Address4
-	     * @static
 	     * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address
 	     * @returns {Adress4}
 	     * @example
@@ -3594,17 +3686,15 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * 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
+	     * Converts an IPv4 address object to an array of bytes.
+	     *
+	     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toArray())`.
 	     * @returns {Array}
 	     */
 	    toArray() {
@@ -3612,8 +3702,6 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * Converts an IPv4 address object to an IPv6 address group
-	     * @memberof Address4
-	     * @instance
 	     * @returns {String}
 	     */
 	    toGroup6() {
@@ -3626,8 +3714,6 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * Returns the address as a `bigint`
-	     * @memberof Address4
-	     * @instance
 	     * @returns {bigint}
 	     */
 	    bigInt() {
@@ -3635,8 +3721,6 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * Helper function getting start address.
-	     * @memberof Address4
-	     * @instance
 	     * @returns {bigint}
 	     */
 	    _startAddress() {
@@ -3645,8 +3729,6 @@ function requireIpv4 () {
 	    /**
 	     * The first address in the range given by this address' subnet.
 	     * Often referred to as the Network Address.
-	     * @memberof Address4
-	     * @instance
 	     * @returns {Address4}
 	     */
 	    startAddress() {
@@ -3655,8 +3737,6 @@ function requireIpv4 () {
 	    /**
 	     * 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() {
@@ -3665,8 +3745,6 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * Helper function getting end address.
-	     * @memberof Address4
-	     * @instance
 	     * @returns {bigint}
 	     */
 	    _endAddress() {
@@ -3675,8 +3753,6 @@ function requireIpv4 () {
 	    /**
 	     * The last address in the range given by this address' subnet
 	     * Often referred to as the Broadcast
-	     * @memberof Address4
-	     * @instance
 	     * @returns {Address4}
 	     */
 	    endAddress() {
@@ -3685,8 +3761,6 @@ function requireIpv4 () {
 	    /**
 	     * 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() {
@@ -3694,19 +3768,47 @@ function requireIpv4 () {
 	        return Address4.fromBigInt(this._endAddress() - adjust);
 	    }
 	    /**
-	     * Converts a BigInt to a v4 address object
-	     * @memberof Address4
-	     * @static
+	     * The dotted-decimal form of the subnet mask, e.g. `255.255.240.0` for
+	     * a `/20`. Returns an `Address4`; call `.correctForm()` for the string.
+	     * @returns {Address4}
+	     */
+	    subnetMaskAddress() {
+	        return Address4.fromBigInt(BigInt(`0b${'1'.repeat(this.subnetMask)}${'0'.repeat(constants.BITS - this.subnetMask)}`));
+	    }
+	    /**
+	     * The Cisco-style wildcard mask, e.g. `0.0.0.255` for a `/24`. This is
+	     * the bitwise inverse of `subnetMaskAddress()`. Returns an `Address4`;
+	     * call `.correctForm()` for the string.
+	     * @returns {Address4}
+	     */
+	    wildcardMask() {
+	        return Address4.fromBigInt(BigInt(`0b${'0'.repeat(this.subnetMask)}${'1'.repeat(constants.BITS - this.subnetMask)}`));
+	    }
+	    /**
+	     * The network address in CIDR string form, e.g. `192.168.1.0/24` for
+	     * `192.168.1.5/24`. For an address with no explicit subnet the prefix is
+	     * `/32`, e.g. `networkForm()` on `192.168.1.5` returns `192.168.1.5/32`.
+	     * @returns {string}
+	     */
+	    networkForm() {
+	        return `${this.startAddress().correctForm()}/${this.subnetMask}`;
+	    }
+	    /**
+	     * Converts a BigInt to a v4 address object. The value must be in the
+	     * range `[0, 2**32 - 1]`; otherwise `AddressError` is thrown.
 	     * @param {bigint} bigInt - a BigInt to convert
 	     * @returns {Address4}
 	     */
 	    static fromBigInt(bigInt) {
-	        return Address4.fromHex(bigInt.toString(16));
+	        if (bigInt < 0n || bigInt > 0xffffffffn) {
+	            throw new address_error_1.AddressError('IPv4 BigInt must be in the range 0 to 2**32 - 1');
+	        }
+	        return Address4.fromHex(bigInt.toString(16).padStart(8, '0'));
 	    }
 	    /**
-	     * Convert a byte array to an Address4 object
-	     * @memberof Address4
-	     * @static
+	     * Convert a byte array to an Address4 object.
+	     *
+	     * To convert from a Node.js `Buffer`, spread it: `Address4.fromByteArray([...buf])`.
 	     * @param {Array<number>} bytes - an array of 4 bytes (0-255)
 	     * @returns {Address4}
 	     */
@@ -3724,8 +3826,6 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * 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}
 	     */
@@ -3739,8 +3839,6 @@ function requireIpv4 () {
 	    /**
 	     * Returns the first n bits of the address, defaulting to the
 	     * subnet mask
-	     * @memberof Address4
-	     * @instance
 	     * @returns {String}
 	     */
 	    mask(mask) {
@@ -3751,8 +3849,6 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * Returns the bits in the given range as a base-2 string
-	     * @memberof Address4
-	     * @instance
 	     * @returns {string}
 	     */
 	    getBitsBase2(start, end) {
@@ -3760,10 +3856,8 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * 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) {
@@ -3778,21 +3872,62 @@ function requireIpv4 () {
 	    }
 	    /**
 	     * 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'));
+	        return this.isInSubnet(MULTICAST_V4);
+	    }
+	    /**
+	     * Returns true if the address is in one of the [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private address ranges (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`).
+	     * @returns {boolean}
+	     */
+	    isPrivate() {
+	        return PRIVATE_V4.some((subnet) => this.isInSubnet(subnet));
+	    }
+	    /**
+	     * Returns true if the address is in the loopback range `127.0.0.0/8` ([RFC 1122](https://datatracker.ietf.org/doc/html/rfc1122)).
+	     * @returns {boolean}
+	     */
+	    isLoopback() {
+	        return this.isInSubnet(LOOPBACK_V4);
+	    }
+	    /**
+	     * Returns true if the address is in the link-local range `169.254.0.0/16` ([RFC 3927](https://datatracker.ietf.org/doc/html/rfc3927)).
+	     * @returns {boolean}
+	     */
+	    isLinkLocal() {
+	        return this.isInSubnet(LINK_LOCAL_V4);
+	    }
+	    /**
+	     * Returns true if the address is the unspecified address `0.0.0.0`.
+	     * @returns {boolean}
+	     */
+	    isUnspecified() {
+	        return this.isInSubnet(UNSPECIFIED_V4);
+	    }
+	    /**
+	     * Returns true if the address is the limited broadcast address `255.255.255.255` ([RFC 919](https://datatracker.ietf.org/doc/html/rfc919)).
+	     * @returns {boolean}
+	     */
+	    isBroadcast() {
+	        return this.isInSubnet(BROADCAST_V4);
+	    }
+	    /**
+	     * Returns true if the address is in the carrier-grade NAT range `100.64.0.0/10` ([RFC 6598](https://datatracker.ietf.org/doc/html/rfc6598)).
+	     * @returns {boolean}
+	     */
+	    isCGNAT() {
+	        return this.isInSubnet(CGNAT_V4);
 	    }
 	    /**
 	     * 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');
+	        if (this._binaryZeroPad === undefined) {
+	            this._binaryZeroPad = this.bigInt().toString(2).padStart(constants.BITS, '0');
+	        }
+	        return this._binaryZeroPad;
 	    }
 	    /**
 	     * Groups an IPv4 address for inclusion at the end of an IPv6 address
@@ -3808,6 +3943,17 @@ function requireIpv4 () {
 	    }
 	}
 	ipv4.Address4 = Address4;
+	const MULTICAST_V4 = new Address4('224.0.0.0/4');
+	const PRIVATE_V4 = [
+	    new Address4('10.0.0.0/8'),
+	    new Address4('172.16.0.0/12'),
+	    new Address4('192.168.0.0/16'),
+	];
+	const LOOPBACK_V4 = new Address4('127.0.0.0/8');
+	const LINK_LOCAL_V4 = new Address4('169.254.0.0/16');
+	const UNSPECIFIED_V4 = new Address4('0.0.0.0/32');
+	const BROADCAST_V4 = new Address4('255.255.255.255/32');
+	const CGNAT_V4 = new Address4('100.64.0.0/10');
 	
 	return ipv4;
 }
@@ -3868,6 +4014,11 @@ function requireConstants () {
 	    '::1/128': 'Loopback',
 	    'ff00::/8': 'Multicast',
 	    'fe80::/10': 'Link-local unicast',
+	    'fc00::/7': 'Unique local',
+	    '2002::/16': '6to4',
+	    '2001:db8::/32': 'Documentation',
+	    '64:ff9b::/96': 'NAT64 (well-known)',
+	    '64:ff9b:1::/48': 'NAT64 (local-use)',
 	};
 	/**
 	 * A regular expression that matches bad characters in an IPv6 address
@@ -3907,15 +4058,24 @@ function requireHelpers$1 () {
 	if (hasRequiredHelpers$1) return helpers;
 	hasRequiredHelpers$1 = 1;
 	Object.defineProperty(helpers, "__esModule", { value: true });
+	helpers.escapeHtml = escapeHtml;
 	helpers.spanAllZeroes = spanAllZeroes;
 	helpers.spanAll = spanAll;
 	helpers.spanLeadingZeroes = spanLeadingZeroes;
 	helpers.simpleGroup = simpleGroup;
+	function escapeHtml(s) {
+	    return s
+	        .replace(/&/g, '&amp;')
+	        .replace(/</g, '&lt;')
+	        .replace(/>/g, '&gt;')
+	        .replace(/"/g, '&quot;')
+	        .replace(/'/g, '&#39;');
+	}
 	/**
 	 * @returns {String} the string with all zeroes contained in a <span>
 	 */
 	function spanAllZeroes(s) {
-	    return s.replace(/(0+)/g, '<span class="zero">$1</span>');
+	    return escapeHtml(s).replace(/(0+)/g, '<span class="zero">$1</span>');
 	}
 	/**
 	 * @returns {String} the string with each character contained in a <span>
@@ -3923,11 +4083,11 @@ function requireHelpers$1 () {
 	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>`)
+	        .map((n, i) => `<span class="digit value-${escapeHtml(n)} position-${i + offset}">${spanAllZeroes(n)}</span>`)
 	        .join('');
 	}
 	function spanLeadingZeroesSimple(group) {
-	    return group.replace(/^(0+)/, '<span class="zero">$1</span>');
+	    return escapeHtml(group).replace(/^(0+)/, '<span class="zero">$1</span>');
 	}
 	/**
 	 * @returns {String} the string with leading zeroes contained in a <span>
@@ -3989,7 +4149,7 @@ function requireRegularExpressions () {
 	regularExpressions.padGroup = padGroup;
 	regularExpressions.simpleRegularExpression = simpleRegularExpression;
 	regularExpressions.possibleElisions = possibleElisions;
-	const v6 = __importStar(requireConstants());
+	const v6 = __importStar(/*@__PURE__*/ requireConstants());
 	function groupPossibilities(possibilities) {
 	    return `(${possibilities.join('|')})`;
 	}
@@ -4089,14 +4249,15 @@ function requireIpv6 () {
 	};
 	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();
+	const common = __importStar(/*@__PURE__*/ requireCommon());
+	const constants4 = __importStar(/*@__PURE__*/ requireConstants$1());
+	const constants6 = __importStar(/*@__PURE__*/ requireConstants());
+	const helpers = __importStar(/*@__PURE__*/ requireHelpers$1());
+	const ipv4_1 = /*@__PURE__*/ requireIpv4();
+	const regular_expressions_1 = /*@__PURE__*/ requireRegularExpressions();
+	const address_error_1 = /*@__PURE__*/ requireAddressError();
+	const common_1 = /*@__PURE__*/ requireCommon();
+	const isCorrect6 = common.isCorrect(constants6.BITS);
 	function assert(condition) {
 	    if (!condition) {
 	        throw new Error('Assertion failed.');
@@ -4140,7 +4301,6 @@ function requireIpv6 () {
 	}
 	/**
 	 * Represents an IPv6 address
-	 * @class Address6
 	 * @param {string} address - An IPv6 address string
 	 * @param {number} [groups=8] - How many octets to parse
 	 * @example
@@ -4157,18 +4317,14 @@ function requireIpv6 () {
 	        // #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);
+	        this.isCorrect = isCorrect6;
 	        if (optionalGroups === undefined) {
 	            this.groups = constants6.GROUPS;
 	        }
@@ -4199,6 +4355,13 @@ function requireIpv6 () {
 	        this.addressMinusSuffix = address;
 	        this.parsedAddress = this.parse(this.addressMinusSuffix);
 	    }
+	    /**
+	     * Returns true if the given string is a valid IPv6 address (with optional
+	     * CIDR subnet and zone identifier), false otherwise. Host bits in the
+	     * subnet portion are allowed (e.g. `2001:db8::1/32` is valid); for strict
+	     * network-address validation compare `correctForm()` to
+	     * `startAddress().correctForm()`, or use `networkForm()`.
+	     */
 	    static isValid(address) {
 	        try {
 	            // eslint-disable-next-line no-new
@@ -4210,9 +4373,8 @@ function requireIpv6 () {
 	        }
 	    }
 	    /**
-	     * Convert a BigInt to a v6 address object
-	     * @memberof Address6
-	     * @static
+	     * Convert a BigInt to a v6 address object. The value must be in the
+	     * range `[0, 2**128 - 1]`; otherwise `AddressError` is thrown.
 	     * @param {bigint} bigInt - a BigInt to convert
 	     * @returns {Address6}
 	     * @example
@@ -4221,19 +4383,21 @@ function requireIpv6 () {
 	     * address.correctForm(); // '::e8:d4a5:1000'
 	     */
 	    static fromBigInt(bigInt) {
+	        if (bigInt < 0n || bigInt > (1n << BigInt(constants6.BITS)) - 1n) {
+	            throw new address_error_1.AddressError('IPv6 BigInt must be in the range 0 to 2**128 - 1');
+	        }
 	        const hex = bigInt.toString(16).padStart(32, '0');
 	        const groups = [];
-	        let i;
-	        for (i = 0; i < constants6.GROUPS; i++) {
+	        for (let 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
+	     * Parse a URL (with optional bracketed host and port) into an address and
+	     * port. Returns either `{ address, port }` on success or
+	     * `{ error, address: null, port: null }` if the URL could not be parsed.
+	     * Ports are returned as numbers (or `null` if absent or out of range).
 	     * @example
 	     * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');
 	     * addressAndPort.address.correctForm(); // 'ffff::'
@@ -4292,10 +4456,92 @@ function requireIpv6 () {
 	            port,
 	        };
 	    }
+	    /**
+	     * Construct an `Address6` from an address and a hex subnet mask given as
+	     * separate strings (e.g. as returned by Node's `os.networkInterfaces()`).
+	     * Throws `AddressError` if the mask is non-contiguous (e.g.
+	     * `ffff::ffff`).
+	     * @example
+	     * var address = Address6.fromAddressAndMask('fe80::1', 'ffff:ffff:ffff:ffff::');
+	     * address.subnetMask; // 64
+	     */
+	    static fromAddressAndMask(address, mask) {
+	        const bits = common.prefixLengthFromMask(new Address6(mask).bigInt(), constants6.BITS);
+	        return new Address6(`${address}/${bits}`);
+	    }
+	    /**
+	     * Construct an `Address6` from an address and a Cisco-style wildcard mask
+	     * given as separate strings (e.g. `::ffff:ffff:ffff:ffff` for a `/64`).
+	     * The wildcard mask is the bitwise inverse of the subnet mask. Throws
+	     * `AddressError` if the mask is non-contiguous.
+	     * @example
+	     * var address = Address6.fromAddressAndWildcardMask('fe80::1', '::ffff:ffff:ffff:ffff');
+	     * address.subnetMask; // 64
+	     */
+	    static fromAddressAndWildcardMask(address, wildcardMask) {
+	        const wildcard = new Address6(wildcardMask).bigInt();
+	        const allOnes = (BigInt(1) << BigInt(constants6.BITS)) - BigInt(1);
+	        // eslint-disable-next-line no-bitwise
+	        const mask = wildcard ^ allOnes;
+	        const bits = common.prefixLengthFromMask(mask, constants6.BITS);
+	        return new Address6(`${address}/${bits}`);
+	    }
+	    /**
+	     * Construct an `Address6` from a wildcard pattern with trailing `*`
+	     * groups. The number of trailing wildcards determines the prefix
+	     * length: each `*` represents 16 bits. `::` is expanded to zero groups
+	     * (not wildcards) before evaluating trailing wildcards.
+	     *
+	     * Only trailing whole-group wildcards are supported. Partial-group
+	     * wildcards (e.g. `2001:db8::0*`) and interior wildcards (e.g.
+	     * `*::1`) throw `AddressError`.
+	     * @example
+	     * Address6.fromWildcard('2001:db8:*:*:*:*:*:*').subnet;  // '/32'
+	     * Address6.fromWildcard('2001:db8::*').subnet;           // '/112'
+	     * Address6.fromWildcard('*:*:*:*:*:*:*:*').subnet;       // '/0'
+	     */
+	    static fromWildcard(input) {
+	        if (input.includes('%') || input.includes('/')) {
+	            throw new address_error_1.AddressError('Wildcard pattern must not include a zone or CIDR suffix');
+	        }
+	        const halves = input.split('::');
+	        if (halves.length > 2) {
+	            throw new address_error_1.AddressError("Wildcard pattern cannot contain more than one '::'");
+	        }
+	        let groups;
+	        if (halves.length === 2) {
+	            const left = halves[0] === '' ? [] : halves[0].split(':');
+	            const right = halves[1] === '' ? [] : halves[1].split(':');
+	            const remaining = constants6.GROUPS - left.length - right.length;
+	            if (remaining < 1) {
+	                throw new address_error_1.AddressError("Wildcard pattern with '::' has too many groups");
+	            }
+	            groups = [...left, ...new Array(remaining).fill('0'), ...right];
+	        }
+	        else {
+	            groups = input.split(':');
+	        }
+	        if (groups.length !== constants6.GROUPS) {
+	            throw new address_error_1.AddressError('Wildcard pattern must have 8 groups');
+	        }
+	        let firstWildcard = -1;
+	        for (let i = 0; i < groups.length; i++) {
+	            if (groups[i] === '*') {
+	                if (firstWildcard === -1) {
+	                    firstWildcard = i;
+	                }
+	            }
+	            else if (firstWildcard !== -1) {
+	                throw new address_error_1.AddressError('Wildcard `*` must only appear in trailing groups (e.g. `2001:db8:*:*:*:*:*:*`)');
+	            }
+	        }
+	        const trailing = firstWildcard === -1 ? 0 : groups.length - firstWildcard;
+	        const replaced = groups.map((g) => (g === '*' ? '0' : g));
+	        const subnetBits = constants6.BITS - trailing * 16;
+	        return new Address6(`${replaced.join(':')}/${subnetBits}`);
+	    }
 	    /**
 	     * Create an IPv6-mapped address given an IPv4 address
-	     * @memberof Address6
-	     * @static
 	     * @param {string} address - An IPv4 address string
 	     * @returns {Address6}
 	     * @example
@@ -4310,8 +4556,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Return an address from ip6.arpa form
-	     * @memberof Address6
-	     * @static
 	     * @param {string} arpaFormAddress - an 'ip6.arpa' form address
 	     * @returns {Adress6}
 	     * @example
@@ -4336,8 +4580,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Return the Microsoft UNC transcription of the address
-	     * @memberof Address6
-	     * @instance
 	     * @returns {String} the Microsoft UNC transcription of the address
 	     */
 	    microsoftTranscription() {
@@ -4345,8 +4587,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * 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
 	     */
@@ -4355,8 +4595,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * 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}
 	     */
@@ -4372,8 +4610,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Helper function getting start address.
-	     * @memberof Address6
-	     * @instance
 	     * @returns {bigint}
 	     */
 	    _startAddress() {
@@ -4382,8 +4618,6 @@ function requireIpv6 () {
 	    /**
 	     * The first address in the range given by this address' subnet
 	     * Often referred to as the Network Address.
-	     * @memberof Address6
-	     * @instance
 	     * @returns {Address6}
 	     */
 	    startAddress() {
@@ -4392,8 +4626,6 @@ function requireIpv6 () {
 	    /**
 	     * 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() {
@@ -4402,8 +4634,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Helper function getting end address.
-	     * @memberof Address6
-	     * @instance
 	     * @returns {bigint}
 	     */
 	    _endAddress() {
@@ -4412,8 +4642,6 @@ function requireIpv6 () {
 	    /**
 	     * The last address in the range given by this address' subnet
 	     * Often referred to as the Broadcast
-	     * @memberof Address6
-	     * @instance
 	     * @returns {Address6}
 	     */
 	    endAddress() {
@@ -4422,8 +4650,6 @@ function requireIpv6 () {
 	    /**
 	     * 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() {
@@ -4431,36 +4657,73 @@ function requireIpv6 () {
 	        return Address6.fromBigInt(this._endAddress() - adjust);
 	    }
 	    /**
-	     * Return the scope of the address
-	     * @memberof Address6
-	     * @instance
+	     * The hex form of the subnet mask, e.g. `ffff:ffff:ffff:ffff::` for a
+	     * `/64`. Returns an `Address6`; call `.correctForm()` for the string.
+	     * @returns {Address6}
+	     */
+	    subnetMaskAddress() {
+	        return Address6.fromBigInt(BigInt(`0b${'1'.repeat(this.subnetMask)}${'0'.repeat(constants6.BITS - this.subnetMask)}`));
+	    }
+	    /**
+	     * The Cisco-style wildcard mask, e.g. `::ffff:ffff:ffff:ffff` for a
+	     * `/64`. This is the bitwise inverse of `subnetMaskAddress()`. Returns
+	     * an `Address6`; call `.correctForm()` for the string.
+	     * @returns {Address6}
+	     */
+	    wildcardMask() {
+	        return Address6.fromBigInt(BigInt(`0b${'0'.repeat(this.subnetMask)}${'1'.repeat(constants6.BITS - this.subnetMask)}`));
+	    }
+	    /**
+	     * The network address in CIDR string form, e.g. `2001:db8::/32` for
+	     * `2001:db8::1/32`. For an address with no explicit subnet the prefix
+	     * is `/128`, e.g. `networkForm()` on `2001:db8::1` returns
+	     * `2001:db8::1/128`.
+	     * @returns {string}
+	     */
+	    networkForm() {
+	        return `${this.startAddress().correctForm()}/${this.subnetMask}`;
+	    }
+	    /**
+	     * Return the scope of the address. The 4-bit scope field
+	     * ([RFC 4291 §2.7](https://datatracker.ietf.org/doc/html/rfc4291#section-2.7))
+	     * is only defined for multicast addresses; for unicast addresses the scope
+	     * is derived from the address type per
+	     * [RFC 4007 §6](https://datatracker.ietf.org/doc/html/rfc4007#section-6).
 	     * @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';
+	        const type = this.getType();
+	        if (type === 'Multicast' || type.startsWith('Multicast ')) {
+	            const scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)];
+	            return scope || 'Unknown';
 	        }
-	        return scope || 'Unknown';
+	        // RFC 4291 §2.5.3: the loopback address is treated as having Link-Local
+	        // scope. (Multicast scope 1, "Interface-Local", is a different concept
+	        // used only for loopback transmission of multicast.)
+	        if (type === 'Link-local unicast' || type === 'Loopback') {
+	            return 'Link local';
+	        }
+	        // RFC 4007 §6: the unspecified address has no scope.
+	        if (type === 'Unspecified') {
+	            return 'Unknown';
+	        }
+	        return 'Global';
 	    }
 	    /**
 	     * 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];
+	        for (let i = 0; i < TYPE_SUBNETS.length; i++) {
+	            const entry = TYPE_SUBNETS[i];
+	            if (this.isInSubnet(entry[0])) {
+	                return entry[1];
 	            }
 	        }
 	        return 'Global unicast';
 	    }
 	    /**
 	     * Return the bits in the given range as a BigInt
-	     * @memberof Address6
-	     * @instance
 	     * @returns {bigint}
 	     */
 	    getBits(start, end) {
@@ -4468,8 +4731,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Return the bits in the given range as a base-2 string
-	     * @memberof Address6
-	     * @instance
 	     * @returns {String}
 	     */
 	    getBitsBase2(start, end) {
@@ -4477,8 +4738,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Return the bits in the given range as a base-16 string
-	     * @memberof Address6
-	     * @instance
 	     * @returns {String}
 	     */
 	    getBitsBase16(start, end) {
@@ -4492,8 +4751,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Return the bits that are set past the subnet mask length
-	     * @memberof Address6
-	     * @instance
 	     * @returns {String}
 	     */
 	    getBitsPastSubnet() {
@@ -4501,10 +4758,8 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * 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) {
@@ -4530,10 +4785,10 @@ function requireIpv6 () {
 	        return 'ip6.arpa.';
 	    }
 	    /**
-	     * Return the correct form of the address
-	     * @memberof Address6
-	     * @instance
-	     * @returns {String}
+	     * Returns the address in correct form, per
+	     * [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952): leading zeros
+	     * stripped, the longest run of zero groups collapsed to `::`, and hex digits
+	     * lowercased (e.g. `2001:db8::1`). This is the recommended form for display.
 	     */
 	    correctForm() {
 	        let i;
@@ -4577,8 +4832,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * 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');
@@ -4587,10 +4840,22 @@ function requireIpv6 () {
 	     * //  0000000000000000000000000000000000000000000000000001000000010001'
 	     */
 	    binaryZeroPad() {
-	        return this.bigInt().toString(2).padStart(constants6.BITS, '0');
+	        if (this._binaryZeroPad === undefined) {
+	            this._binaryZeroPad = this.bigInt().toString(2).padStart(constants6.BITS, '0');
+	        }
+	        return this._binaryZeroPad;
 	    }
+	    /**
+	     * Parses a v4-in-v6 string (e.g. `::ffff:192.168.0.1`) by extracting the
+	     * trailing IPv4 address into `this.address4` / `this.parsedAddress4` and
+	     * returning the address with the v4 portion converted to two v6 groups.
+	     * Used internally by `parse()`.
+	     */
 	    // TODO: Improve the semantics of this helper function
 	    parse4in6(address) {
+	        if (address.indexOf('.') === -1) {
+	            return address;
+	        }
 	        const groups = address.split(':');
 	        const lastGroup = groups.slice(-1)[0];
 	        const address4 = lastGroup.match(constants4.RE_ADDRESS);
@@ -4599,7 +4864,12 @@ function requireIpv6 () {
 	            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('.')));
+	                    // The prefix groups haven't been through the bad-character check
+	                    // yet, so escape them before including in the error HTML.
+	                    const highlighted = this.address4.parsedAddress.map(spanLeadingZeroes4).join('.');
+	                    const prefix = groups.slice(0, -1).map(helpers.escapeHtml).join(':');
+	                    const separator = groups.length > 1 ? ':' : '';
+	                    throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", `${prefix}${separator}${highlighted}`);
 	                }
 	            }
 	            this.v4 = true;
@@ -4608,6 +4878,13 @@ function requireIpv6 () {
 	        }
 	        return address;
 	    }
+	    /**
+	     * Parses an IPv6 address string into its 8 hexadecimal groups (expanding
+	     * any `::` elision and any trailing v4-in-v6 portion) and stores the result
+	     * on `this.parsedAddress`. Called automatically by the constructor; you
+	     * typically don't need to call it directly. Throws `AddressError` if the
+	     * input is malformed.
+	     */
 	    // TODO: Make private?
 	    parse(address) {
 	        address = this.parse4in6(address);
@@ -4657,18 +4934,16 @@ function requireIpv6 () {
 	        return groups;
 	    }
 	    /**
-	     * Return the canonical form of the address
-	     * @memberof Address6
-	     * @instance
-	     * @returns {String}
+	     * Returns the canonical (fully expanded) form of the address: all 8 groups,
+	     * each padded to 4 hex digits, with no `::` collapsing
+	     * (e.g. `2001:0db8:0000:0000:0000:0000:0000:0001`). Useful for sorting and
+	     * byte-exact comparison.
 	     */
 	    canonicalForm() {
 	        return this.parsedAddress.map(paddedHex).join(':');
 	    }
 	    /**
 	     * Return the decimal form of the address
-	     * @memberof Address6
-	     * @instance
 	     * @returns {String}
 	     */
 	    decimal() {
@@ -4676,8 +4951,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Return the address as a BigInt
-	     * @memberof Address6
-	     * @instance
 	     * @returns {bigint}
 	     */
 	    bigInt() {
@@ -4685,8 +4958,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * 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');
@@ -4694,12 +4965,10 @@ function requireIpv6 () {
 	     */
 	    to4() {
 	        const binary = this.binaryZeroPad().split('');
-	        return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join('')}`).toString(16));
+	        return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join('')}`).toString(16).padStart(8, '0'));
 	    }
 	    /**
 	     * Return the v4-in-v6 form of the address
-	     * @memberof Address6
-	     * @instance
 	     * @returns {String}
 	     */
 	    to4in6() {
@@ -4713,10 +4982,10 @@ function requireIpv6 () {
 	        return correct + infix + address4.address;
 	    }
 	    /**
-	     * Return an object containing the Teredo properties of the address
-	     * @memberof Address6
-	     * @instance
-	     * @returns {Object}
+	     * Decodes the Teredo tunneling fields embedded in this address. Returns the
+	     * Teredo prefix, server IPv4, client IPv4, raw flag bits, cone-NAT flag,
+	     * UDP port, and Microsoft-format flag breakdown (reserved, universal/local,
+	     * group/individual, nonce). Only meaningful for addresses in `2001::/32`.
 	     */
 	    inspectTeredo() {
 	        /*
@@ -4747,7 +5016,7 @@ function requireIpv6 () {
 	        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 client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt('0xffffffff')).toString(16).padStart(8, '0'));
 	        const flagsBase2 = this.getBitsBase2(64, 80);
 	        const coneNat = (0, common_1.testBit)(flagsBase2, 15);
 	        const reserved = (0, common_1.testBit)(flagsBase2, 14);
@@ -4770,10 +5039,9 @@ function requireIpv6 () {
 	        };
 	    }
 	    /**
-	     * Return an object containing the 6to4 properties of the address
-	     * @memberof Address6
-	     * @instance
-	     * @returns {Object}
+	     * Decodes the 6to4 tunneling fields embedded in this address. Returns the
+	     * 6to4 prefix and the embedded IPv4 gateway address. Only meaningful for
+	     * addresses in `2002::/16`.
 	     */
 	    inspect6to4() {
 	        /*
@@ -4789,8 +5057,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Return a v6 6to4 address from a v6 v4inv6 address
-	     * @memberof Address6
-	     * @instance
 	     * @returns {Address6}
 	     */
 	    to6to4() {
@@ -4807,9 +5073,80 @@ function requireIpv6 () {
 	        return new Address6(addr6to4);
 	    }
 	    /**
-	     * Return a byte array
-	     * @memberof Address6
-	     * @instance
+	     * Embed an IPv4 address into a NAT64 IPv6 address using the encoding
+	     * defined by [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052).
+	     * The default prefix is the well-known prefix `64:ff9b::/96`. The prefix
+	     * length must be one of 32, 40, 48, 56, 64, or 96; for prefixes shorter
+	     * than /64 the IPv4 octets are split around the reserved bits 64–71.
+	     * @example
+	     * Address6.fromAddress4Nat64('192.0.2.33').correctForm(); // '64:ff9b::c000:221'
+	     * Address6.fromAddress4Nat64('192.0.2.33', '2001:db8::/32').correctForm(); // '2001:db8:c000:221::'
+	     */
+	    static fromAddress4Nat64(address, prefix = '64:ff9b::/96') {
+	        const v4 = new ipv4_1.Address4(address);
+	        const prefix6 = new Address6(prefix);
+	        const pl = prefix6.subnetMask;
+	        if (pl !== 32 && pl !== 40 && pl !== 48 && pl !== 56 && pl !== 64 && pl !== 96) {
+	            throw new address_error_1.AddressError('NAT64 prefix length must be 32, 40, 48, 56, 64, or 96');
+	        }
+	        const prefixBits = prefix6.binaryZeroPad();
+	        const v4Bits = v4.binaryZeroPad();
+	        let bits;
+	        if (pl === 96) {
+	            bits = prefixBits.slice(0, 96) + v4Bits;
+	        }
+	        else {
+	            const beforeU = 64 - pl;
+	            bits =
+	                prefixBits.slice(0, pl) +
+	                    v4Bits.slice(0, beforeU) +
+	                    '00000000' +
+	                    v4Bits.slice(beforeU) +
+	                    '0'.repeat(128 - 72 - (32 - beforeU));
+	        }
+	        const hex = BigInt(`0b${bits}`).toString(16).padStart(32, '0');
+	        const groups = [];
+	        for (let i = 0; i < 8; i++) {
+	            groups.push(hex.slice(i * 4, (i + 1) * 4));
+	        }
+	        return new Address6(groups.join(':'));
+	    }
+	    /**
+	     * Extract the embedded IPv4 address from a NAT64 IPv6 address using the
+	     * encoding defined by [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052).
+	     * The default prefix is the well-known prefix `64:ff9b::/96`. Returns
+	     * `null` if this address is not contained within the given prefix.
+	     * @example
+	     * new Address6('64:ff9b::c000:221').toAddress4Nat64()!.correctForm(); // '192.0.2.33'
+	     */
+	    toAddress4Nat64(prefix = '64:ff9b::/96') {
+	        const prefix6 = new Address6(prefix);
+	        const pl = prefix6.subnetMask;
+	        if (pl !== 32 && pl !== 40 && pl !== 48 && pl !== 56 && pl !== 64 && pl !== 96) {
+	            throw new address_error_1.AddressError('NAT64 prefix length must be 32, 40, 48, 56, 64, or 96');
+	        }
+	        if (!this.isInSubnet(prefix6)) {
+	            return null;
+	        }
+	        const bits = this.binaryZeroPad();
+	        let v4Bits;
+	        if (pl === 96) {
+	            v4Bits = bits.slice(96, 128);
+	        }
+	        else {
+	            const beforeU = 64 - pl;
+	            v4Bits = bits.slice(pl, pl + beforeU) + bits.slice(72, 72 + (32 - beforeU));
+	        }
+	        const octets = [];
+	        for (let i = 0; i < 4; i++) {
+	            octets.push(parseInt(v4Bits.slice(i * 8, (i + 1) * 8), 2).toString());
+	        }
+	        return new ipv4_1.Address4(octets.join('.'));
+	    }
+	    /**
+	     * Return a byte array.
+	     *
+	     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toByteArray())`.
 	     * @returns {Array}
 	     */
 	    toByteArray() {
@@ -4823,27 +5160,27 @@ function requireIpv6 () {
 	        return bytes;
 	    }
 	    /**
-	     * Return an unsigned byte array
-	     * @memberof Address6
-	     * @instance
+	     * Return an unsigned byte array.
+	     *
+	     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toUnsignedByteArray())`.
 	     * @returns {Array}
 	     */
 	    toUnsignedByteArray() {
 	        return this.toByteArray().map(unsignByte);
 	    }
 	    /**
-	     * Convert a byte array to an Address6 object
-	     * @memberof Address6
-	     * @static
+	     * Convert a byte array to an Address6 object.
+	     *
+	     * To convert from a Node.js `Buffer`, spread it: `Address6.fromByteArray([...buf])`.
 	     * @returns {Address6}
 	     */
 	    static fromByteArray(bytes) {
 	        return this.fromUnsignedByteArray(bytes.map(unsignByte));
 	    }
 	    /**
-	     * Convert an unsigned byte array to an Address6 object
-	     * @memberof Address6
-	     * @static
+	     * Convert an unsigned byte array to an Address6 object.
+	     *
+	     * To convert from a Node.js `Buffer`, spread it: `Address6.fromUnsignedByteArray([...buf])`.
 	     * @returns {Address6}
 	     */
 	    static fromUnsignedByteArray(bytes) {
@@ -4858,8 +5195,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Returns true if the address is in the canonical form, false otherwise
-	     * @memberof Address6
-	     * @instance
 	     * @returns {boolean}
 	     */
 	    isCanonical() {
@@ -4867,8 +5202,6 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Returns true if the address is a link local address, false otherwise
-	     * @memberof Address6
-	     * @instance
 	     * @returns {boolean}
 	     */
 	    isLinkLocal() {
@@ -4881,53 +5214,81 @@ function requireIpv6 () {
 	    }
 	    /**
 	     * Returns true if the address is a multicast address, false otherwise
-	     * @memberof Address6
-	     * @instance
 	     * @returns {boolean}
 	     */
 	    isMulticast() {
-	        return this.getType() === 'Multicast';
+	        const type = this.getType();
+	        return type === 'Multicast' || type.startsWith('Multicast ');
 	    }
 	    /**
-	     * Returns true if the address is a v4-in-v6 address, false otherwise
-	     * @memberof Address6
-	     * @instance
+	     * Returns true if the address was written in v4-in-v6 dotted-quad notation
+	     * (e.g. `::ffff:127.0.0.1`), false otherwise. This is a notation-level flag
+	     * and does not reflect whether the address bits lie in the IPv4-mapped
+	     * (`::ffff:0:0/96`) subnet — for that, see {@link isMapped4}.
 	     * @returns {boolean}
 	     */
 	    is4() {
 	        return this.v4;
 	    }
+	    /**
+	     * Returns true if the address is an IPv4-mapped IPv6 address in
+	     * `::ffff:0:0/96` ([RFC 4291 §2.5.5.2](https://datatracker.ietf.org/doc/html/rfc4291#section-2.5.5.2)),
+	     * false otherwise. Unlike {@link is4}, this checks the underlying address
+	     * bits rather than the textual notation, so `::ffff:127.0.0.1` and
+	     * `::ffff:7f00:1` both return true.
+	     * @returns {boolean}
+	     */
+	    isMapped4() {
+	        return this.isInSubnet(IPV4_MAPPED_SUBNET);
+	    }
 	    /**
 	     * Returns true if the address is a Teredo address, false otherwise
-	     * @memberof Address6
-	     * @instance
 	     * @returns {boolean}
 	     */
 	    isTeredo() {
-	        return this.isInSubnet(new Address6('2001::/32'));
+	        return this.isInSubnet(TEREDO_SUBNET);
 	    }
 	    /**
 	     * Returns true if the address is a 6to4 address, false otherwise
-	     * @memberof Address6
-	     * @instance
 	     * @returns {boolean}
 	     */
 	    is6to4() {
-	        return this.isInSubnet(new Address6('2002::/16'));
+	        return this.isInSubnet(SIX_TO_FOUR_SUBNET);
 	    }
 	    /**
 	     * Returns true if the address is a loopback address, false otherwise
-	     * @memberof Address6
-	     * @instance
 	     * @returns {boolean}
 	     */
 	    isLoopback() {
 	        return this.getType() === 'Loopback';
 	    }
+	    /**
+	     * Returns true if the address is a Unique Local Address in `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)). ULAs are the IPv6 equivalent of IPv4 [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private addresses.
+	     * @returns {boolean}
+	     */
+	    isULA() {
+	        return this.isInSubnet(ULA_SUBNET);
+	    }
+	    /**
+	     * Returns true if the address is the unspecified address `::`.
+	     * @returns {boolean}
+	     */
+	    isUnspecified() {
+	        return this.getType() === 'Unspecified';
+	    }
+	    /**
+	     * Returns true if the address is in the documentation prefix `2001:db8::/32` ([RFC 3849](https://datatracker.ietf.org/doc/html/rfc3849)).
+	     * @returns {boolean}
+	     */
+	    isDocumentation() {
+	        return this.isInSubnet(DOCUMENTATION_SUBNET);
+	    }
 	    // #endregion
 	    // #region HTML
 	    /**
-	     * @returns {String} the address in link form with a default port of 80
+	     * Returns the address as an HTTP URL with the host bracketed, e.g.
+	     * `http://[2001:db8::1]/`. If `optionalPort` is provided it is appended,
+	     * e.g. `http://[2001:db8::1]:8080/`.
 	     */
 	    href(optionalPort) {
 	        if (optionalPort === undefined) {
@@ -4939,7 +5300,12 @@ function requireIpv6 () {
 	        return `http://[${this.correctForm()}]${optionalPort}/`;
 	    }
 	    /**
-	     * @returns {String} a link suitable for conveying the address via a URL hash
+	     * Returns an HTML `<a>` element whose `href` encodes the address in a URL
+	     * hash fragment (default prefix `/#address=`). Useful for linking between
+	     * pages of an address-inspector UI.
+	     * @param options.className - CSS class for the rendered `<a>` element
+	     * @param options.prefix - hash prefix prepended to the address (default `/#address=`)
+	     * @param options.v4 - when true, render the address in v4-in-v6 form
 	     */
 	    link(options) {
 	        if (!options) {
@@ -4959,10 +5325,13 @@ function requireIpv6 () {
 	            formFunction = this.to4in6;
 	        }
 	        const form = formFunction.call(this);
+	        const safeHref = helpers.escapeHtml(`${options.prefix}${form}`);
+	        const safeForm = helpers.escapeHtml(form);
 	        if (options.className) {
-	            return `<a href="${options.prefix}${form}" class="${options.className}">${form}</a>`;
+	            const safeClass = helpers.escapeHtml(options.className);
+	            return `<a href="${safeHref}" class="${safeClass}">${safeForm}</a>`;
 	        }
-	        return `<a href="${options.prefix}${form}">${form}</a>`;
+	        return `<a href="${safeHref}">${safeForm}</a>`;
 	    }
 	    /**
 	     * Groups an address
@@ -4971,13 +5340,13 @@ function requireIpv6 () {
 	    group() {
 	        if (this.elidedGroups === 0) {
 	            // The simple case
-	            return helpers.simpleGroup(this.address).join(':');
+	            return helpers.simpleGroup(this.addressMinusSuffix).join(':');
 	        }
 	        assert(typeof this.elidedGroups === 'number');
 	        assert(typeof this.elisionBegin === 'number');
 	        // The elided case
 	        const output = [];
-	        const [left, right] = this.address.split('::');
+	        const [left, right] = this.addressMinusSuffix.split('::');
 	        if (left.length) {
 	            output.push(...helpers.simpleGroup(left));
 	        }
@@ -5007,8 +5376,6 @@ function requireIpv6 () {
 	    /**
 	     * 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}
 	     */
@@ -5053,8 +5420,6 @@ function requireIpv6 () {
 	    /**
 	     * 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}
 	     */
@@ -5063,6 +5428,15 @@ function requireIpv6 () {
 	    }
 	}
 	ipv6.Address6 = Address6;
+	const TYPE_SUBNETS = Object.keys(constants6.TYPES).map((subnet) => [
+	    new Address6(subnet),
+	    constants6.TYPES[subnet],
+	]);
+	const TEREDO_SUBNET = new Address6('2001::/32');
+	const SIX_TO_FOUR_SUBNET = new Address6('2002::/16');
+	const ULA_SUBNET = new Address6('fc00::/7');
+	const DOCUMENTATION_SUBNET = new Address6('2001:db8::/32');
+	const IPV4_MAPPED_SUBNET = new Address6('::ffff:0:0/96');
 	
 	return ipv6;
 }
@@ -5072,7 +5446,7 @@ var hasRequiredIpAddress;
 function requireIpAddress () {
 	if (hasRequiredIpAddress) return ipAddress;
 	hasRequiredIpAddress = 1;
-	(function (exports$1) {
+	(function (exports) {
 		var __createBinding = (ipAddress && ipAddress.__createBinding) || (Object.create ? (function(o, m, k, k2) {
 		    if (k2 === undefined) k2 = k;
 		    var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -5096,16 +5470,16 @@ function requireIpAddress () {
 		    __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 };
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.v6 = exports.AddressError = exports.Address6 = exports.Address4 = void 0;
+		var ipv4_1 = /*@__PURE__*/ requireIpv4();
+		Object.defineProperty(exports, "Address4", { enumerable: true, get: function () { return ipv4_1.Address4; } });
+		var ipv6_1 = /*@__PURE__*/ requireIpv6();
+		Object.defineProperty(exports, "Address6", { enumerable: true, get: function () { return ipv6_1.Address6; } });
+		var address_error_1 = /*@__PURE__*/ requireAddressError();
+		Object.defineProperty(exports, "AddressError", { enumerable: true, get: function () { return address_error_1.AddressError; } });
+		const helpers = __importStar(/*@__PURE__*/ requireHelpers$1());
+		exports.v6 = { helpers };
 		
 	} (ipAddress));
 	return ipAddress;
@@ -5121,7 +5495,7 @@ function requireHelpers () {
 	const util_1 = requireUtil();
 	const constants_1 = requireConstants$2();
 	const stream = require$$2$1;
-	const ip_address_1 = requireIpAddress();
+	const ip_address_1 = /*@__PURE__*/ requireIpAddress();
 	const net$1 = net;
 	/**
 	 * Validates the provided SocksClientOptions
@@ -5342,7 +5716,7 @@ var hasRequiredSocksclient;
 function requireSocksclient () {
 	if (hasRequiredSocksclient) return socksclient;
 	hasRequiredSocksclient = 1;
-	(function (exports$1) {
+	(function (exports) {
 		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) {
@@ -5352,8 +5726,8 @@ function requireSocksclient () {
 		        step((generator = generator.apply(thisArg, _arguments || [])).next());
 		    });
 		};
-		Object.defineProperty(exports$1, "__esModule", { value: true });
-		exports$1.SocksClientError = exports$1.SocksClient = void 0;
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.SocksClientError = exports.SocksClient = void 0;
 		const events_1 = require$$0;
 		const net$1 = net;
 		const smart_buffer_1 = requireSmartbuffer();
@@ -5361,8 +5735,8 @@ function requireSocksclient () {
 		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();
+		Object.defineProperty(exports, "SocksClientError", { enumerable: true, get: function () { return util_1.SocksClientError; } });
+		const ip_address_1 = /*@__PURE__*/ requireIpAddress();
 		class SocksClient extends events_1.EventEmitter {
 		    constructor(options) {
 		        super();
@@ -6133,7 +6507,7 @@ function requireSocksclient () {
 		        return Object.assign({}, this.options);
 		    }
 		}
-		exports$1.SocksClient = SocksClient;
+		exports.SocksClient = SocksClient;
 		
 	} (socksclient));
 	return socksclient;
@@ -6144,7 +6518,7 @@ var hasRequiredBuild;
 function requireBuild () {
 	if (hasRequiredBuild) return build$1;
 	hasRequiredBuild = 1;
-	(function (exports$1) {
+	(function (exports) {
 		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);
@@ -6156,11 +6530,11 @@ function requireBuild () {
 		    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);
+		var __exportStar = (build$1 && build$1.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 		};
-		Object.defineProperty(exports$1, "__esModule", { value: true });
-		__exportStar(requireSocksclient(), exports$1);
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireSocksclient(), exports);
 		
 	} (build$1));
 	return build$1;
@@ -6504,6 +6878,85 @@ const getCurrentUser = () => {
     }
 };
 
+/**
+ * Cookie 工具：把 Set-Cookie 头（或被 `'; '` 拼接污染过的脏 cookie 串）
+ * 归一化为合法的 `Cookie` 请求头值。
+ *
+ * 与浏览器一致的最小行为：
+ * - 丢弃 cookie 属性段（Path / Domain / Max-Age / Expires / Secure / HttpOnly / SameSite / Priority / Partitioned）
+ * - 过滤 `Max-Age <= 0` 或 `Expires` 已过期的 cookie（浏览器不会写入 jar，也就不会发送）
+ * - 保持原有出现顺序，不按 name 去重（浏览器在不同 domain/path 下同名 cookie 会一并发送）
+ */
+const COOKIE_ATTRIBUTE_KEYS = new Set([
+    'path',
+    'domain',
+    'max-age',
+    'expires',
+    'secure',
+    'httponly',
+    'samesite',
+    'priority',
+    'partitioned',
+]);
+function splitSegments(raw) {
+    return raw
+        .split(';')
+        .map(s => s.trim())
+        .filter(Boolean);
+}
+function isAttributeKey(key) {
+    return COOKIE_ATTRIBUTE_KEYS.has(key.toLowerCase());
+}
+/**
+ * 清洗任意来源的 Cookie 字符串：
+ * - 兼容标准 `name=value; name=value` 格式（幂等）
+ * - 兼容把多条 Set-Cookie 用 `'; '` 拼接得到的脏串
+ */
+function sanitizeCookieHeader(cookieHeader) {
+    if (!cookieHeader)
+        return '';
+    const segments = splitSegments(cookieHeader);
+    const entries = [];
+    let current = null;
+    for (const seg of segments) {
+        const eqIdx = seg.indexOf('=');
+        const key = (eqIdx < 0 ? seg : seg.slice(0, eqIdx)).trim();
+        const val = eqIdx < 0 ? '' : seg.slice(eqIdx + 1).trim();
+        if (!key)
+            continue;
+        if (isAttributeKey(key)) {
+            if (!current)
+                continue;
+            const lk = key.toLowerCase();
+            if (lk === 'max-age') {
+                const n = Number(val);
+                if (Number.isFinite(n) && n <= 0)
+                    current.expired = true;
+            }
+            else if (lk === 'expires') {
+                const t = Date.parse(val);
+                if (!Number.isNaN(t) && t <= Date.now())
+                    current.expired = true;
+            }
+            continue;
+        }
+        current = { name: key, value: val, expired: false };
+        entries.push(current);
+    }
+    return entries
+        .filter(e => !e.expired)
+        .map(e => `${e.name}=${e.value}`)
+        .join('; ');
+}
+/**
+ * 从 `response.headers['set-cookie']` 数组构建可用于 `Cookie` 请求头的字符串。
+ */
+function buildCookieHeaderFromSetCookies(setCookies) {
+    if (!setCookies || setCookies.length === 0)
+        return '';
+    return sanitizeCookieHeader(setCookies.join('; '));
+}
+
 function isVerboseEnabled() {
     return process.argv.includes('--verbose');
 }
@@ -6654,7 +7107,7 @@ function printApiResponseLog(title, result) {
 }
 async function request({ url, method, data, headers, params, }) {
     const config = getTTMGRC();
-    const cookie = config?.cookie;
+    const cookie = sanitizeCookieHeader(config?.cookie);
     const proxyConfig = getAxiosProxyConfig();
     if (isVerboseEnabled()) {
         printApiRequestLog({
@@ -11541,10 +11994,13 @@ async function login(options) {
             process.exit(1);
         }
         else {
+            const setCookies = response?.headers['set-cookie'];
+            const cookie = buildCookieHeaderFromSetCookies(setCookies);
+            log('Parsed cookies', { rawCount: setCookies?.length ?? 0, kept: cookie ? cookie.split('; ').length : 0 });
             const loginData = {
                 email,
                 user_id: response?.data?.data?.user_id,
-                cookie: response?.headers['set-cookie'].join('; '),
+                cookie,
             };
             log('Login success', { user_id: loginData.user_id, email: loginData.email });
             setTTMGRC(loginData);
@@ -11818,7 +12274,7 @@ async function upload({ clientKey, note = '--', dir, }) {
     }
 }
 
-var version = "0.3.8-beta.2";
+var version = "0.3.8-beta.3";
 var pkg = {
 	version: version};