@bigbinary/neeto-molecules 4.0.18 → 4.0.29

package/dist/IpRestriction.js

@@ -27,10 +27,10 @@ import { useQuery } from '@tanstack/react-query';
 import axios from 'axios';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import useMutationWithInvalidation from '@bigbinary/neeto-commons-frontend/react-utils/useMutationWithInvalidation';
-import { n } from './inject-css-DmrvuTKK.js';
+import { n } from './inject-css-C2dztUxs.js';
 import '@bigbinary/neeto-cist';
 
-var ipNum = {};
+var src = {};
 
 var BinaryUtils = {};
 
@@ -43,9 +43,10 @@ var BinaryUtils = {};
 	 * @param num number to parse
 	 * @returns {string} the binary string representation of number
 	 */
-	exports.numberToBinaryString = (num) => {
+	let numberToBinaryString = (num) => {
 	    return num.toString(2);
 	};
+	exports.numberToBinaryString = numberToBinaryString;
 	/**
 	 * Converts a decimal number to binary octet (8 bit) string. If needed the octet will be padded with zeros
 	 * to make it up to 8 bits
@@ -53,23 +54,25 @@ var BinaryUtils = {};
 	 * @param {number} num to convert to octet string
 	 * @returns {string} the octet string representation of given number
 	 */
-	exports.decimalNumberToOctetString = (num) => {
-	    let binaryString = exports.numberToBinaryString(num);
+	let decimalNumberToOctetString = (num) => {
+	    let binaryString = (0, exports.numberToBinaryString)(num);
 	    let length = binaryString.length;
 	    if (length > 8) {
 	        throw new Error("Given decimal in binary contains digits greater than an octet");
 	    }
-	    return exports.leftPadWithZeroBit(binaryString, 8);
+	    return (0, exports.leftPadWithZeroBit)(binaryString, 8);
 	};
+	exports.decimalNumberToOctetString = decimalNumberToOctetString;
 	/**
 	 * Parses number in binary to number in BigInt
 	 *
 	 * @param num binary number in string to parse
 	 * @returns {number} binary number in BigInt
 	 */
-	exports.parseBinaryStringToBigInt = (num) => {
+	let parseBinaryStringToBigInt = (num) => {
 	    return BigInt(`0b${num}`);
 	};
+	exports.parseBinaryStringToBigInt = parseBinaryStringToBigInt;
 	/**
 	 * Given an IPv4 number in dot-decimal notated string, e.g 192.168.0.1 converts it to
 	 * binary string, e.g. '11000000101010000000000000000001'
@@ -77,33 +80,35 @@ var BinaryUtils = {};
 	 * @param dottedDecimal IPv4 string in dot-decimal notation
 	 * @returns {string} the binary value of the given ipv4 number in string
 	 */
-	exports.dottedDecimalNotationToBinaryString = (dottedDecimal) => {
+	let dottedDecimalNotationToBinaryString = (dottedDecimal) => {
 	    let stringOctets = dottedDecimal.split(".");
 	    return stringOctets.reduce((binaryAsString, octet) => {
-	        return binaryAsString.concat(exports.decimalNumberToOctetString(parseInt(octet)));
+	        return binaryAsString.concat((0, exports.decimalNumberToOctetString)(parseInt(octet)));
 	    }, '');
 	};
+	exports.dottedDecimalNotationToBinaryString = dottedDecimalNotationToBinaryString;
 	/**
 	 * Given a binary string, adds a number of zero to the left until string is as long as the given string length
 	 * @param {string} binaryString the string to pad
 	 * @param {number} finalStringLength the final length of string after padding
 	 * @returns {string}
 	 */
-	exports.leftPadWithZeroBit = (binaryString, finalStringLength) => {
+	let leftPadWithZeroBit = (binaryString, finalStringLength) => {
 	    if (binaryString.length > finalStringLength) {
 	        throw new Error(`Given string is already longer than given final length after padding: ${finalStringLength}`);
 	    }
 	    return "0".repeat(finalStringLength - binaryString.length).concat(binaryString);
 	};
+	exports.leftPadWithZeroBit = leftPadWithZeroBit;
 	/**
 	 * Given the prefix portion of a cidr notation and the type of IP number, returns the mask in binary string
 	 *
 	 * @param {number} cidrPrefix the prefix part of a cidr notation
 	 * @param {IPNumType.IPv4 | IPNumType.IPv6} ipType the type of the ip number in the range the cidr represents
 	 */
-	exports.cidrPrefixToMaskBinaryString = (cidrPrefix, ipType) => {
+	let cidrPrefixToMaskBinaryString = (cidrPrefix, ipType) => {
 	    let cidrUpperValue;
-	    if (ipType == "IPv4" /* IPv4 */) {
+	    if (ipType == "IPv4" /* IPNumType.IPv4 */) {
 	        cidrUpperValue = 32;
 	    }
 	    else {
@@ -115,6 +120,7 @@ var BinaryUtils = {};
 	    let offBits = '0'.repeat(cidrUpperValue - cidrPrefix);
 	    return `${onBits}${offBits}`;
 	};
+	exports.cidrPrefixToMaskBinaryString = cidrPrefixToMaskBinaryString;
 	/**
 	 * Calculates the log, to base 2 of given number.
 	 *
@@ -122,7 +128,7 @@ var BinaryUtils = {};
 	 * @param givenNumber the number to calculate log base 2
 	 * @return the log base 2 of given number
 	 */
-	exports.intLog2 = (givenNumber) => {
+	let intLog2 = (givenNumber) => {
 	    let result = 0;
 	    while (givenNumber % 2n === 0n) {
 	        if (givenNumber === 2n) {
@@ -141,12 +147,13 @@ var BinaryUtils = {};
 	    }
 	    return result;
 	};
+	exports.intLog2 = intLog2;
 	/**
 	 * Starting from the most significant bit (from left) returns the number of first bits from both string that are equal
 	 * @param firstBinaryString first binary string
 	 * @param secondBinaryString second binary string
 	 */
-	exports.matchingBitCount = (firstBinaryString, secondBinaryString) => {
+	let matchingBitCount = (firstBinaryString, secondBinaryString) => {
 	    let longerString;
 	    let otherString;
 	    if (firstBinaryString.length >= secondBinaryString.length) {
@@ -166,6 +173,7 @@ var BinaryUtils = {};
 	    }
 	    return count;
 	};
+	exports.matchingBitCount = matchingBitCount;
 	
 } (BinaryUtils));
 
@@ -180,101 +188,158 @@ var hasRequiredIPv6Utils;
 function requireIPv6Utils () {
 	if (hasRequiredIPv6Utils) return IPv6Utils;
 	hasRequiredIPv6Utils = 1;
-	Object.defineProperty(IPv6Utils, "__esModule", { value: true });
-	IPv6Utils.collapseIPv6Number = IPv6Utils.expandIPv6Number = void 0;
-	const BinaryUtils_1 = BinaryUtils;
-	const Validator_1 = requireValidator();
-	let extractPrefix = (ipv6String) => {
-	    return ipv6String.includes("/") ? `/${ipv6String.split("/")[1]}` : "";
-	};
-	/**
-	 * Expands an IPv6 number in abbreviated format into its full form
-	 *
-	 * {@see https://en.wikipedia.org/wiki/IPv6_address#Representation} for more on the representation of IPv6 addresses
-	 *
-	 * @param {string} ipv6String the abbreviated IPv6 address to expand
-	 * @returns {string} the expanded IPv6 address
-	 */
-	IPv6Utils.expandIPv6Number = (ipv6String) => {
-	    let expandWithZero = (hexadecimalArray) => {
-	        let paddedArray = hexadecimalArray.map((hexadecimal) => {
-	            return BinaryUtils_1.leftPadWithZeroBit(hexadecimal, 4);
-	        });
-	        return paddedArray.join(":");
-	    };
-	    let expandDoubleColon = (gapCount) => {
-	        let pads = [];
-	        for (let count = 0; count < gapCount; count++) {
-	            pads.push("0000");
-	        }
-	        return pads.join(":");
-	    };
-	    if (/(:){3,}/.test(ipv6String))
-	        throw "given IPv6 contains consecutive : more than two";
-	    const prefix = extractPrefix(ipv6String);
-	    if (ipv6String.includes("/")) {
-	        ipv6String = ipv6String.split("/")[0];
-	    }
-	    let isValid = Validator_1.Validator.IPV6_PATTERN.test(ipv6String);
-	    if (!isValid) {
-	        throw Error(Validator_1.Validator.invalidIPv6PatternMessage);
-	    }
-	    if (ipv6String.includes("::")) {
-	        let split = ipv6String.split("::");
-	        let leftPortion = split[0];
-	        let rightPortion = split[1];
-	        let leftPortionSplit = leftPortion.split(":").filter(hexadecimal => { return hexadecimal !== ""; });
-	        let rightPortionSplit = rightPortion.split(":").filter(hexadecimal => { return hexadecimal !== ""; });
-	        let doublePortion = expandDoubleColon(8 - (leftPortionSplit.length + rightPortionSplit.length));
-	        let leftString = expandWithZero(leftPortionSplit);
-	        if (leftString !== "") {
-	            leftString += ":";
-	        }
-	        let rightString = expandWithZero(rightPortionSplit);
-	        if (rightString !== "") {
-	            rightString = ":" + rightString;
-	        }
-	        return `${leftString}${doublePortion}${rightString}${prefix}`;
-	    }
-	    else {
-	        return `${expandWithZero(ipv6String.split(":"))}${prefix}`;
-	    }
-	};
-	/**
-	 * Collapses an IPv6 number in full format into its abbreviated form
-	 *
-	 * {@see https://en.wikipedia.org/wiki/IPv6_address#Representation} for more on the representation of IPv6 addresses
-	 *
-	 * @param {string} ipv6String the full form IPv6 number to collapse
-	 * @returns {string} the collapsed IPv6 number
-	 */
-	IPv6Utils.collapseIPv6Number = (ipv6String) => {
-	    const prefix = extractPrefix(ipv6String);
-	    if (ipv6String.includes("/")) {
-	        ipv6String = ipv6String.split("/")[0];
-	    }
-	    let isValid = Validator_1.Validator.IPV6_PATTERN.test(ipv6String);
-	    if (!isValid) {
-	        throw Error(Validator_1.Validator.invalidIPv6PatternMessage);
-	    }
-	    let hexadecimals = ipv6String.split(":");
-	    let hexadecimalsWithoutLeadingZeros = hexadecimals.map((hexidecimal) => {
-	        let withoutLeadingZero = hexidecimal.replace(/^0+/, '');
-	        if (withoutLeadingZero !== '') {
-	            return withoutLeadingZero;
-	        }
-	        else {
-	            return "0";
-	        }
-	    });
-	    let contracted = hexadecimalsWithoutLeadingZeros.join(":").replace(/((^0)?(:0){2,}|(^0)(:0){1,})/, ':');
-	    if (contracted.slice(-1) === ":") {
-	        return `${contracted}:${prefix}`;
-	    }
-	    contracted = contracted.replace(":0:", "::");
-	    return `${contracted}${prefix}`;
-	};
-	
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.collapseIPv6Number = exports.expandIPv6Number = void 0;
+		const BinaryUtils_1 = BinaryUtils;
+		const Validator_1 = requireValidator();
+		let extractPrefix = (ipv6String) => {
+		    return ipv6String.includes("/") ? `/${ipv6String.split("/")[1]}` : "";
+		};
+		let expandIPv6Number = (ipv6String) => {
+		    let expandWithZero = (hexadecimalArray) => {
+		        let paddedArray = hexadecimalArray.map((hexadecimal) => {
+		            return (0, BinaryUtils_1.leftPadWithZeroBit)(hexadecimal, 4);
+		        });
+		        return paddedArray.join(":");
+		    };
+		    let expandDoubleColon = (gapCount) => {
+		        let pads = [];
+		        for (let count = 0; count < gapCount; count++) {
+		            pads.push("0000");
+		        }
+		        return pads.join(":");
+		    };
+		    if (/(:){3,}/.test(ipv6String))
+		        throw "given IPv6 contains consecutive : more than two";
+		    const prefix = extractPrefix(ipv6String);
+		    if (ipv6String.includes("/")) {
+		        ipv6String = ipv6String.split("/")[0];
+		    }
+		    let isValid = Validator_1.Validator.IPV6_PATTERN.test(ipv6String);
+		    if (!isValid) {
+		        throw Error(Validator_1.Validator.invalidIPv6PatternMessage);
+		    }
+		    if (ipv6String.includes("::")) {
+		        let split = ipv6String.split("::");
+		        let leftPortion = split[0];
+		        let rightPortion = split[1];
+		        let leftPortionSplit = leftPortion.split(":").filter(hexadecimal => { return hexadecimal !== ""; });
+		        let rightPortionSplit = rightPortion.split(":").filter(hexadecimal => { return hexadecimal !== ""; });
+		        let doublePortion = expandDoubleColon(8 - (leftPortionSplit.length + rightPortionSplit.length));
+		        let leftString = expandWithZero(leftPortionSplit);
+		        if (leftString !== "") {
+		            leftString += ":";
+		        }
+		        let rightString = expandWithZero(rightPortionSplit);
+		        if (rightString !== "") {
+		            rightString = ":" + rightString;
+		        }
+		        return `${leftString}${doublePortion}${rightString}${prefix}`;
+		    }
+		    else {
+		        return `${expandWithZero(ipv6String.split(":"))}${prefix}`;
+		    }
+		};
+		exports.expandIPv6Number = expandIPv6Number;
+		// Helper function to shorten hexadecatets
+		const shortenHexadecatet = (hex) => {
+		    // Input hex is expected to be like "0000", "0DB8", "001A" from expanded form
+		    const withoutLeadingZero = hex.replace(/^0+/, '');
+		    // If hex was "0000", withoutLeadingZero is "", so return "0"
+		    // Otherwise, return the string without leading zeros.
+		    return withoutLeadingZero === '' ? '0' : withoutLeadingZero;
+		};
+		let collapseIPv6Number = (ipv6String) => {
+		    const originalPrefix = extractPrefix(ipv6String);
+		    const processedIPv6String = ipv6String.includes("/") ? ipv6String.split("/")[0] : ipv6String;
+		    let expandedIPv6 = "";
+		    try {
+		        // Expand to full 8 segments, no prefix internally for processing
+		        let tempExpanded = (0, exports.expandIPv6Number)(processedIPv6String);
+		        if (tempExpanded.includes("/")) {
+		            expandedIPv6 = tempExpanded.split("/")[0];
+		        }
+		        else {
+		            expandedIPv6 = tempExpanded;
+		        }
+		    }
+		    catch (e) {
+		        // Propagate error if expansion fails (e.g. invalid IPv6 format)
+		        throw e;
+		    }
+		    let hexadecatets = expandedIPv6.split(":");
+		    if (hexadecatets.length !== 8) {
+		        // This case should ideally be prevented by expandIPv6Number's validation or structure.
+		        // If expandIPv6Number guarantees 8 segments or throws, this might not be strictly needed.
+		        // However, as a safeguard:
+		        throw new Error(`Invalid IPv6 structure after expansion: ${expandedIPv6}. Expected 8 segments.`);
+		    }
+		    let zeroSequences = [];
+		    let currentSequenceStart = -1;
+		    let currentSequenceLength = 0;
+		    for (let i = 0; i < 8; i++) {
+		        // Segments from expandIPv6Number are 4-char 0-padded, e.g., "0000"
+		        if (hexadecatets[i] === "0000") {
+		            if (currentSequenceStart === -1) {
+		                currentSequenceStart = i;
+		            }
+		            currentSequenceLength++;
+		        }
+		        else {
+		            if (currentSequenceLength > 0) {
+		                zeroSequences.push({ start: currentSequenceStart, length: currentSequenceLength });
+		            }
+		            currentSequenceStart = -1;
+		            currentSequenceLength = 0;
+		        }
+		    }
+		    if (currentSequenceLength > 0) { // Capture any trailing zero sequence
+		        zeroSequences.push({ start: currentSequenceStart, length: currentSequenceLength });
+		    }
+		    if (zeroSequences.length === 0) {
+		        // No zero segments at all, just shorten each hexadecatet
+		        return hexadecatets.map(shortenHexadecatet).join(":") + originalPrefix;
+		    }
+		    // Sort sequences: longest first, then earliest start first
+		    zeroSequences.sort((a, b) => {
+		        if (b.length !== a.length) {
+		            return b.length - a.length;
+		        }
+		        return a.start - b.start;
+		    });
+		    const bestSequence = zeroSequences[0];
+		    if (bestSequence.length === 8) { // All 8 segments are zero
+		        return "::" + originalPrefix;
+		    }
+		    // RFC 5952: "The symbol "::" MUST NOT be used to shorten just one 16-bit 0 field."
+		    // So, length must be > 1 for "::" compression.
+		    if (bestSequence.length < 2) {
+		        // No "::" compression is applied (e.g. "1:2:0:4:5:6:7:8")
+		        return hexadecatets.map(shortenHexadecatet).join(":") + originalPrefix;
+		    }
+		    // Apply "::" compression using the bestSequence
+		    let leftPartSegments = hexadecatets.slice(0, bestSequence.start);
+		    let rightPartSegments = hexadecatets.slice(bestSequence.start + bestSequence.length);
+		    let leftString = leftPartSegments.map(shortenHexadecatet).join(":");
+		    let rightString = rightPartSegments.map(shortenHexadecatet).join(":");
+		    let finalStr = "";
+		    if (bestSequence.start === 0) { // Compression at the beginning: "::..."
+		        finalStr = "::" + rightString;
+		    }
+		    else if (bestSequence.start + bestSequence.length === 8) { // Compression at the end: "...::"
+		        // Ensure that if leftString is empty (which shouldn't happen here if start > 0), it's handled.
+		        // However, if bestSequence.start > 0, leftPartSegments won't be empty unless bestSequence.start is 0.
+		        finalStr = leftString + "::";
+		    }
+		    else { // Compression in the middle: "...::..."
+		        finalStr = leftString + "::" + rightString;
+		    }
+		    return finalStr + originalPrefix;
+		};
+		exports.collapseIPv6Number = collapseIPv6Number;
+		
+	} (IPv6Utils));
 	return IPv6Utils;
 }
 
@@ -295,32 +360,35 @@ function requireHexadecimalUtils () {
 		 * @param num the bigint number
 		 * @returns {string} the hexadeciaml string
 		 */
-		exports.bigIntToHexadecimalString = (num) => {
+		let bigIntToHexadecimalString = (num) => {
 		    return num.toString(16);
 		};
+		exports.bigIntToHexadecimalString = bigIntToHexadecimalString;
 		/**
 		 * Converts a number in hexadecimal (base 16) to binary string
 		 * @param {string} hexadecimalString the number in base 16
 		 * @returns {string} the number converted to base 2
 		 */
-		exports.hexadecimalStringToBinaryString = (hexadecimalString) => {
+		let hexadecimalStringToBinaryString = (hexadecimalString) => {
 		    let inDecimal = BigInt(`0x${hexadecimalString}`);
 		    return inDecimal.toString(2);
 		};
+		exports.hexadecimalStringToBinaryString = hexadecimalStringToBinaryString;
 		/**
 		 * Converts a number in hexadecimal (base 16) to binary hexadecatet string.
 		 * This means the bits in the output cannot be more than 16
 		 *
 		 * @param hexadecimalString {string} the number converted to binary hexadecatet string
 		 */
-		exports.hexadecimalStringToHexadecatetString = (hexadecimalString) => {
-		    let binaryString = exports.hexadecimalStringToBinaryString(hexadecimalString);
+		let hexadecimalStringToHexadecatetString = (hexadecimalString) => {
+		    let binaryString = (0, exports.hexadecimalStringToBinaryString)(hexadecimalString);
 		    let length = binaryString.length;
 		    if (length > 16) {
 		        throw new Error("Given decimal in binary contains digits greater than an Hexadecatet");
 		    }
-		    return BinaryUtils_1.leftPadWithZeroBit(binaryString, 16);
+		    return (0, BinaryUtils_1.leftPadWithZeroBit)(binaryString, 16);
 		};
+		exports.hexadecimalStringToHexadecatetString = hexadecimalStringToHexadecatetString;
 		/**
 		 * Given an IPv6 number in hexadecimal notated string, e.g 2001:0db8:0000:0000:0000:0000:0000:0000 converts it to
 		 * binary string
@@ -328,35 +396,38 @@ function requireHexadecimalUtils () {
 		 * @param hexadecimalString IPv6 string
 		 * @returns {string} the binary value of the given ipv6 number in string
 		 */
-		exports.colonHexadecimalNotationToBinaryString = (hexadecimalString) => {
-		    let expandedIPv6 = IPv6Utils_1.expandIPv6Number(hexadecimalString);
+		let colonHexadecimalNotationToBinaryString = (hexadecimalString) => {
+		    let expandedIPv6 = (0, IPv6Utils_1.expandIPv6Number)(hexadecimalString);
 		    let stringHexadecimal = expandedIPv6.split(":");
 		    return stringHexadecimal.reduce((binaryAsString, hexidecimal) => {
-		        return binaryAsString.concat(exports.hexadecimalStringToHexadecatetString(hexidecimal));
+		        return binaryAsString.concat((0, exports.hexadecimalStringToHexadecatetString)(hexidecimal));
 		    }, '');
 		};
+		exports.colonHexadecimalNotationToBinaryString = colonHexadecimalNotationToBinaryString;
 		/**
 		 * Converts number in binary string to hexadecimal string
 		 * @param {string} num in binary string
 		 * @returns {string} num in hexadecimal string
 		 */
-		exports.binaryStringToHexadecimalString = (num) => {
+		let binaryStringToHexadecimalString = (num) => {
 		    // first convert to binary string to decimal (big Integer)
 		    let inDecimal = BigInt(`0b${num}`);
 		    return inDecimal.toString(16);
 		};
+		exports.binaryStringToHexadecimalString = binaryStringToHexadecimalString;
 		/**
 		 * Converts a given IPv6 number expressed in the hexadecimal string notation into a 16 bit binary number in string
 		 * @param {string} hexadectetString the IPv6 number
 		 * @returns {string} the IPv6 number converted to binary string
 		 */
-		exports.hexadectetNotationToBinaryString = (hexadectetString) => {
-		    let expand = IPv6Utils_1.expandIPv6Number(hexadectetString);
+		let hexadectetNotationToBinaryString = (hexadectetString) => {
+		    let expand = (0, IPv6Utils_1.expandIPv6Number)(hexadectetString);
 		    let hexadecimals = expand.split(":");
 		    return hexadecimals.reduce((hexadecimalAsString, hexavalue) => {
-		        return hexadecimalAsString.concat(BinaryUtils_1.leftPadWithZeroBit(exports.hexadecimalStringToBinaryString(hexavalue), 16));
+		        return hexadecimalAsString.concat((0, BinaryUtils_1.leftPadWithZeroBit)((0, exports.hexadecimalStringToBinaryString)(hexavalue), 16));
 		    }, '');
 		};
+		exports.hexadectetNotationToBinaryString = hexadectetNotationToBinaryString;
 		
 	} (HexadecimalUtils));
 	return HexadecimalUtils;
@@ -482,7 +553,7 @@ function requireValidator () {
 	     */
 	    static isValidIPv6String(ipv6String) {
 	        try {
-	            let hexadecimals = IPv6Utils_1.expandIPv6Number(ipv6String).split(":");
+	            let hexadecimals = (0, IPv6Utils_1.expandIPv6Number)(ipv6String).split(":");
 	            if (hexadecimals.length != 8) {
 	                return [false, [Validator.invalidHexadecatetCountMessage]];
 	            }
@@ -497,7 +568,7 @@ function requireValidator () {
 	            return [isValid, isValid ? [] : [Validator.invalidIPv6PatternMessage]];
 	        }
 	        catch (error) {
-	            return [false, [error]];
+	            return [false, [String(error)]];
 	        }
 	    }
 	    /**
@@ -508,11 +579,11 @@ function requireValidator () {
 	     * @returns {(boolean|string)[]} a tuple representing if valid or not and corresponding message
 	     */
 	    static isValidPrefixValue(prefixValue, ipNumType) {
-	        if ("IPv4" /* IPv4 */ === ipNumType) {
+	        if ("IPv4" /* IPNumType.IPv4 */ === ipNumType) {
 	            let withinRange = Validator.isWithinRange(BigInt(prefixValue), 0n, 32n);
 	            return [withinRange, withinRange ? [] : [Validator.invalidPrefixValueMessage]];
 	        }
-	        if ("IPv6" /* IPv6 */ === ipNumType) {
+	        if ("IPv6" /* IPNumType.IPv6 */ === ipNumType) {
 	            let withinRange = Validator.isWithinRange(BigInt(prefixValue), 0n, 128n);
 	            return [withinRange, withinRange ? [] : [Validator.invalidPrefixValueMessage]];
 	        }
@@ -526,7 +597,7 @@ function requireValidator () {
 	     * contains "valid" or an error message when value is invalid
 	     */
 	    static isValidIPv4Mask(ipv4MaskString) {
-	        let ipv4InBinary = BinaryUtils_1.dottedDecimalNotationToBinaryString(ipv4MaskString);
+	        let ipv4InBinary = (0, BinaryUtils_1.dottedDecimalNotationToBinaryString)(ipv4MaskString);
 	        let isValid = Validator.IPV4_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv4InBinary);
 	        return isValid ? [isValid, []] : [isValid, [Validator.invalidMaskMessage]];
 	    }
@@ -538,7 +609,7 @@ function requireValidator () {
 	     * contains "valid" or an error message when value is invalid
 	     */
 	    static isValidIPv6Mask(ipv6MaskString) {
-	        let ipv6InBinary = HexadecimalUtils_2.hexadectetNotationToBinaryString(ipv6MaskString);
+	        let ipv6InBinary = (0, HexadecimalUtils_2.hexadectetNotationToBinaryString)(ipv6MaskString);
 	        let isValid = Validator.IPV6_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv6InBinary);
 	        return isValid ? [isValid, []] : [isValid, [Validator.invalidMaskMessage]];
 	    }
@@ -557,11 +628,14 @@ function requireValidator () {
 	        }
 	        let ip = cidrComponents[0];
 	        let range = cidrComponents[1];
+	        if (!/^\d+$/.test(range)) {
+	            return [false, [Validator.invalidIPv4CidrNotationMessage]];
+	        }
 	        if (isNaN(Number(range))) {
 	            return [false, [Validator.invalidIPv4CidrNotationMessage]];
 	        }
 	        let [validIpv4, invalidIpv4Message] = Validator.isValidIPv4String(ip);
-	        let [validPrefix, invalidPrefixMessage] = Validator.isValidPrefixValue(BigInt(range), "IPv4" /* IPv4 */);
+	        let [validPrefix, invalidPrefixMessage] = Validator.isValidPrefixValue(BigInt(range), "IPv4" /* IPNumType.IPv4 */);
 	        let isValid = validIpv4 && validPrefix;
 	        let invalidMessage = invalidIpv4Message.concat(invalidPrefixMessage);
 	        return isValid ? [isValid, []] : [isValid, invalidMessage];
@@ -576,7 +650,7 @@ function requireValidator () {
 	     * value contains [] or an array of error message when invalid
 	     */
 	    static isValidIPv4CidrRange(ipv4CidrNotation) {
-	        return Validator.isValidCidrRange(ipv4CidrNotation, Validator.isValidIPv4CidrNotation, BinaryUtils_1.dottedDecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv4" /* IPv4 */));
+	        return Validator.isValidCidrRange(ipv4CidrNotation, Validator.isValidIPv4CidrNotation, BinaryUtils_1.dottedDecimalNotationToBinaryString, (value) => (0, BinaryUtils_2.cidrPrefixToMaskBinaryString)(value, "IPv4" /* IPNumType.IPv4 */));
 	    }
 	    /**
 	     *  Checks if the given string is a valid IPv6 range in Cidr notation, with the ip number in the cidr notation
@@ -588,7 +662,7 @@ function requireValidator () {
 	     * value contains [] or an array of error message when invalid
 	     */
 	    static isValidIPv6CidrRange(ipv6CidrNotation) {
-	        return Validator.isValidCidrRange(ipv6CidrNotation, Validator.isValidIPv6CidrNotation, HexadecimalUtils_1.colonHexadecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv6" /* IPv6 */));
+	        return Validator.isValidCidrRange(ipv6CidrNotation, Validator.isValidIPv6CidrNotation, HexadecimalUtils_1.colonHexadecimalNotationToBinaryString, (value) => (0, BinaryUtils_2.cidrPrefixToMaskBinaryString)(value, "IPv6" /* IPNumType.IPv6 */));
 	    }
 	    static isValidCidrRange(rangeString, cidrNotationValidator, toBinaryStringConverter, prefixFactory) {
 	        let validationResult = cidrNotationValidator(rangeString);
@@ -604,13 +678,13 @@ function requireValidator () {
 	        return isValid ? [isValid, []] : [isValid, [Validator.InvalidIPCidrRangeMessage]];
 	    }
 	    static isValidIPv4RangeString(ipv4RangeString) {
-	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${BinaryUtils_1.dottedDecimalNotationToBinaryString(firstIP)}`)
-	            >= BigInt(`0b${BinaryUtils_1.dottedDecimalNotationToBinaryString(lastIP)}`);
+	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${(0, BinaryUtils_1.dottedDecimalNotationToBinaryString)(firstIP)}`)
+	            >= BigInt(`0b${(0, BinaryUtils_1.dottedDecimalNotationToBinaryString)(lastIP)}`);
 	        return this.isValidRange(ipv4RangeString, Validator.isValidIPv4String, firstLastValidator);
 	    }
 	    static isValidIPv6RangeString(ipv6RangeString) {
-	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(firstIP)}`)
-	            >= BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(lastIP)}`);
+	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${(0, HexadecimalUtils_2.hexadectetNotationToBinaryString)(firstIP)}`)
+	            >= BigInt(`0b${(0, HexadecimalUtils_2.hexadectetNotationToBinaryString)(lastIP)}`);
 	        return this.isValidRange(ipv6RangeString, Validator.isValidIPv6String, firstLastValidator);
 	    }
 	    static isValidRange(rangeString, validator, firstLastValidator) {
@@ -716,27 +790,6 @@ const Validator_1$4 = requireValidator();
  * It is used to represents the components of an IPv6 address
  */
 class Hexadecatet {
-    /**
-     * Constructor for creating an instance of {@link Hexadecatet}
-     *
-     * @param {string | number} givenValue a string or numeric value. If given value is a string then it should be a
-     * four (base 16) number representation of a 16bit value. If it is a number, then it should be a decimal number
-     * representation of a 16 bit value
-     */
-    constructor(givenValue) {
-        let hexadecatetValue;
-        if (typeof givenValue === 'string') {
-            hexadecatetValue = parseInt(givenValue, 16);
-        }
-        else {
-            hexadecatetValue = parseInt(String(givenValue), 16);
-        }
-        let [isValid, message] = Validator_1$4.Validator.isValidIPv6Hexadecatet(BigInt(hexadecatetValue));
-        if (!isValid) {
-            throw Error(message.filter(msg => { return msg !== ''; }).toString());
-        }
-        this.value = hexadecatetValue;
-    }
     /**
      * A convenience method for constructing an instance of {@link Hexadecatet} from a four (base 16) number
      * representation of a 16bit value.
@@ -759,6 +812,27 @@ class Hexadecatet {
         return new Hexadecatet(rawValue);
     }
     ;
+    /**
+     * Constructor for creating an instance of {@link Hexadecatet}
+     *
+     * @param {string | number} givenValue a string or numeric value. If given value is a string then it should be a
+     * four (base 16) number representation of a 16bit value. If it is a number, then it should be a decimal number
+     * representation of a 16 bit value
+     */
+    constructor(givenValue) {
+        let hexadecatetValue;
+        if (typeof givenValue === 'string') {
+            hexadecatetValue = parseInt(givenValue, 16);
+        }
+        else {
+            hexadecatetValue = parseInt(String(givenValue), 16);
+        }
+        let [isValid, message] = Validator_1$4.Validator.isValidIPv6Hexadecatet(BigInt(hexadecatetValue));
+        if (!isValid) {
+            throw Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        this.value = hexadecatetValue;
+    }
     /**
      * Returns the numeric value in base 10 (ie decimal)
      *
@@ -794,6 +868,26 @@ const Validator_1$3 = requireValidator();
  * into 4 octets
  */
 class Octet {
+    /**
+     * Convenience method for creating an Octet out of a string value representing the value of the octet
+     *
+     * @param {string} rawValue the octet value in string
+     * @returns {Octet} the Octet instance
+     */
+    static fromString(rawValue) {
+        return new Octet(rawValue);
+    }
+    ;
+    /**
+     * Convenience method for creating an Octet out of a numeric value representing the value of the octet
+     *
+     * @param {number} rawValue the octet value in number
+     * @returns {Octet} the Octet instance
+     */
+    static fromNumber(rawValue) {
+        return new Octet(rawValue);
+    }
+    ;
     /**
      * Constructor for creating an instance of an Octet.
      *
@@ -818,26 +912,6 @@ class Octet {
         }
         this.value = octetValue;
     }
-    /**
-     * Convenience method for creating an Octet out of a string value representing the value of the octet
-     *
-     * @param {string} rawValue the octet value in string
-     * @returns {Octet} the Octet instance
-     */
-    static fromString(rawValue) {
-        return new Octet(rawValue);
-    }
-    ;
-    /**
-     * Convenience method for creating an Octet out of a numeric value representing the value of the octet
-     *
-     * @param {number} rawValue the octet value in number
-     * @returns {Octet} the Octet instance
-     */
-    static fromNumber(rawValue) {
-        return new Octet(rawValue);
-    }
-    ;
     /**
      * Method to get the numeric value of the octet
      *
@@ -858,7 +932,8 @@ class Octet {
 Octet$1.Octet = Octet;
 
 Object.defineProperty(IPNumber, "__esModule", { value: true });
-IPNumber.isIPv4 = IPNumber.IPv6Mask = IPNumber.IPv4Mask = IPNumber.IPv6 = IPNumber.Asn = IPNumber.IPv4 = IPNumber.AbstractIPNum = void 0;
+IPNumber.IPv6Mask = IPNumber.IPv4Mask = IPNumber.IPv6 = IPNumber.Asn = IPNumber.IPv4 = IPNumber.AbstractIPNum = void 0;
+IPNumber.isIPv4 = isIPv4;
 const Octet_1 = Octet$1;
 const Validator_1$2 = requireValidator();
 const BinaryUtils_1$2 = BinaryUtils;
@@ -888,7 +963,7 @@ class AbstractIPNum {
      * @returns {string} the string binary representation.
      */
     toBinaryString() {
-        return BinaryUtils_3.leftPadWithZeroBit(this.value.toString(2), this.bitSize);
+        return (0, BinaryUtils_3.leftPadWithZeroBit)(this.value.toString(2), this.bitSize);
     }
     /**
      * Checks if an IP number has a value greater than the present value
@@ -960,50 +1035,6 @@ IPNumber.AbstractIPNum = AbstractIPNum;
  * @see https://www.rfc-editor.org/info/rfc791
  */
 class IPv4 extends AbstractIPNum {
-    /**
-     * Constructor for an IPv4 number.
-     *
-     * @param {string | bigint} ipValue value to construct an IPv4 from. The given value can either be
-     * numeric or string. If a string is given then it needs to be in dot-decimal notation
-     */
-    constructor(ipValue) {
-        super();
-        /**
-         * The number of bits needed to represents the value of the IPv4 number
-         */
-        this.bitSize = 32;
-        /**
-         * The maximum bit size (i.e. binary value) of the IPv4 number in BigInt
-         */
-        this.maximumBitSize = Validator_1$2.Validator.THIRTY_TWO_BIT_SIZE;
-        /**
-         * The type of IP number. Value is one of the values of the {@link IPNumType} enum
-         * @type {IPNumType} the type of IP number
-         */
-        this.type = "IPv4" /* IPv4 */;
-        /**
-         * An array of {@link Octet}'s
-         *
-         * @type {Array} the octets that makes up the IPv4 number
-         */
-        this.octets = [];
-        /**
-         * The string character used to separate the individual octets when the IPv4 is rendered as strings
-         *
-         * @type {string} The string character used to separate the individual octets when rendered as strings
-         */
-        this.separator = ".";
-        if (typeof ipValue === "string") {
-            let [value, octets] = this.constructFromDecimalDottedString(ipValue);
-            this.value = value;
-            this.octets = octets;
-        }
-        else {
-            let [value, octets] = this.constructFromBigIntValue(ipValue);
-            this.value = value;
-            this.octets = octets;
-        }
-    }
     /**
      * A convenience method for creating an {@link IPv4} by providing the decimal value of the IP number in BigInt
      *
@@ -1043,12 +1074,56 @@ class IPv4 extends AbstractIPNum {
     static fromBinaryString(ipBinaryString) {
         let validationResult = Validator_1$2.Validator.isValidBinaryString(ipBinaryString);
         if (validationResult[0]) {
-            return new IPv4(BinaryUtils_2.parseBinaryStringToBigInt(ipBinaryString));
+            return new IPv4((0, BinaryUtils_2.parseBinaryStringToBigInt)(ipBinaryString));
         }
         else {
             throw Error(validationResult[1].join(','));
         }
     }
+    /**
+     * Constructor for an IPv4 number.
+     *
+     * @param {string | bigint} ipValue value to construct an IPv4 from. The given value can either be
+     * numeric or string. If a string is given then it needs to be in dot-decimal notation
+     */
+    constructor(ipValue) {
+        super();
+        /**
+         * The number of bits needed to represents the value of the IPv4 number
+         */
+        this.bitSize = 32;
+        /**
+         * The maximum bit size (i.e. binary value) of the IPv4 number in BigInt
+         */
+        this.maximumBitSize = Validator_1$2.Validator.THIRTY_TWO_BIT_SIZE;
+        /**
+         * The type of IP number. Value is one of the values of the {@link IPNumType} enum
+         * @type {IPNumType} the type of IP number
+         */
+        this.type = "IPv4" /* IPNumType.IPv4 */;
+        /**
+         * An array of {@link Octet}'s
+         *
+         * @type {Array} the octets that makes up the IPv4 number
+         */
+        this.octets = [];
+        /**
+         * The string character used to separate the individual octets when the IPv4 is rendered as strings
+         *
+         * @type {string} The string character used to separate the individual octets when rendered as strings
+         */
+        this.separator = ".";
+        if (typeof ipValue === "string") {
+            let [value, octets] = this.constructFromDecimalDottedString(ipValue);
+            this.value = value;
+            this.octets = octets;
+        }
+        else {
+            let [value, octets] = this.constructFromBigIntValue(ipValue);
+            this.value = value;
+            this.octets = octets;
+        }
+    }
     /**
      * A string representation of the IPv4 number. The string representation is in dot-decimal notation
      *
@@ -1105,7 +1180,7 @@ class IPv4 extends AbstractIPNum {
         octets = stringOctets.map((rawOctet) => {
             return Octet_1.Octet.fromString(rawOctet);
         });
-        value = BigInt(`0b${BinaryUtils_1$2.dottedDecimalNotationToBinaryString(ipString)}`);
+        value = BigInt(`0b${(0, BinaryUtils_1$2.dottedDecimalNotationToBinaryString)(ipString)}`);
         return [value, octets];
     }
     constructFromBigIntValue(ipv4Number) {
@@ -1113,17 +1188,17 @@ class IPv4 extends AbstractIPNum {
         if (!isValid) {
             throw new Error(message.filter(msg => { return msg !== ''; }).toString());
         }
-        let binaryString = BinaryUtils_4.numberToBinaryString(ipv4Number);
+        let binaryString = (0, BinaryUtils_4.numberToBinaryString)(ipv4Number);
         ipv4Number = typeof ipv4Number === "bigint" ? ipv4Number : BigInt(ipv4Number);
         return [ipv4Number, this.binaryStringToDecimalOctets(binaryString)];
     }
     binaryStringToDecimalOctets(ipv4BinaryString) {
         if (ipv4BinaryString.length < 32) {
-            ipv4BinaryString = BinaryUtils_3.leftPadWithZeroBit(ipv4BinaryString, 32);
+            ipv4BinaryString = (0, BinaryUtils_3.leftPadWithZeroBit)(ipv4BinaryString, 32);
         }
         let octets = ipv4BinaryString.match(/.{1,8}/g);
         return octets.map((octet) => {
-            return Octet_1.Octet.fromString(BinaryUtils_2.parseBinaryStringToBigInt(octet).toString());
+            return Octet_1.Octet.fromString((0, BinaryUtils_2.parseBinaryStringToBigInt)(octet).toString());
         });
     }
 }
@@ -1136,43 +1211,6 @@ IPNumber.IPv4 = IPv4;
  * @see https://tools.ietf.org/html/rfc5396
  */
 class Asn extends AbstractIPNum {
-    /**
-     * Constructor for an instance of {@link ASN}
-     *
-     * @param {string | number} rawValue value to construct an ASN from. The given value can either be numeric or
-     * string. If in string then it can be in asplain, asdot or asdot+ string representation format
-     */
-    constructor(rawValue) {
-        super();
-        /**
-         * The number of bits needed to represents the value of the ASN number
-         */
-        this.bitSize = 32;
-        /**
-         * The maximum bit size (i.e. binary value) of the ASN number in BigInt
-         */
-        this.maximumBitSize = Validator_1$2.Validator.THIRTY_TWO_BIT_SIZE;
-        this.type = "ASN" /* ASN */;
-        if (typeof rawValue === 'string') {
-            if (Asn.startWithASPrefix(rawValue)) {
-                this.value = BigInt(parseInt(rawValue.substring(2)));
-            }
-            else if (rawValue.indexOf(".") != -1) {
-                this.value = BigInt(this.parseFromDotNotation(rawValue));
-            }
-            else {
-                this.value = BigInt(parseInt(rawValue));
-            }
-        }
-        else {
-            let valueAsBigInt = BigInt(rawValue);
-            let [isValid, message] = Validator_1$2.Validator.isValidAsnNumber(valueAsBigInt);
-            if (!isValid) {
-                throw Error(message.filter(msg => { return msg !== ''; }).toString());
-            }
-            this.value = valueAsBigInt;
-        }
-    }
     /**
      * A convenience method for creating an instance of {@link Asn} from a string
      *
@@ -1212,6 +1250,43 @@ class Asn extends AbstractIPNum {
             throw Error(validationResult[1].join(','));
         }
     }
+    /**
+     * Constructor for an instance of {@link ASN}
+     *
+     * @param {string | number} rawValue value to construct an ASN from. The given value can either be numeric or
+     * string. If in string then it can be in asplain, asdot or asdot+ string representation format
+     */
+    constructor(rawValue) {
+        super();
+        /**
+         * The number of bits needed to represents the value of the ASN number
+         */
+        this.bitSize = 32;
+        /**
+         * The maximum bit size (i.e. binary value) of the ASN number in BigInt
+         */
+        this.maximumBitSize = Validator_1$2.Validator.THIRTY_TWO_BIT_SIZE;
+        this.type = "ASN" /* IPNumType.ASN */;
+        if (typeof rawValue === 'string') {
+            if (Asn.startWithASPrefix(rawValue)) {
+                this.value = BigInt(parseInt(rawValue.substring(2)));
+            }
+            else if (rawValue.indexOf(".") != -1) {
+                this.value = BigInt(this.parseFromDotNotation(rawValue));
+            }
+            else {
+                this.value = BigInt(parseInt(rawValue));
+            }
+        }
+        else {
+            let valueAsBigInt = BigInt(rawValue);
+            let [isValid, message] = Validator_1$2.Validator.isValidAsnNumber(valueAsBigInt);
+            if (!isValid) {
+                throw Error(message.filter(msg => { return msg !== ''; }).toString());
+            }
+            this.value = valueAsBigInt;
+        }
+    }
     /**
      * A string representation where the asn value is prefixed by "ASN". For example "AS65526"
      *
@@ -1262,7 +1337,7 @@ class Asn extends AbstractIPNum {
      * @returns {string} a binary string representation of the value of the ASN number
      */
     toBinaryString() {
-        return BinaryUtils_4.numberToBinaryString(this.value);
+        return (0, BinaryUtils_4.numberToBinaryString)(this.value);
     }
     /**
      * Checks if the ASN value is 16bit
@@ -1317,51 +1392,6 @@ Asn.AS_PREFIX = "AS";
  * @see https://www.rfc-editor.org/info/rfc8200
  */
 class IPv6 extends AbstractIPNum {
-    /**
-     * Constructor for an IPv6 number.
-     *
-     * @param {string | bigint} ipValue value to construct an IPv6 from. The given value can either be
-     * numeric or string. If a string is given then it needs to be in hexadecatet string notation
-     */
-    constructor(ipValue) {
-        super();
-        /**
-         * The number of bits needed to represents the value of the IPv6 number
-         */
-        this.bitSize = 128;
-        /**
-         * The maximum bit size (i.e. binary value) of the IPv6 number in BigInt
-         */
-        this.maximumBitSize = Validator_1$2.Validator.ONE_HUNDRED_AND_TWENTY_EIGHT_BIT_SIZE;
-        /**
-         * The type of IP number. Value is one of the values of the {@link IPNumType} enum
-         * @type {IPNumType} the type of IP number
-         */
-        this.type = "IPv6" /* IPv6 */;
-        /**
-         * An array of {@link Hexadecatet}'s
-         *
-         * @type {Array} the hexadecatet that makes up the IPv6 number
-         */
-        this.hexadecatet = [];
-        /**
-         * The string character used to separate the individual hexadecatet when the IPv6 is rendered as strings
-         *
-         * @type {string} The string character used to separate the individual hexadecatet when rendered as strings
-         */
-        this.separator = ":";
-        if (typeof ipValue === "string") {
-            let expandedIPv6 = IPv6Utils_1.expandIPv6Number(ipValue);
-            let [value, hexadecatet] = this.constructFromHexadecimalDottedString(expandedIPv6);
-            this.value = value;
-            this.hexadecatet = hexadecatet;
-        }
-        else {
-            let [value, hexadecatet] = this.constructFromBigIntValue(ipValue);
-            this.value = value;
-            this.hexadecatet = hexadecatet;
-        }
-    }
     /**
      * A convenience method for creating an {@link IPv6} by providing the decimal value of the IP number in BigInt
      *
@@ -1401,8 +1431,8 @@ class IPv6 extends AbstractIPNum {
     static fromBinaryString(ipBinaryString) {
         let validationResult = Validator_1$2.Validator.isValidBinaryString(ipBinaryString);
         if (validationResult[0]) {
-            let paddedBinaryString = BinaryUtils_3.leftPadWithZeroBit(ipBinaryString, 128);
-            return new IPv6(BinaryUtils_2.parseBinaryStringToBigInt(paddedBinaryString));
+            let paddedBinaryString = (0, BinaryUtils_3.leftPadWithZeroBit)(ipBinaryString, 128);
+            return new IPv6((0, BinaryUtils_2.parseBinaryStringToBigInt)(paddedBinaryString));
         }
         else {
             throw Error(validationResult[1].join(','));
@@ -1427,6 +1457,51 @@ class IPv6 extends AbstractIPNum {
     static fromIPv4DotDecimalString(ip4DotDecimalString) {
         return new IPv4(ip4DotDecimalString).toIPv4MappedIPv6();
     }
+    /**
+     * Constructor for an IPv6 number.
+     *
+     * @param {string | bigint} ipValue value to construct an IPv6 from. The given value can either be
+     * numeric or string. If a string is given then it needs to be in hexadecatet string notation
+     */
+    constructor(ipValue) {
+        super();
+        /**
+         * The number of bits needed to represents the value of the IPv6 number
+         */
+        this.bitSize = 128;
+        /**
+         * The maximum bit size (i.e. binary value) of the IPv6 number in BigInt
+         */
+        this.maximumBitSize = Validator_1$2.Validator.ONE_HUNDRED_AND_TWENTY_EIGHT_BIT_SIZE;
+        /**
+         * The type of IP number. Value is one of the values of the {@link IPNumType} enum
+         * @type {IPNumType} the type of IP number
+         */
+        this.type = "IPv6" /* IPNumType.IPv6 */;
+        /**
+         * An array of {@link Hexadecatet}'s
+         *
+         * @type {Array} the hexadecatet that makes up the IPv6 number
+         */
+        this.hexadecatet = [];
+        /**
+         * The string character used to separate the individual hexadecatet when the IPv6 is rendered as strings
+         *
+         * @type {string} The string character used to separate the individual hexadecatet when rendered as strings
+         */
+        this.separator = ":";
+        if (typeof ipValue === "string") {
+            let expandedIPv6 = (0, IPv6Utils_1.expandIPv6Number)(ipValue);
+            let [value, hexadecatet] = this.constructFromHexadecimalDottedString(expandedIPv6);
+            this.value = value;
+            this.hexadecatet = hexadecatet;
+        }
+        else {
+            let [value, hexadecatet] = this.constructFromBigIntValue(ipValue);
+            this.value = value;
+            this.hexadecatet = hexadecatet;
+        }
+    }
     /**
      * A string representation of the IPv6 number.
      *
@@ -1471,7 +1546,7 @@ class IPv6 extends AbstractIPNum {
         if (!isValid) {
             throw new Error(message.filter(msg => { return msg !== ''; }).toString());
         }
-        let binaryString = BinaryUtils_4.numberToBinaryString(ipv6Number);
+        let binaryString = (0, BinaryUtils_4.numberToBinaryString)(ipv6Number);
         return [ipv6Number, this.binaryStringToHexadecatets(binaryString)];
     }
     constructFromHexadecimalDottedString(expandedIPv6) {
@@ -1483,11 +1558,11 @@ class IPv6 extends AbstractIPNum {
         let hexadecatet = stringHexadecimals.map((stringHexadecatet) => {
             return Hexadecatet_1$1.Hexadecatet.fromString(stringHexadecatet);
         });
-        let value = BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(expandedIPv6)}`);
+        let value = BigInt(`0b${(0, HexadecimalUtils_2.hexadectetNotationToBinaryString)(expandedIPv6)}`);
         return [value, hexadecatet];
     }
     binaryStringToHexadecatets(binaryString) {
-        let hexadecimalString = HexadecimalUtils_1$1.binaryStringToHexadecimalString(binaryString);
+        let hexadecimalString = (0, HexadecimalUtils_1$1.binaryStringToHexadecimalString)(binaryString);
         while (hexadecimalString.length % 4 != 0) {
             hexadecimalString = '0' + hexadecimalString;
         }
@@ -1504,6 +1579,17 @@ IPNumber.IPv6 = IPv6;
  * to demarcate which bits are used to identify a network, and the ones that are used to identify hosts on the network
  */
 class IPv4Mask extends IPv4 {
+    /**
+     * A convenience method for creating an instance of IPv4Mask. The passed strings need to be a valid IPv4
+     * number in dot-decimal notation.
+     *
+     * @param {string} rawValue The passed string in dot-decimal notation
+     * @returns {IPv4Mask} the instance of IPv4Mask
+     */
+    static fromDecimalDottedString(rawValue) {
+        return new IPv4Mask(rawValue);
+    }
+    ;
     /**
      * Constructor for creating an instance of IPv4Mask.
      * The passed strings need to be a valid IPv4 mask number in dot-decimal notation.
@@ -1524,25 +1610,14 @@ class IPv4Mask extends IPv4 {
         if (!isValid) {
             throw new Error(message.filter(msg => { return msg !== ''; }).toString());
         }
-        let stringOctets = ipString.split(".");
-        this.octets = stringOctets.map((rawOctet) => {
-            return Octet_1.Octet.fromString(rawOctet);
-        });
-        let binaryString = BinaryUtils_1$2.dottedDecimalNotationToBinaryString(ipString);
-        this.prefix = (binaryString.match(/1/g) || []).length;
-        this.value = BigInt(`0b${binaryString}`);
-    }
-    /**
-     * A convenience method for creating an instance of IPv4Mask. The passed strings need to be a valid IPv4
-     * number in dot-decimal notation.
-     *
-     * @param {string} rawValue The passed string in dot-decimal notation
-     * @returns {IPv4Mask} the instance of IPv4Mask
-     */
-    static fromDecimalDottedString(rawValue) {
-        return new IPv4Mask(rawValue);
+        let stringOctets = ipString.split(".");
+        this.octets = stringOctets.map((rawOctet) => {
+            return Octet_1.Octet.fromString(rawOctet);
+        });
+        let binaryString = (0, BinaryUtils_1$2.dottedDecimalNotationToBinaryString)(ipString);
+        this.prefix = (binaryString.match(/1/g) || []).length;
+        this.value = BigInt(`0b${binaryString}`);
     }
-    ;
 }
 IPNumber.IPv4Mask = IPv4Mask;
 /**
@@ -1552,6 +1627,17 @@ IPNumber.IPv4Mask = IPv4Mask;
  * on the network
  */
 class IPv6Mask extends IPv6 {
+    /**
+     * A convenience method for creating an instance of IPv6Mask.
+     * The passed strings need to be a valid IPv4 mask number in dot-decimal notation.
+     *
+     * @param {string} rawValue The passed string in textual notation
+     * @returns {IPv6Mask} the instance of IPv6Mask
+     */
+    static fromHexadecatet(rawValue) {
+        return new IPv6Mask(rawValue);
+    }
+    ;
     /**
      * Constructor for creating an instance of IPv6Mask.
      * The passed strings need to be a valid IPv6 mask number in dot-decimal notation
@@ -1568,7 +1654,7 @@ class IPv6Mask extends IPv6 {
         this.hexadecatet = [];
         let isValid;
         let message;
-        let expandedIPv6 = IPv6Utils_1.expandIPv6Number(ipString);
+        let expandedIPv6 = (0, IPv6Utils_1.expandIPv6Number)(ipString);
         [isValid, message] = Validator_1$2.Validator.isValidIPv6Mask(expandedIPv6);
         if (!isValid) {
             throw new Error(message.filter(msg => { return msg !== ''; }).toString());
@@ -1577,22 +1663,11 @@ class IPv6Mask extends IPv6 {
         this.hexadecatet = stringHexadecimals.map((stringHexadecatet) => {
             return Hexadecatet_1$1.Hexadecatet.fromString(stringHexadecatet);
         });
-        let binaryString = HexadecimalUtils_2.hexadectetNotationToBinaryString(expandedIPv6);
+        let binaryString = (0, HexadecimalUtils_2.hexadectetNotationToBinaryString)(expandedIPv6);
         this.prefix = (binaryString.match(/1/g) || []).length;
         this.value = BigInt(`0b${binaryString}`);
-        this.value = BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(expandedIPv6)}`);
-    }
-    /**
-     * A convenience method for creating an instance of IPv6Mask.
-     * The passed strings need to be a valid IPv4 mask number in dot-decimal notation.
-     *
-     * @param {string} rawValue The passed string in textual notation
-     * @returns {IPv6Mask} the instance of IPv6Mask
-     */
-    static fromHexadecatet(rawValue) {
-        return new IPv6Mask(rawValue);
+        this.value = BigInt(`0b${(0, HexadecimalUtils_2.hexadectetNotationToBinaryString)(expandedIPv6)}`);
     }
-    ;
 }
 IPNumber.IPv6Mask = IPv6Mask;
 /**
@@ -1602,7 +1677,6 @@ IPNumber.IPv6Mask = IPv6Mask;
 function isIPv4(ip) {
     return ip.bitSize === 32;
 }
-IPNumber.isIPv4 = isIPv4;
 
 var IPNumType = {};
 
@@ -1615,7 +1689,8 @@ var IPRange = {};
 var Prefix = {};
 
 Object.defineProperty(Prefix, "__esModule", { value: true });
-Prefix.isIPv4Prefix = Prefix.IPv6Prefix = Prefix.IPv4Prefix = void 0;
+Prefix.IPv6Prefix = Prefix.IPv4Prefix = void 0;
+Prefix.isIPv4Prefix = isIPv4Prefix;
 const Validator_1$1 = requireValidator();
 const IPNumber_1$1 = IPNumber;
 const BinaryUtils_1$1 = BinaryUtils;
@@ -1630,6 +1705,21 @@ const Hexadecatet_1 = Hexadecatet$1;
  * {@see https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing} for more information on CIDR
  */
 class IPv4Prefix {
+    /**
+     * Convenience method for constructing an instance of IPv4 prefix from a decimal number
+     *
+     * @param {number} rawValue the decimal value to construct the IPv4 prefix from.
+     * @returns {IPv4Prefix} the instance of an IPv4 prefix
+     */
+    static fromNumber(rawValue) {
+        return new IPv4Prefix(rawValue);
+    }
+    ;
+    static fromRangeSize(rangeSize) {
+        let prefixNumber = rangeSize === (1n) ? 32 : 32 - rangeSizeToPrefix(rangeSize, Validator_1$1.Validator.IPV4_SIZE);
+        return IPv4Prefix.fromNumber(BigInt(prefixNumber));
+    }
+    ;
     /**
      * Constructor for an instance of IPv4 prefix from a decimal number
      *
@@ -1641,27 +1731,12 @@ class IPv4Prefix {
         this.bitValue = 32n;
         let isValid;
         let message;
-        [isValid, message] = Validator_1$1.Validator.isValidPrefixValue(rawValue, "IPv4" /* IPv4 */);
+        [isValid, message] = Validator_1$1.Validator.isValidPrefixValue(rawValue, "IPv4" /* IPNumType.IPv4 */);
         if (!isValid) {
             throw new Error(message.filter(msg => { return msg !== ''; }).toString());
         }
         this.value = rawValue;
     }
-    /**
-     * Convenience method for constructing an instance of IPv4 prefix from a decimal number
-     *
-     * @param {number} rawValue the decimal value to construct the IPv4 prefix from.
-     * @returns {IPv4Prefix} the instance of an IPv4 prefix
-     */
-    static fromNumber(rawValue) {
-        return new IPv4Prefix(rawValue);
-    }
-    ;
-    static fromRangeSize(rangeSize) {
-        let prefixNumber = rangeSize === (1n) ? 32 : 32 - rangeSizeToPrefix(rangeSize, Validator_1$1.Validator.IPV4_SIZE);
-        return IPv4Prefix.fromNumber(BigInt(prefixNumber));
-    }
-    ;
     /**
      * Gets the decimal value of the IPv4 prefix
      *
@@ -1718,7 +1793,7 @@ class IPv4Prefix {
         return new IPv4Prefix(this.value + 1n);
     }
     toDecimalNotation(bits) {
-        return `${BinaryUtils_1$1.parseBinaryStringToBigInt(bits.substr(0, 8))}.${BinaryUtils_1$1.parseBinaryStringToBigInt(bits.substr(8, 8))}.${BinaryUtils_1$1.parseBinaryStringToBigInt(bits.substr(16, 8))}.${BinaryUtils_1$1.parseBinaryStringToBigInt(bits.substr(24, 8))}`;
+        return `${(0, BinaryUtils_1$1.parseBinaryStringToBigInt)(bits.substr(0, 8))}.${(0, BinaryUtils_1$1.parseBinaryStringToBigInt)(bits.substr(8, 8))}.${(0, BinaryUtils_1$1.parseBinaryStringToBigInt)(bits.substr(16, 8))}.${(0, BinaryUtils_1$1.parseBinaryStringToBigInt)(bits.substr(24, 8))}`;
     }
 }
 Prefix.IPv4Prefix = IPv4Prefix;
@@ -1731,6 +1806,20 @@ Prefix.IPv4Prefix = IPv4Prefix;
  * {@see https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing} for more information on CIDR
  */
 class IPv6Prefix {
+    /**
+     * Convenience method for constructing an instance of IPv46 prefix from a decimal number
+     *
+     * @param {number} rawValue the decimal value to construct the IPv6 prefix from.
+     * @returns {IPv4Prefix} the instance of an IPv6 prefix
+     */
+    static fromNumber(rawValue) {
+        return new IPv6Prefix(rawValue);
+    }
+    ;
+    static fromRangeSize(rangeSize) {
+        let prefixNumber = rangeSize === (1n) ? 128 : 128 - rangeSizeToPrefix(rangeSize, Validator_1$1.Validator.IPV6_SIZE);
+        return IPv6Prefix.fromNumber(BigInt(prefixNumber));
+    }
     /**
      * Constructor for an instance of IPv6 prefix from a decimal number
      *
@@ -1742,26 +1831,12 @@ class IPv6Prefix {
         this.bitValue = 128n;
         let isValid;
         let message;
-        [isValid, message] = Validator_1$1.Validator.isValidPrefixValue(rawValue, "IPv6" /* IPv6 */);
+        [isValid, message] = Validator_1$1.Validator.isValidPrefixValue(rawValue, "IPv6" /* IPNumType.IPv6 */);
         if (!isValid) {
             throw new Error(message.filter(msg => { return msg !== ''; }).toString());
         }
         this.value = rawValue;
     }
-    /**
-     * Convenience method for constructing an instance of IPv46 prefix from a decimal number
-     *
-     * @param {number} rawValue the decimal value to construct the IPv6 prefix from.
-     * @returns {IPv4Prefix} the instance of an IPv6 prefix
-     */
-    static fromNumber(rawValue) {
-        return new IPv6Prefix(rawValue);
-    }
-    ;
-    static fromRangeSize(rangeSize) {
-        let prefixNumber = rangeSize === (1n) ? 128 : 128 - rangeSizeToPrefix(rangeSize, Validator_1$1.Validator.IPV6_SIZE);
-        return IPv6Prefix.fromNumber(BigInt(prefixNumber));
-    }
     /**
      * Gets the decimal value of the IPv6 prefix
      *
@@ -1820,7 +1895,7 @@ class IPv6Prefix {
     toHexadecatetNotation(bits) {
         let binaryStrings = bits.match(/.{1,16}/g);
         let hexadecimalStrings = binaryStrings.map((binaryString) => {
-            return Hexadecatet_1.Hexadecatet.fromString(HexadecimalUtils_1.binaryStringToHexadecimalString(binaryString));
+            return Hexadecatet_1.Hexadecatet.fromString((0, HexadecimalUtils_1.binaryStringToHexadecimalString)(binaryString));
         });
         return hexadecimalStrings.map((value) => { return value.toString(); }).join(":");
     }
@@ -1832,7 +1907,7 @@ function rangeSizeToPrefix(rangeSize, rangeMaxSize) {
         throw new Error(Validator_1$1.Validator.invalidIPRangeSizeMessage.replace("$iptype", ipType));
     }
     try {
-        return BinaryUtils_1$1.intLog2(rangeSize);
+        return (0, BinaryUtils_1$1.intLog2)(rangeSize);
     }
     catch (e) {
         throw new Error(Validator_1$1.Validator.invalidIPRangeSizeForCidrMessage);
@@ -1845,10 +1920,10 @@ function rangeSizeToPrefix(rangeSize, rangeMaxSize) {
 function isIPv4Prefix(prefix) {
     return prefix.type === "IPv4";
 }
-Prefix.isIPv4Prefix = isIPv4Prefix;
 
 Object.defineProperty(IPRange, "__esModule", { value: true });
-IPRange.isIPv4CidrRange = IPRange.IPv6CidrRange = IPRange.IPv4CidrRange = IPRange.AbstractIPRange = IPRange.RangedSet = void 0;
+IPRange.IPv6CidrRange = IPRange.IPv4CidrRange = IPRange.AbstractIPRange = IPRange.RangedSet = void 0;
+IPRange.isIPv4CidrRange = isIPv4CidrRange;
 const IPNumber_1 = IPNumber;
 const Prefix_1$1 = Prefix;
 const BinaryUtils_1 = BinaryUtils;
@@ -1859,24 +1934,6 @@ const Validator_1 = requireValidator();
  * for allocating IP addresses.
  */
 class RangedSet {
-    /**
-     * Constructor for an instance of {@link RangedSet} from an
-     * instance of either {@link IPv4CidrRange} or {@link IPv6CidrRange}
-     *
-     * Throws an exception if first IP number is not less than given last IP number
-     *
-     * @param first the first IP number of the range
-     * @param last the last IP number of the range
-     */
-    constructor(first, last) {
-        this.first = first;
-        this.last = last;
-        if (first.isGreaterThan(last)) {
-            throw new Error(`${first.toString()} should be lower than ${last.toString()}`);
-        }
-        this.currentValue = first;
-        this.bitValue = BigInt(first.bitSize);
-    }
     /**
      * Convenience method for constructing an instance of {@link RangedSet} from a
      * single IP number.
@@ -1921,6 +1978,24 @@ class RangedSet {
             throw new Error("First IP and Last IP should be valid and same type");
         }
     }
+    /**
+     * Constructor for an instance of {@link RangedSet} from an
+     * instance of either {@link IPv4CidrRange} or {@link IPv6CidrRange}
+     *
+     * Throws an exception if first IP number is not less than given last IP number
+     *
+     * @param first the first IP number of the range
+     * @param last the last IP number of the range
+     */
+    constructor(first, last) {
+        this.first = first;
+        this.last = last;
+        if (first.isGreaterThan(last)) {
+            throw new Error(`${first.toString()} should be lower than ${last.toString()}`);
+        }
+        this.currentValue = first;
+        this.bitValue = BigInt(first.bitSize);
+    }
     /**
      * Returns the first IP number in the range
      */
@@ -2024,7 +2099,11 @@ class RangedSet {
         let otherLast = otherRange.getLast();
         return (thisLast.isGreaterThan(otherFirst) && thisLast.isLessThanOrEquals(otherLast) && thisFirst.isLessThan(otherFirst)
             ||
-                otherLast.isGreaterThan(thisFirst) && otherLast.isLessThanOrEquals(thisLast) && otherFirst.isLessThan(thisFirst));
+                otherLast.isGreaterThan(thisFirst) && otherLast.isLessThanOrEquals(thisLast) && otherFirst.isLessThan(thisFirst)
+            ||
+                this.contains(otherRange)
+            ||
+                otherRange.contains(this));
     }
     /**
      * Check if this range can be converted to a CIDR range.
@@ -2034,8 +2113,8 @@ class RangedSet {
             return true;
         }
         try {
-            let prefix = BinaryUtils_1.intLog2(this.getSize());
-            let netmask = BinaryUtils_1.parseBinaryStringToBigInt(BinaryUtils_1.cidrPrefixToMaskBinaryString(prefix, IPNumber_1.isIPv4(this.currentValue) ? "IPv4" /* IPv4 */ : "IPv6" /* IPv6 */));
+            let prefix = (0, BinaryUtils_1.intLog2)(this.getSize());
+            let netmask = (0, BinaryUtils_1.parseBinaryStringToBigInt)((0, BinaryUtils_1.cidrPrefixToMaskBinaryString)(prefix, (0, IPNumber_1.isIPv4)(this.currentValue) ? "IPv4" /* IPNumType.IPv4 */ : "IPv6" /* IPNumType.IPv6 */));
             return (this.first.getValue()) === (netmask & (this.first.getValue()));
         }
         catch (e) {
@@ -2046,7 +2125,7 @@ class RangedSet {
      * Converts an instance of range to an instance of CIDR range
      */
     toCidrRange() {
-        if (IPNumber_1.isIPv4(this.currentValue)) {
+        if ((0, IPNumber_1.isIPv4)(this.currentValue)) {
             return this.toIPv4CidrRange();
         }
         else {
@@ -2080,6 +2159,12 @@ class RangedSet {
         if (this.isEquals(otherRange)) {
             return new RangedSet(otherRange.getFirst(), otherRange.getLast());
         }
+        if (this.contains(otherRange)) {
+            return new RangedSet(this.getFirst(), this.getLast());
+        }
+        else if (otherRange.contains(this)) {
+            return new RangedSet(otherRange.getFirst(), otherRange.getLast());
+        }
         if (this.isOverlapping(otherRange)) {
             if (this.getFirst().isLessThan(otherRange.getFirst())) {
                 return new RangedSet(this.getFirst(), otherRange.getLast());
@@ -2088,12 +2173,6 @@ class RangedSet {
                 return new RangedSet(otherRange.getFirst(), this.getLast());
             }
         }
-        if (this.contains(otherRange)) {
-            return new RangedSet(this.getFirst(), this.getLast());
-        }
-        else if (otherRange.contains(this)) {
-            return new RangedSet(otherRange.getFirst(), otherRange.getLast());
-        }
         throw new Error("Ranges do not overlap nor are equal");
     }
     /**
@@ -2147,10 +2226,10 @@ class RangedSet {
             throw new Error("Sub range cannot be zero");
         }
         let valueOfFirstIp = this.getFirst().value + (offset);
-        let firstIp = IPNumber_1.isIPv4(this.getFirst()) ?
+        let firstIp = (0, IPNumber_1.isIPv4)(this.getFirst()) ?
             IPNumber_1.IPv4.fromNumber(valueOfFirstIp) : IPNumber_1.IPv6.fromBigInt(valueOfFirstIp);
         let valueOfLastIp = firstIp.value + (size - 1n);
-        let lastIp = IPNumber_1.isIPv4(firstIp) ? IPNumber_1.IPv4.fromNumber(valueOfLastIp) : IPNumber_1.IPv6.fromBigInt(valueOfLastIp);
+        let lastIp = (0, IPNumber_1.isIPv4)(firstIp) ? IPNumber_1.IPv4.fromNumber(valueOfLastIp) : IPNumber_1.IPv6.fromBigInt(valueOfLastIp);
         return new RangedSet(firstIp, lastIp);
     }
     /**
@@ -2228,6 +2307,12 @@ class AbstractIPRange {
         return this.toRangeSet().inside(otherRange.toRangeSet());
     }
     contains(otherRange) {
+        if (otherRange instanceof IPNumber_1.AbstractIPNum) {
+            const firstValue = this.getFirst().getValue();
+            const lastValue = this.getLast().getValue();
+            const otherValue = otherRange.getValue();
+            return otherValue >= firstValue && otherValue <= lastValue;
+        }
         return this.toRangeSet().contains(otherRange.toRangeSet());
     }
     toRangeString() {
@@ -2240,7 +2325,7 @@ class AbstractIPRange {
         return this.toRangeSet().isConsecutive(otherRange.toRangeSet());
     }
     isCidrMergeable(otherRange) {
-        const count = BigInt(BinaryUtils_1.matchingBitCount(this.getFirst().toBinaryString(), otherRange.getFirst().toBinaryString()));
+        const count = BigInt((0, BinaryUtils_1.matchingBitCount)(this.getFirst().toBinaryString(), otherRange.getFirst().toBinaryString()));
         if (this.getPrefix().value - count !== 1n) {
             return false;
         }
@@ -2285,23 +2370,6 @@ IPRange.AbstractIPRange = AbstractIPRange;
  * @see https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
  */
 class IPv4CidrRange extends AbstractIPRange {
-    /**
-     * Constructor for creating an instance of an IPv4 range.
-     *
-     * The arguments taken by the constructor is inspired by the CIDR notation which basically consists of the IP
-     * number and the prefix.
-     *
-     * @param {IPv4} ipv4 the IP number used to construct the range. By convention this is the first IP number in
-     * the range, but it could also be any IP number within the range
-     * @param {IPv4Prefix} cidrPrefix the prefix which is a representation of the number of bits used to mask the
-     * given IP number in other to create the range
-     */
-    constructor(ipv4, cidrPrefix) {
-        super();
-        this.ipv4 = ipv4;
-        this.cidrPrefix = cidrPrefix;
-        this.bitValue = 32n;
-    }
     /**
      * Convenience method for constructing an instance of an IPv4CidrRange from an IP range represented in CIDR notation
      *
@@ -2319,6 +2387,23 @@ class IPv4CidrRange extends AbstractIPRange {
         let prefix = BigInt(parseInt(cidrComponents[1]));
         return new IPv4CidrRange(IPNumber_1.IPv4.fromDecimalDottedString(ipString), Prefix_1$1.IPv4Prefix.fromNumber(prefix));
     }
+    /**
+     * Constructor for creating an instance of an IPv4 range.
+     *
+     * The arguments taken by the constructor is inspired by the CIDR notation which basically consists of the IP
+     * number and the prefix.
+     *
+     * @param {IPv4} ipv4 the IP number used to construct the range. By convention this is the first IP number in
+     * the range, but it could also be any IP number within the range
+     * @param {IPv4Prefix} cidrPrefix the prefix which is a representation of the number of bits used to mask the
+     * given IP number in other to create the range
+     */
+    constructor(ipv4, cidrPrefix) {
+        super();
+        this.ipv4 = ipv4;
+        this.cidrPrefix = cidrPrefix;
+        this.bitValue = 32n;
+    }
     /**
      * Gets the size of IPv4 numbers contained within the IPv4 range
      *
@@ -2520,23 +2605,6 @@ IPRange.IPv4CidrRange = IPv4CidrRange;
  * @see https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
  */
 class IPv6CidrRange extends AbstractIPRange {
-    /**
-     * Constructor for creating an instance of an IPv6 range.
-     *
-     * The arguments taken by the constructor is inspired by the CIDR notation which basically consists of the IP
-     * number and the prefix.
-     *
-     * @param {IPv6} ipv6 the IP number used to construct the range. By convention this is the first IP number in
-     * the range, but it could also be any IP number within the range
-     * @param {IPv6Prefix} cidrPrefix the prefix which is a representation of the number of bits used to mask the
-     * given IPv6 number in other to create the range
-     */
-    constructor(ipv6, cidrPrefix) {
-        super();
-        this.ipv6 = ipv6;
-        this.cidrPrefix = cidrPrefix;
-        this.bitValue = 128n;
-    }
     /**
      * Convenience method for constructing an instance of an IPV6Range from an IP range represented in CIDR notation
      *
@@ -2554,6 +2622,23 @@ class IPv6CidrRange extends AbstractIPRange {
         return new IPv6CidrRange(IPNumber_1.IPv6.fromHexadecatet(ipString), Prefix_1$1.IPv6Prefix.fromNumber(prefix));
     }
     ;
+    /**
+     * Constructor for creating an instance of an IPv6 range.
+     *
+     * The arguments taken by the constructor is inspired by the CIDR notation which basically consists of the IP
+     * number and the prefix.
+     *
+     * @param {IPv6} ipv6 the IP number used to construct the range. By convention this is the first IP number in
+     * the range, but it could also be any IP number within the range
+     * @param {IPv6Prefix} cidrPrefix the prefix which is a representation of the number of bits used to mask the
+     * given IPv6 number in other to create the range
+     */
+    constructor(ipv6, cidrPrefix) {
+        super();
+        this.ipv6 = ipv6;
+        this.cidrPrefix = cidrPrefix;
+        this.bitValue = 128n;
+    }
     /**
      * Gets the size of IPv6 numbers contained within the IPv6 range
      *
@@ -2750,18 +2835,17 @@ let last = (range, ip) => {
     let bitValue = Number(range.bitValue.valueOf());
     let maskSize = BigInt(`0b${"1".repeat(bitValue)}`);
     let maskAsBigInteger = range.cidrPrefix.toMask().getValue();
-    let invertedMask = BinaryUtils_1.leftPadWithZeroBit((maskAsBigInteger ^ (maskSize)).toString(2), bitValue);
+    let invertedMask = (0, BinaryUtils_1.leftPadWithZeroBit)((maskAsBigInteger ^ (maskSize)).toString(2), bitValue);
     if (isIPv4CidrRange(range)) {
-        return IPNumber_1.IPv4.fromNumber((ip.getValue()) | (BinaryUtils_1.parseBinaryStringToBigInt(invertedMask)));
+        return IPNumber_1.IPv4.fromNumber((ip.getValue()) | ((0, BinaryUtils_1.parseBinaryStringToBigInt)(invertedMask)));
     }
     else {
-        return IPNumber_1.IPv6.fromBigInt((ip.getValue()) | (BinaryUtils_1.parseBinaryStringToBigInt(invertedMask)));
+        return IPNumber_1.IPv6.fromBigInt((ip.getValue()) | ((0, BinaryUtils_1.parseBinaryStringToBigInt)(invertedMask)));
     }
 };
 function isIPv4CidrRange(ip) {
     return ip.bitValue.valueOf() === 32n;
 }
-IPRange.isIPv4CidrRange = isIPv4CidrRange;
 
 Object.defineProperty(IPPool, "__esModule", { value: true });
 IPPool.Pool = void 0;
@@ -2771,19 +2855,6 @@ const Prefix_1 = Prefix;
  * Represents a collection of IP {@link RangedSet}'s
  */
 class Pool {
-    /**
-     * Constructor for an IP pool.
-     *
-     * Creates a Pool of IP ranges from supplied {@link RangedSet}'s
-     *
-     * @param ranges the array of IP ranges that would make up the pool.
-     */
-    constructor(ranges) {
-        this.backingSet = new SortedSet();
-        ranges.forEach(range => {
-            this.backingSet.add(range);
-        });
-    }
     /**
      * Convenient method for creating an instance from arrays of {@link IPv4} or {@link IPv6}
      * @param ipNumbers the arrays of {@link IPv4} or {@link IPv6} that will make up the pool.
@@ -2815,6 +2886,19 @@ class Pool {
         });
         return new Pool(rangeSet);
     }
+    /**
+     * Constructor for an IP pool.
+     *
+     * Creates a Pool of IP ranges from supplied {@link RangedSet}'s
+     *
+     * @param ranges the array of IP ranges that would make up the pool.
+     */
+    constructor(ranges) {
+        this.backingSet = new SortedSet();
+        ranges.forEach(range => {
+            this.backingSet.add(range);
+        });
+    }
     /**
      * Returns an array of {@link RangedSet}'s that is contained within the pool
      */
@@ -2889,7 +2973,7 @@ class Pool {
                     if (e instanceof RangeError) {
                         continue loop;
                     }
-                    error = e;
+                    error = e instanceof Error ? e : new Error(String(e));
                 }
         }
         if (selectedCidrRange) {
@@ -2925,7 +3009,7 @@ class Pool {
                 }
             }
             catch (e) {
-                let lowerPrefix = Prefix_1.isIPv4Prefix(prefix) ?
+                let lowerPrefix = (0, Prefix_1.isIPv4Prefix)(prefix) ?
                     Prefix_1.IPv4Prefix.fromNumber(prefix.getValue() + 1n) : Prefix_1.IPv6Prefix.fromNumber(prefix.getValue() + 1n);
                 return go(reqprefix, lowerPrefix, accummulated);
             }
@@ -2993,14 +3077,6 @@ class Pool {
 }
 IPPool.Pool = Pool;
 class SortedSet {
-    constructor(array) {
-        if (array) {
-            this.backingArray = this.sortArray(array);
-        }
-        else {
-            this.backingArray = new Array();
-        }
-    }
     sortArray(array) {
         array.sort((a, b) => {
             if (a.isLessThan(b)) {
@@ -3013,6 +3089,14 @@ class SortedSet {
         });
         return array;
     }
+    constructor(array) {
+        if (array) {
+            this.backingArray = this.sortArray(array);
+        }
+        else {
+            this.backingArray = new Array();
+        }
+    }
     asArray() {
         return this.backingArray;
     }
@@ -3084,13 +3168,17 @@ class SortedSet {
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
 	    if (k2 === undefined) k2 = k;
-	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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 = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-	    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	/**
@@ -3114,7 +3202,7 @@ class SortedSet {
 	__exportStar(Prefix, exports);
 	__exportStar(requireValidator(), exports);
 	
-} (ipNum));
+} (src));
 
 var toLabelAndValue = function toLabelAndValue(value) {
   return {
@@ -3123,10 +3211,10 @@ var toLabelAndValue = function toLabelAndValue(value) {
   };
 };
 var isValidIPv4String = function isValidIPv4String(ip) {
-  return isNotNil(ip) && ipNum.Validator.isValidIPv4String(ip)[0];
+  return isNotNil(ip) && src.Validator.isValidIPv4String(ip)[0];
 };
 var isValidIPv6String = function isValidIPv6String(ip) {
-  return isNotNil(ip) && ipNum.Validator.isValidIPv6String(ip)[0];
+  return isNotNil(ip) && src.Validator.isValidIPv6String(ip)[0];
 };
 var isValidIpString = function isValidIpString(ip) {
   return isValidIPv4String(ip) || isValidIPv6String(ip);
@@ -3135,13 +3223,13 @@ var areIpAddressesInSameFormat = function areIpAddressesInSameFormat(ipStart, ip
   return isValidIPv4String(ipStart) && isValidIPv4String(ipEnd) || isValidIPv6String(ipStart) && isValidIPv6String(ipEnd);
 };
 var isValidIPv4Range = function isValidIPv4Range(ipStart, ipEnd) {
-  var ipStartAddr = ipNum.IPv4.fromDecimalDottedString(ipStart);
-  var ipEndAddr = ipNum.IPv4.fromDecimalDottedString(ipEnd);
+  var ipStartAddr = src.IPv4.fromDecimalDottedString(ipStart);
+  var ipEndAddr = src.IPv4.fromDecimalDottedString(ipEnd);
   return ipStartAddr.isLessThanOrEquals(ipEndAddr);
 };
 var isValidIPv6Range = function isValidIPv6Range(ipStart, ipEnd) {
-  var ipStartAddr = ipNum.IPv6.fromString(ipStart);
-  var ipEndAddr = ipNum.IPv6.fromString(ipEnd);
+  var ipStartAddr = src.IPv6.fromString(ipStart);
+  var ipEndAddr = src.IPv6.fromString(ipEnd);
   return ipStartAddr.isLessThanOrEquals(ipEndAddr);
 };
 var isValidIPRange = function isValidIPRange(ipStart, ipEnd) {
@@ -3231,8 +3319,6 @@ var ADDRESS_TYPE_SELECT_OPTIONS = [{
   value: "ipv6"
 }];
 ({
-  ipStart: "",
-  ipEnd: "",
   addressType: ADDRESS_TYPE_SELECT_OPTIONS[0].value
 });
 var VALIDATION_SCHEMA = yup.object().shape({
@@ -3440,7 +3526,7 @@ var allowedIpRangesApi = {
 };
 
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var ALLOWED_IP_RANGES$1 = QUERY_KEYS.ALLOWED_IP_RANGES;
 var useFetchAllowedIpRanges = function useFetchAllowedIpRanges(options) {
   return useQuery(_objectSpread({