@bigbinary/neeto-molecules 3.2.2 → 3.2.4

package/dist/IpRestriction.js

@@ -18,7 +18,7 @@ import Input from '@bigbinary/neetoui/formik/Input';
 import Select from '@bigbinary/neetoui/formik/Select';
 import { t } from 'i18next';
 import * as yup from 'yup';
-import { Validator, IPv4, IPv6 } from 'ip-num';
+import { c as commonjsGlobal } from './_commonjsHelpers-1c8beb5f.js';
 import { isNil, isNotNil, assoc } from 'ramda';
 import { useQuery } from '@tanstack/react-query';
 import axios from 'axios';
@@ -28,6 +28,3092 @@ import '@babel/runtime/helpers/extends';
 import '@babel/runtime/helpers/objectWithoutProperties';
 import './inject-css-c86de496.js';
 
+var ipNum = {};
+
+var BinaryUtils = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.matchingBitCount = exports.intLog2 = exports.cidrPrefixToMaskBinaryString = exports.leftPadWithZeroBit = exports.dottedDecimalNotationToBinaryString = exports.parseBinaryStringToBigInt = exports.decimalNumberToOctetString = exports.numberToBinaryString = void 0;
+	/**
+	 * Converts a decimal number to binary string
+	 *
+	 * @param num number to parse
+	 * @returns {string} the binary string representation of number
+	 */
+	exports.numberToBinaryString = (num) => {
+	    return num.toString(2);
+	};
+	/**
+	 * 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
+	 *
+	 * @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 length = binaryString.length;
+	    if (length > 8) {
+	        throw new Error("Given decimal in binary contains digits greater than an octet");
+	    }
+	    return exports.leftPadWithZeroBit(binaryString, 8);
+	};
+	/**
+	 * 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) => {
+	    return BigInt(`0b${num}`);
+	};
+	/**
+	 * Given an IPv4 number in dot-decimal notated string, e.g 192.168.0.1 converts it to
+	 * binary string, e.g. '11000000101010000000000000000001'
+	 *
+	 * @param dottedDecimal IPv4 string in dot-decimal notation
+	 * @returns {string} the binary value of the given ipv4 number in string
+	 */
+	exports.dottedDecimalNotationToBinaryString = (dottedDecimal) => {
+	    let stringOctets = dottedDecimal.split(".");
+	    return stringOctets.reduce((binaryAsString, octet) => {
+	        return binaryAsString.concat(exports.decimalNumberToOctetString(parseInt(octet)));
+	    }, '');
+	};
+	/**
+	 * 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) => {
+	    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);
+	};
+	/**
+	 * 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 cidrUpperValue;
+	    if (ipType == "IPv4" /* IPv4 */) {
+	        cidrUpperValue = 32;
+	    }
+	    else {
+	        cidrUpperValue = 128;
+	    }
+	    if (cidrPrefix > cidrUpperValue)
+	        throw Error(`Value is greater than ${cidrUpperValue}`);
+	    let onBits = '1'.repeat(cidrPrefix);
+	    let offBits = '0'.repeat(cidrUpperValue - cidrPrefix);
+	    return `${onBits}${offBits}`;
+	};
+	/**
+	 * Calculates the log, to base 2 of given number.
+	 *
+	 * @throws Error if number cannot be converted to log base 2
+	 * @param givenNumber the number to calculate log base 2
+	 * @return the log base 2 of given number
+	 */
+	exports.intLog2 = (givenNumber) => {
+	    let result = 0;
+	    while (givenNumber % 2n === 0n) {
+	        if (givenNumber === 2n) {
+	            result++;
+	            break;
+	        }
+	        givenNumber = givenNumber >> 1n;
+	        if (givenNumber % 2n !== 0n) {
+	            result = 0;
+	            break;
+	        }
+	        result++;
+	    }
+	    if (result == 0) {
+	        throw new Error(`The value of log2 for ${givenNumber.toString()} is not an integer`);
+	    }
+	    return result;
+	};
+	/**
+	 * 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 longerString;
+	    let otherString;
+	    if (firstBinaryString.length >= secondBinaryString.length) {
+	        longerString = firstBinaryString;
+	        otherString = secondBinaryString;
+	    }
+	    else {
+	        longerString = secondBinaryString;
+	        otherString = firstBinaryString;
+	    }
+	    let count = 0;
+	    for (; count < longerString.length; count++) {
+	        if (longerString.charAt(count) === otherString.charAt(count)) {
+	            continue;
+	        }
+	        break;
+	    }
+	    return count;
+	};
+	
+} (BinaryUtils));
+
+var Hexadecatet$1 = {};
+
+var Validator = {};
+
+var IPv6Utils = {};
+
+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}`;
+	};
+	
+	return IPv6Utils;
+}
+
+var HexadecimalUtils = {};
+
+var hasRequiredHexadecimalUtils;
+
+function requireHexadecimalUtils () {
+	if (hasRequiredHexadecimalUtils) return HexadecimalUtils;
+	hasRequiredHexadecimalUtils = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.hexadectetNotationToBinaryString = exports.binaryStringToHexadecimalString = exports.colonHexadecimalNotationToBinaryString = exports.hexadecimalStringToHexadecatetString = exports.hexadecimalStringToBinaryString = exports.bigIntToHexadecimalString = void 0;
+		const IPv6Utils_1 = requireIPv6Utils();
+		const BinaryUtils_1 = BinaryUtils;
+		/**
+		 * Converts a given bigint number to a hexadecimal string
+		 * @param num the bigint number
+		 * @returns {string} the hexadeciaml string
+		 */
+		exports.bigIntToHexadecimalString = (num) => {
+		    return num.toString(16);
+		};
+		/**
+		 * 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 inDecimal = BigInt(`0x${hexadecimalString}`);
+		    return inDecimal.toString(2);
+		};
+		/**
+		 * 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 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);
+		};
+		/**
+		 * Given an IPv6 number in hexadecimal notated string, e.g 2001:0db8:0000:0000:0000:0000:0000:0000 converts it to
+		 * binary string
+		 *
+		 * @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 stringHexadecimal = expandedIPv6.split(":");
+		    return stringHexadecimal.reduce((binaryAsString, hexidecimal) => {
+		        return binaryAsString.concat(exports.hexadecimalStringToHexadecatetString(hexidecimal));
+		    }, '');
+		};
+		/**
+		 * Converts number in binary string to hexadecimal string
+		 * @param {string} num in binary string
+		 * @returns {string} num in hexadecimal string
+		 */
+		exports.binaryStringToHexadecimalString = (num) => {
+		    // first convert to binary string to decimal (big Integer)
+		    let inDecimal = BigInt(`0b${num}`);
+		    return inDecimal.toString(16);
+		};
+		/**
+		 * 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 hexadecimals = expand.split(":");
+		    return hexadecimals.reduce((hexadecimalAsString, hexavalue) => {
+		        return hexadecimalAsString.concat(BinaryUtils_1.leftPadWithZeroBit(exports.hexadecimalStringToBinaryString(hexavalue), 16));
+		    }, '');
+		};
+		
+} (HexadecimalUtils));
+	return HexadecimalUtils;
+}
+
+var hasRequiredValidator;
+
+function requireValidator () {
+	if (hasRequiredValidator) return Validator;
+	hasRequiredValidator = 1;
+	Object.defineProperty(Validator, "__esModule", { value: true });
+	Validator.Validator = void 0;
+	const BinaryUtils_1 = BinaryUtils;
+	const BinaryUtils_2 = BinaryUtils;
+	const IPv6Utils_1 = requireIPv6Utils();
+	const HexadecimalUtils_1 = requireHexadecimalUtils();
+	const HexadecimalUtils_2 = requireHexadecimalUtils();
+	class Validator$1 {
+	    /**
+	     * Checks if given ipNumber is in between the given lower and upper bound
+	     *
+	     * @param ipNumber ipNumber to check
+	     * @param lowerBound lower bound
+	     * @param upperBound upper bound
+	     * @returns {boolean} true if ipNumber is between lower and upper bound
+	     */
+	    static isWithinRange(ipNumber, lowerBound, upperBound) {
+	        return ipNumber >= lowerBound && ipNumber <= upperBound;
+	    }
+	    /**
+	     * Checks if the number given is within the value considered valid for an ASN number
+	     *
+	     * @param asnNumber the asn number to validate
+	     * @returns {[boolean , string]} first value is true if valid ASN, false otherwise. Second value contains
+	     * "valid" or an error message when value is invalid
+	     */
+	    static isValidAsnNumber(asnNumber) {
+	        let isValid = this.isWithinRange(asnNumber, 0n, this.THIRTY_TWO_BIT_SIZE);
+	        return [isValid, isValid ? [] : [Validator$1.invalidAsnRangeMessage]];
+	    }
+	    /**
+	     * Checks if the given ASN number is a 16bit ASN number
+	     *
+	     * @param {bigint} asnNumber to check if 16bit or not
+	     * @returns {[boolean , string]} first value is true if valid 16bit ASN, false otherwise. Second value contains
+	     * "valid" or an error message when value is invalid
+	     */
+	    static isValid16BitAsnNumber(asnNumber) {
+	        let isValid = Validator$1.isWithinRange(asnNumber, 0n, Validator$1.SIXTEEN_BIT_SIZE);
+	        return [isValid, isValid ? [] : [Validator$1.invalid16BitAsnRangeMessage]];
+	    }
+	    /**
+	     * Checks if the number given is within the value considered valid for an IPv4 number
+	     *
+	     * @param ipv4Number the asn number to validate
+	     * @returns {[boolean , string]} first value is true if valid IPv4 number, false otherwise. Second value contains
+	     * "valid" or an error message when value is invalid
+	     */
+	    static isValidIPv4Number(ipv4Number) {
+	        ipv4Number = typeof ipv4Number === "bigint" ? ipv4Number : BigInt(ipv4Number);
+	        let isValid = this.isWithinRange(ipv4Number, 0n, this.THIRTY_TWO_BIT_SIZE);
+	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidIPv4NumberMessage]];
+	    }
+	    /**
+	     * Checks if the number given is within the value considered valid for an IPv6 number
+	     *
+	     * @param ipv6Number the asn number to validate
+	     * @returns {[boolean , string]} first value is true if valid IPv6 number, false otherwise. Second value contains
+	     * "valid" or an error message when value is invalid
+	     */
+	    static isValidIPv6Number(ipv6Number) {
+	        let isValid = this.isWithinRange(ipv6Number, 0n, this.ONE_HUNDRED_AND_TWENTY_EIGHT_BIT_SIZE);
+	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidIPv6NumberMessage]];
+	    }
+	    /**
+	     * Checks if the number given is valid for an IPv4 octet
+	     *
+	     * @param octetNumber the octet value
+	     * @returns {boolean} true if valid octet, false otherwise
+	     */
+	    static isValidIPv4Octet(octetNumber) {
+	        let withinRange = this.isWithinRange(octetNumber, 0n, this.EIGHT_BIT_SIZE);
+	        return [withinRange, withinRange ? [] : [Validator$1.invalidOctetRangeMessage]];
+	    }
+	    /**
+	     * Checks if the number given is valid for an IPv6 hexadecatet
+	     *
+	     * @param {bigint} hexadecatetNum the hexadecatet value
+	     * @returns {[boolean , string]} first value is true if valid hexadecatet, false otherwise. Second value contains
+	     * "valid" or an error message when value is invalid
+	     */
+	    static isValidIPv6Hexadecatet(hexadecatetNum) {
+	        let isValid = this.isWithinRange(hexadecatetNum, 0n, this.SIXTEEN_BIT_SIZE);
+	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidHexadecatetMessage]];
+	    }
+	    /**
+	     * Checks if given string is a valid IPv4 value.
+	     *
+	     * @param {string} ipv4String the IPv4 string to validate
+	     * @returns {[boolean , string]} result of validation, first value represents if is valid IPv4, second value
+	     * contains error message if invalid IPv4
+	     */
+	    static isValidIPv4String(ipv4String) {
+	        let rawOctets = ipv4String.split(".");
+	        if (rawOctets.length != 4 || rawOctets.includes('')) {
+	            return [false, [Validator$1.invalidOctetCountMessage]];
+	        }
+	        let isValid = rawOctets.every(octet => {
+	            return Validator$1.isNumeric(octet) ? Validator$1.isValidIPv4Octet(BigInt(octet))[0] : false;
+	        });
+	        if (!isValid) {
+	            return [false, [Validator$1.invalidOctetRangeMessage]];
+	        }
+	        isValid = Validator$1.IPV4_PATTERN.test(ipv4String);
+	        return [isValid, isValid ? [] : [Validator$1.invalidIPv4PatternMessage]];
+	    }
+	    /**
+	     * Checks if given string is a valid IPv6 value.
+	     *
+	     * @param {string} ipv6String the IPv6 string to validate
+	     * @returns {[boolean , string]} result of validation, first value represents if is valid IPv6, second value
+	     * contains error message if invalid IPv6
+	     */
+	    static isValidIPv6String(ipv6String) {
+	        try {
+	            let hexadecimals = IPv6Utils_1.expandIPv6Number(ipv6String).split(":");
+	            if (hexadecimals.length != 8) {
+	                return [false, [Validator$1.invalidHexadecatetCountMessage]];
+	            }
+	            let isValid = hexadecimals.every(hexadecimal => {
+	                return Validator$1.isHexadecatet(hexadecimal) ?
+	                    Validator$1.isValidIPv6Hexadecatet(BigInt(`0x${hexadecimal}`))[0] : false;
+	            });
+	            if (!isValid) {
+	                return [false, [Validator$1.invalidHexadecatetMessage]];
+	            }
+	            isValid = Validator$1.IPV6_PATTERN.test(ipv6String);
+	            return [isValid, isValid ? [] : [Validator$1.invalidIPv6PatternMessage]];
+	        }
+	        catch (error) {
+	            return [false, [error]];
+	        }
+	    }
+	    /**
+	     * Checks if given value is a valid prefix value
+	     *
+	     * @param prefixValue value to check
+	     * @param ipNumType The type of IP number
+	     * @returns {(boolean|string)[]} a tuple representing if valid or not and corresponding message
+	     */
+	    static isValidPrefixValue(prefixValue, ipNumType) {
+	        if ("IPv4" /* IPv4 */ === ipNumType) {
+	            let withinRange = Validator$1.isWithinRange(BigInt(prefixValue), 0n, 32n);
+	            return [withinRange, withinRange ? [] : [Validator$1.invalidPrefixValueMessage]];
+	        }
+	        if ("IPv6" /* IPv6 */ === ipNumType) {
+	            let withinRange = Validator$1.isWithinRange(BigInt(prefixValue), 0n, 128n);
+	            return [withinRange, withinRange ? [] : [Validator$1.invalidPrefixValueMessage]];
+	        }
+	        return [false, [Validator$1.invalidInetNumType]];
+	    }
+	    /**
+	     * Checks if given string is a valid IPv4 mask
+	     *
+	     * @param {string} ipv4MaskString the given IPv4 mask string
+	     * @returns {[boolean , string]} first value is true if valid IPv4 mask string, false otherwise. Second value
+	     * contains "valid" or an error message when value is invalid
+	     */
+	    static isValidIPv4Mask(ipv4MaskString) {
+	        let ipv4InBinary = BinaryUtils_1.dottedDecimalNotationToBinaryString(ipv4MaskString);
+	        let isValid = Validator$1.IPV4_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv4InBinary);
+	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidMaskMessage]];
+	    }
+	    /**
+	     * Checks if given string is a valid IPv6 mask
+	     *
+	     * @param {string} ipv6MaskString the given IPv6 mask string
+	     * @returns {[boolean , string]} first value is true if valid IPv6 mask string, false otherwise. Second value
+	     * contains "valid" or an error message when value is invalid
+	     */
+	    static isValidIPv6Mask(ipv6MaskString) {
+	        let ipv6InBinary = HexadecimalUtils_2.hexadectetNotationToBinaryString(ipv6MaskString);
+	        let isValid = Validator$1.IPV6_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv6InBinary);
+	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidMaskMessage]];
+	    }
+	    /**
+	     * Checks if the given string is a valid IPv4 range in Cidr notation
+	     *
+	     * @param {string} ipv4RangeAsCidrString the IPv4 range in Cidr notation
+	     *
+	     * @returns {[boolean , string[]]} first value is true if valid IPv4 range in Cidr notation, false otherwise. Second
+	     * value contains "valid" or an error message when value is invalid
+	     */
+	    static isValidIPv4CidrNotation(ipv4RangeAsCidrString) {
+	        let cidrComponents = ipv4RangeAsCidrString.split("/");
+	        if (cidrComponents.length !== 2 || (cidrComponents[0].length === 0 || cidrComponents[1].length === 0)) {
+	            return [false, [Validator$1.invalidIPv4CidrNotationMessage]];
+	        }
+	        let ip = cidrComponents[0];
+	        let range = cidrComponents[1];
+	        if (isNaN(Number(range))) {
+	            return [false, [Validator$1.invalidIPv4CidrNotationMessage]];
+	        }
+	        let [validIpv4, invalidIpv4Message] = Validator$1.isValidIPv4String(ip);
+	        let [validPrefix, invalidPrefixMessage] = Validator$1.isValidPrefixValue(BigInt(range), "IPv4" /* IPv4 */);
+	        let isValid = validIpv4 && validPrefix;
+	        let invalidMessage = invalidIpv4Message.concat(invalidPrefixMessage);
+	        return isValid ? [isValid, []] : [isValid, invalidMessage];
+	    }
+	    /**
+	     *  Checks if the given string is a valid IPv4 range in Cidr notation, with the ip number in the cidr notation
+	     *  being the start of the range
+	     *
+	     * @param {string}  ipv4CidrNotation the IPv4 range in Cidr notation
+	     *
+	     * * @returns {[boolean , string[]]} first value is true if valid Cidr notation, false otherwise. Second
+	     * value contains [] or an array of error message when invalid
+	     */
+	    static isValidIPv4CidrRange(ipv4CidrNotation) {
+	        return Validator$1.isValidCidrRange(ipv4CidrNotation, Validator$1.isValidIPv4CidrNotation, BinaryUtils_1.dottedDecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv4" /* IPv4 */));
+	    }
+	    /**
+	     *  Checks if the given string is a valid IPv6 range in Cidr notation, with the ip number in the cidr notation
+	     *  being the start of the range
+	     *
+	     * @param {string}  ipv6CidrNotation the IPv6 range in Cidr notation
+	     *
+	     * * @returns {[boolean , string[]]} first value is true if valid Cidr notation, false otherwise. Second
+	     * value contains [] or an array of error message when invalid
+	     */
+	    static isValidIPv6CidrRange(ipv6CidrNotation) {
+	        return Validator$1.isValidCidrRange(ipv6CidrNotation, Validator$1.isValidIPv6CidrNotation, HexadecimalUtils_1.colonHexadecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv6" /* IPv6 */));
+	    }
+	    static isValidCidrRange(rangeString, cidrNotationValidator, toBinaryStringConverter, prefixFactory) {
+	        let validationResult = cidrNotationValidator(rangeString);
+	        if (!validationResult[0]) {
+	            return validationResult;
+	        }
+	        let cidrComponents = rangeString.split("/");
+	        let ip = cidrComponents[0];
+	        let range = cidrComponents[1];
+	        let ipNumber = BigInt(`0b${toBinaryStringConverter(ip)}`);
+	        let mask = BigInt(`0b${prefixFactory(parseInt(range))}`);
+	        let isValid = (ipNumber & (mask)) === (ipNumber);
+	        return isValid ? [isValid, []] : [isValid, [Validator$1.InvalidIPCidrRangeMessage]];
+	    }
+	    static isValidIPv4RangeString(ipv4RangeString) {
+	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${BinaryUtils_1.dottedDecimalNotationToBinaryString(firstIP)}`)
+	            >= BigInt(`0b${BinaryUtils_1.dottedDecimalNotationToBinaryString(lastIP)}`);
+	        return this.isValidRange(ipv4RangeString, Validator$1.isValidIPv4String, firstLastValidator);
+	    }
+	    static isValidIPv6RangeString(ipv6RangeString) {
+	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(firstIP)}`)
+	            >= BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(lastIP)}`);
+	        return this.isValidRange(ipv6RangeString, Validator$1.isValidIPv6String, firstLastValidator);
+	    }
+	    static isValidRange(rangeString, validator, firstLastValidator) {
+	        let rangeComponents = rangeString.split("-").map(component => component.trim());
+	        if (rangeComponents.length !== 2 || (rangeComponents[0].length === 0 || rangeComponents[1].length === 0)) {
+	            return [false, [Validator$1.invalidRangeNotationMessage]];
+	        }
+	        let firstIP = rangeComponents[0];
+	        let lastIP = rangeComponents[1];
+	        let [validFirstIP, invalidFirstIPMessage] = validator(firstIP);
+	        let [validLastIP, invalidLastIPMessage] = validator(lastIP);
+	        let isValid = validFirstIP && validLastIP;
+	        if (isValid && firstLastValidator(firstIP, lastIP)) {
+	            return [false, [Validator$1.invalidRangeFirstNotGreaterThanLastMessage]];
+	        }
+	        let invalidMessage = invalidFirstIPMessage.concat(invalidLastIPMessage);
+	        return isValid ? [isValid, []] : [isValid, invalidMessage];
+	    }
+	    /**
+	     * Checks if the given string is a valid IPv6 range in Cidr notation
+	     *
+	     * @param {string} ipv6RangeAsCidrString the IPv6 range in Cidr notation
+	     *
+	     * @returns {[boolean , string]} first value is true if valid IPv6 range in Cidr notation, false otherwise.
+	     * Second value contains "valid" or an error message when value is invalid
+	     */
+	    // TODO change to be like isValidIPv4CidrNotation where validation is done on the component of the cidr notation
+	    // instead of a single regex check
+	    static isValidIPv6CidrNotation(ipv6RangeAsCidrString) {
+	        let isValid = Validator$1.IPV6_RANGE_PATTERN.test(ipv6RangeAsCidrString);
+	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidIPv6CidrNotationString]];
+	    }
+	    /**
+	     * Checks if the given string is a binary string. That is contains only contiguous 1s and 0s
+	     *
+	     * @param {string} binaryString the binary string
+	     * @returns {(boolean|string)[]} a tuple representing if valid or not and corresponding message
+	     */
+	    static isValidBinaryString(binaryString) {
+	        if (/^([10])+$/.test(binaryString)) {
+	            return [true, []];
+	        }
+	        else {
+	            return [false, [Validator$1.invalidBinaryStringErrorMessage]];
+	        }
+	    }
+	    static isNumeric(value) {
+	        return /^(\d+)$/.test(value);
+	    }
+	    static isHexadecatet(value) {
+	        return /^[0-9A-Fa-f]{4}$/.test(value);
+	    }
+	}
+	Validator.Validator = Validator$1;
+	Validator$1.IPV4_PATTERN = new RegExp(/^(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$/);
+	// source: https://community.helpsystems.com/forums/intermapper/miscellaneous-topics/5acc4fcf-fa83-e511-80cf-0050568460e4
+	Validator$1.IPV6_PATTERN = new RegExp(/^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/);
+	Validator$1.IPV4_RANGE_PATTERN = new RegExp(/^(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(\/)([1-9]|[1-2][0-9]|3[0-2])$/);
+	Validator$1.IPV6_RANGE_PATTERN = new RegExp(/^s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:)))(%.+)?s*(\/([0-9]|[1-9][0-9]|1[0-1][0-9]|12[0-8]))?$/);
+	Validator$1.IPV4_CONTIGUOUS_MASK_BIT_PATTERN = new RegExp(/^(1){0,32}(0){0,32}$/);
+	Validator$1.IPV6_CONTIGUOUS_MASK_BIT_PATTERN = new RegExp(/^(1){0,128}(0){0,128}$/);
+	Validator$1.EIGHT_BIT_SIZE = BigInt(`0b${"1".repeat(8)}`);
+	Validator$1.SIXTEEN_BIT_SIZE = BigInt(`0b${"1".repeat(16)}`);
+	Validator$1.THIRTY_TWO_BIT_SIZE = BigInt(`0b${"1".repeat(32)}`);
+	Validator$1.ONE_HUNDRED_AND_TWENTY_EIGHT_BIT_SIZE = BigInt(`0b${"1".repeat(128)}`);
+	Validator$1.IPV4_SIZE = BigInt("4294967296");
+	Validator$1.IPV6_SIZE = BigInt("340282366920938463463374607431768211456");
+	Validator$1.invalidAsnRangeMessage = "ASN number given less than zero or is greater than 32bit";
+	Validator$1.invalid16BitAsnRangeMessage = "ASN number given less than zero or is greater than 16bit";
+	Validator$1.invalidIPv4NumberMessage = "IPv4 number given less than zero or is greater than 32bit";
+	Validator$1.invalidIPv6NumberMessage = "IPv6 number given less than zero or is greater than 128bit";
+	Validator$1.invalidOctetRangeMessage = "Value given contains an invalid Octet; Value is less than zero or is greater than 8bit";
+	Validator$1.invalidHexadecatetMessage = "The value given is less than zero or is greater than 16bit";
+	Validator$1.invalidOctetCountMessage = "An IP4 number cannot have less or greater than 4 octets";
+	Validator$1.invalidHexadecatetCountMessage = "An IP6 number must have exactly 8 hexadecatet";
+	Validator$1.invalidMaskMessage = "The Mask is invalid";
+	Validator$1.invalidPrefixValueMessage = "A Prefix value cannot be less than 0 or greater than 32";
+	Validator$1.invalidIPv4CidrNotationMessage = "Cidr notation should be in the form [ip number]/[range]";
+	Validator$1.InvalidIPCidrRangeMessage = "Given IP number portion must is not the start of the range";
+	Validator$1.invalidRangeNotationMessage = "Range notation should be in the form [first ip]-[last ip]";
+	Validator$1.invalidRangeFirstNotGreaterThanLastMessage = "First IP in [first ip]-[last ip] must be less than Last IP";
+	Validator$1.invalidIPv6CidrNotationString = "A Cidr notation string should contain an IPv6 number and prefix";
+	Validator$1.takeOutOfRangeSizeMessage = "$count is greater than $size, the size of the range";
+	Validator$1.cannotSplitSingleRangeErrorMessage = "Cannot split an IP range with a single IP number";
+	Validator$1.invalidInetNumType = "Given ipNumType must be either InetNumType.IPv4 or InetNumType.IPv6";
+	Validator$1.invalidBinaryStringErrorMessage = "Binary string should contain only contiguous 1s and 0s";
+	Validator$1.invalidIPRangeSizeMessage = "Given size is zero or greater than maximum size of $iptype";
+	Validator$1.invalidIPRangeSizeForCidrMessage = "Given size can't be created via cidr prefix";
+	Validator$1.invalidIPv4PatternMessage = "Given IPv4 is not confirm to a valid IPv6 address";
+	Validator$1.invalidIPv6PatternMessage = "Given IPv6 is not confirm to a valid IPv6 address";
+	
+	return Validator;
+}
+
+Object.defineProperty(Hexadecatet$1, "__esModule", { value: true });
+Hexadecatet$1.Hexadecatet = void 0;
+const Validator_1$4 = requireValidator();
+/**
+ * A representation of a 4-digit hexadecimal number.
+ *
+ * It consists of four (base 16) number. ie FFFF
+ *
+ * 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.
+     *
+     * @param {string} rawValue the four (base 16) number
+     * @returns {Hexadecatet} an instance of {@link Hexadecatet}
+     */
+    static fromString(rawValue) {
+        return new Hexadecatet(rawValue);
+    }
+    ;
+    /**
+     * A convenience method for constructing an instance of {@link Hexadecatet} from a decimal number representation
+     * of a 16 bit value
+     *
+     * @param {number} rawValue decimal number representation of a 16 bit value
+     * @returns {Hexadecatet} an instance of {@link Hexadecatet}
+     */
+    static fromNumber(rawValue) {
+        return new Hexadecatet(rawValue);
+    }
+    ;
+    /**
+     * Returns the numeric value in base 10 (ie decimal)
+     *
+     * @returns {number} the numeric value in base 10 (ie decimal)
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Returns the string representation of the base 16 representation of the value
+     * @returns {string} the string representation of the base 16 representation of the value
+     */
+    // TODO pad with a zero if digit is less than 4
+    toString() {
+        return this.value.toString(16);
+    }
+}
+Hexadecatet$1.Hexadecatet = Hexadecatet;
+
+var IPNumber = {};
+
+var Octet$1 = {};
+
+Object.defineProperty(Octet$1, "__esModule", { value: true });
+Octet$1.Octet = void 0;
+const Validator_1$3 = requireValidator();
+/**
+ * A binary representation of a 8 bit value.
+ *
+ * {@see https://en.wikipedia.org/wiki/Octet_(computing)} for more information on Octets
+ *
+ * An octet is used in the textual representation of an {@link IPv4} number, where the IP number value is divided
+ * into 4 octets
+ */
+class Octet {
+    /**
+     * Constructor for creating an instance of an Octet.
+     *
+     * The constructor parameter given could either be a string or number.
+     *
+     * If a string, it is the string representation of the numeric value of the octet
+     * If a number, it is the numeric representation of the value of the octet
+     *
+     * @param {string | number} givenValue value of the octet to be created.
+     */
+    constructor(givenValue) {
+        let octetValue;
+        if (typeof givenValue === 'string') {
+            octetValue = parseInt(givenValue);
+        }
+        else {
+            octetValue = givenValue;
+        }
+        let [isValid, message] = Validator_1$3.Validator.isValidIPv4Octet(BigInt(octetValue));
+        if (!isValid) {
+            throw Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        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
+     *
+     * @returns {number} the numeric value of the octet
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Returns a decimal representation of the value of the octet in string
+     *
+     * @returns {string} a decimal representation of the value of the octet in string
+     */
+    toString() {
+        return this.value.toString(10);
+    }
+}
+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;
+const Octet_1 = Octet$1;
+const Validator_1$2 = requireValidator();
+const BinaryUtils_1$2 = BinaryUtils;
+const BinaryUtils_2 = BinaryUtils;
+const BinaryUtils_3 = BinaryUtils;
+const BinaryUtils_4 = BinaryUtils;
+const Hexadecatet_1$1 = Hexadecatet$1;
+const HexadecimalUtils_1$1 = requireHexadecimalUtils();
+const IPv6Utils_1 = requireIPv6Utils();
+const HexadecimalUtils_2 = requireHexadecimalUtils();
+/**
+ * Provides the implementation of functionality that are common
+ * to {@link IPv4}, {@link IPv6}, {@link IPv4Mask} and {@link IPv6Mask}
+ */
+class AbstractIPNum {
+    /**
+     * Gets the numeric value of an IP number as {@link BigInt}
+     *
+     * @returns bigInt the numeric value of an IP number.
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Gets the binary string representation of an IP number.
+     *
+     * @returns {string} the string binary representation.
+     */
+    toBinaryString() {
+        return BinaryUtils_3.leftPadWithZeroBit(this.value.toString(2), this.bitSize);
+    }
+    /**
+     * Checks if an IP number has a value greater than the present value
+     * @returns {boolean} true, if there is a value greater than the present value. Returns false otherwise.
+     */
+    hasNext() {
+        return this.value < this.maximumBitSize;
+    }
+    /**
+     * Checks if an IP number has a value lesser than the present value
+     * @returns {boolean} true, if there is a value lesser than the present value. Returns false otherwise.
+     */
+    hasPrevious() {
+        return this.value > 0n;
+    }
+    /**
+     * Checks if the given IP number, is equals to the current IP number
+     *
+     * @param {AbstractIPNum} anotherIPNum the other IP number to compare with
+     * @returns {boolean} true if the given IP number is equals
+     */
+    isEquals(anotherIPNum) {
+        return this.value === anotherIPNum.value;
+    }
+    /**
+     * Checks if the given IP number is lesser than this current IP number
+     *
+     * @param {AbstractIPNum} anotherIPNum the other IP number to compare with
+     * @returns {boolean} true if the given IP number is less than this current one. False otherwise.
+     */
+    isLessThan(anotherIPNum) {
+        return this.value < anotherIPNum.value;
+    }
+    /**
+     * Checks if the given IP number is greater than this current IP number
+     *
+     * @param {AbstractIPNum} anotherIPNum the other IP number to compare with
+     * @returns {boolean} true if the given IP number is greater than this current one. False otherwise.
+     */
+    isGreaterThan(anotherIPNum) {
+        return this.value > anotherIPNum.value;
+    }
+    /**
+     * Checks if the given IP number is less than or equals to this current IP number
+     *
+     * @param {AbstractIPNum} anotherIPNum the other IP number to compare with
+     * @returns {boolean} true if the given IP number is less than or equals to this current one. False otherwise.
+     */
+    isLessThanOrEquals(anotherIPNum) {
+        return this.value <= anotherIPNum.value;
+    }
+    /**
+     * Checks if the given IP number is greater than or equals to this current IP number
+     *
+     * @param {AbstractIPNum} anotherIPNum the other IP number to compare with
+     * @returns {boolean} {boolean} true if the given IP number is greater than or equals to this current one. False
+     * otherwise.
+     */
+    isGreaterThanOrEquals(anotherIPNum) {
+        return this.value >= anotherIPNum.value;
+    }
+}
+IPNumber.AbstractIPNum = AbstractIPNum;
+/**
+ * Represents an IPv4 number. A 32 bit number that is used to uniquely identify a device that is part of a computer
+ * network that uses the internet protocol for communication.
+ *
+ * @see https://en.wikipedia.org/wiki/IPv4
+ * @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
+     *
+     * @param {bigint} bigIntValue the decimal value of the IP number in BigInt
+     * @returns {IPv4} the IPv4 instance
+     */
+    static fromNumber(bigIntValue) {
+        return new IPv4(bigIntValue);
+    }
+    /**
+     * A convenience method for creating an {@link IPv4} by providing the IP number in dot-decimal notation. E.g
+     * "10.1.1.10"
+     *
+     * {@see https://en.wikipedia.org/wiki/Dot-decimal_notation} for more information on dot-decimal notation.
+     *
+     * @param {string} ipString the IP number in dot-decimal notation
+     * @returns {IPv4} the IPv4 instance
+     */
+    static fromDecimalDottedString(ipString) {
+        return new IPv4(ipString);
+    }
+    /**
+     * Alias for IPv4.fromDecimalDottedString.
+     *
+     * @param {string} ipString the IP number in dot-decimal notation
+     * @returns {IPv4} the IPv4 instance
+     */
+    static fromString(ipString) {
+        return IPv4.fromDecimalDottedString(ipString);
+    }
+    /**
+     * A convenience method for creating an {@link IPv4} from binary string
+     *
+     * @param {string} ipBinaryString the binary string representing the IPv4 number to be created
+     * @returns {IPv4} the IPv4 instance
+     */
+    static fromBinaryString(ipBinaryString) {
+        let validationResult = Validator_1$2.Validator.isValidBinaryString(ipBinaryString);
+        if (validationResult[0]) {
+            return new IPv4(BinaryUtils_2.parseBinaryStringToBigInt(ipBinaryString));
+        }
+        else {
+            throw Error(validationResult[1].join(','));
+        }
+    }
+    /**
+     * A string representation of the IPv4 number. The string representation is in dot-decimal notation
+     *
+     * @returns {string} The string representation in dot-decimal notation
+     */
+    toString() {
+        return this.octets.map((value) => { return value.toString(); }).join(this.separator);
+    }
+    /**
+     * Gets the individual {@link Octet} that makes up the IPv4 number
+     *
+     * @returns {Array<Octet>} The individual {@link Octet} that makes up the IPv4 number
+     */
+    getOctets() {
+        return this.octets;
+    }
+    /**
+     * Returns the next IPv4 number
+     *
+     * @returns {IPv4} the next IPv4 number
+     */
+    nextIPNumber() {
+        return IPv4.fromNumber(this.getValue() + 1n);
+    }
+    /**
+     * Returns the previous IPv4 number
+     *
+     * @returns {IPv4} the previous IPv4 number
+     */
+    previousIPNumber() {
+        return IPv4.fromNumber(this.getValue() - 1n);
+    }
+    /**
+     * Returns this IPv4 number as a IPv4-Mapped IPv6 Address
+     *
+     * The IPv4-Mapped IPv6 Address allows an IPv4 number to be embedded within an IPv6 number
+     *
+     * {@see https://tools.ietf.org/html/rfc4291#section-2.5.5} for more information on the IPv4-Mapped IPv6 Address
+     *
+     * @returns {IPv6} an IPv6 number with the IPv4 embedded within it
+     */
+    toIPv4MappedIPv6() {
+        let binary = '1'.repeat(16) + this.toBinaryString();
+        return IPv6.fromBinaryString(binary);
+    }
+    constructFromDecimalDottedString(ipString) {
+        let octets;
+        let value;
+        let [isValid, message] = Validator_1$2.Validator.isValidIPv4String(ipString);
+        if (!isValid) {
+            throw new Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        let stringOctets = ipString.split(".");
+        octets = stringOctets.map((rawOctet) => {
+            return Octet_1.Octet.fromString(rawOctet);
+        });
+        value = BigInt(`0b${BinaryUtils_1$2.dottedDecimalNotationToBinaryString(ipString)}`);
+        return [value, octets];
+    }
+    constructFromBigIntValue(ipv4Number) {
+        let [isValid, message] = Validator_1$2.Validator.isValidIPv4Number(ipv4Number);
+        if (!isValid) {
+            throw new Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        let binaryString = 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);
+        }
+        let octets = ipv4BinaryString.match(/.{1,8}/g);
+        return octets.map((octet) => {
+            return Octet_1.Octet.fromString(BinaryUtils_2.parseBinaryStringToBigInt(octet).toString());
+        });
+    }
+}
+IPNumber.IPv4 = IPv4;
+/**
+ * Represents an Autonomous System Number. Which is a number that is used to identify
+ * a group of IP addresses with a common, clearly defined routing policy.
+ *
+ * @see https://en.wikipedia.org/wiki/Autonomous_system_(Internet)
+ * @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
+     *
+     * The given string can be in asplain, asdot or asdot+ representation format.
+     * {@see https://tools.ietf.org/html/rfc5396} for more information on
+     * the different ASN string representation
+     *
+     * @param {string} rawValue the asn string. In either asplain, asdot or asdot+ format
+     * @returns {Asn} the constructed ASN instance
+     */
+    static fromString(rawValue) {
+        return new Asn(rawValue);
+    }
+    ;
+    /**
+     * A convenience method for creating an instance of {@link Asn} from a numeric value
+     *
+     * @param {number} rawValue the asn numeric value
+     * @returns {Asn} the constructed ASN instance
+     */
+    static fromNumber(rawValue) {
+        return new Asn(rawValue);
+    }
+    ;
+    /**
+     * A convenience method for creating an instance of {@link Asn} from a binary string
+     *
+     * @param {string} binaryString to create an ASN instance from
+     * @returns {Asn} the constructed ASN instance
+     */
+    static fromBinaryString(binaryString) {
+        let validationResult = Validator_1$2.Validator.isValidBinaryString(binaryString);
+        if (validationResult[0]) {
+            return new Asn(parseInt(binaryString, 2));
+        }
+        else {
+            throw Error(validationResult[1].join(','));
+        }
+    }
+    /**
+     * A string representation where the asn value is prefixed by "ASN". For example "AS65526"
+     *
+     * @returns {string} A string representation where the asn value is prefixed by "ASN"
+     */
+    toString() {
+        let stringValue = this.value.toString();
+        return `${Asn.AS_PREFIX}${stringValue}`;
+    }
+    /**
+     * A string representation where the ASN numeric value of is represented as a string. For example "65526"
+     *
+     * @returns {string} A string representation where the ASN numeric value of is represented as a string
+     */
+    toASPlain() {
+        return this.value.toString();
+    }
+    /**
+     * A string representation where the ASN value is represented using the asplain notation if the ASN value is
+     * less than 65536 and uses asdot+ notation when the value is greater than 65536.
+     *
+     * For example 65526 will be represented as "65526" while 65546 will be represented as "1.10"
+     *
+     *
+     * @returns {string} A string representation of the ASN in either asplain or asdot+ notation depending on
+     * whether the numeric value of the ASN number is greater than 65526 or not.
+     */
+    toASDot() {
+        if (this.value.valueOf() >= 65536n) {
+            return this.toASDotPlus();
+        }
+        return this.toASPlain();
+    }
+    /**
+     * A string representation where the ASN value is represented using the asdot+ notation
+     *
+     * @returns {string} A string representation where the ASN value is represented using the asdot+ notation
+     *
+     */
+    toASDotPlus() {
+        let high = this.value.valueOf() / 65535n;
+        let low = (this.value.valueOf() % 65535n) - high;
+        return `${high}.${low}`;
+    }
+    /**
+     * Converts the ASN value to binary numbers represented with strings
+     *
+     * @returns {string} a binary string representation of the value of the ASN number
+     */
+    toBinaryString() {
+        return BinaryUtils_4.numberToBinaryString(this.value);
+    }
+    /**
+     * Checks if the ASN value is 16bit
+     *
+     * @returns {boolean} true if the ASN is a 16bit value. False otherwise.
+     */
+    is16Bit() {
+        let [valid16BitAsnNumber,] = Validator_1$2.Validator.isValid16BitAsnNumber(this.value);
+        return valid16BitAsnNumber;
+    }
+    /**
+     * Checks if the ASN value is 32bit
+     *
+     * @returns {boolean} true if the ASN is a 32bit value. False otherwise.
+     */
+    is32Bit() {
+        return !this.is16Bit();
+    }
+    /**
+     * Returns the next ASN number
+     *
+     * @returns {AbstractIPNum} the next ASN number
+     */
+    nextIPNumber() {
+        return new Asn(this.value.valueOf() + 1n);
+    }
+    /**
+     * Returns the previous ASN number
+     *
+     * @returns {AbstractIPNum} the previous ASN number
+     */
+    previousIPNumber() {
+        return new Asn(this.value.valueOf() - 1n);
+    }
+    static startWithASPrefix(word) {
+        return word.indexOf(Asn.AS_PREFIX) === 0;
+    }
+    parseFromDotNotation(rawValue) {
+        let values = rawValue.split(".");
+        let high = parseInt(values[0]);
+        let low = parseInt(values[1]);
+        return (high * 65535) + (low + high);
+    }
+}
+IPNumber.Asn = Asn;
+Asn.AS_PREFIX = "AS";
+/**
+ * Represents an IPv6 number. A 128 bit number that is used to uniquely identify a device that is part of a computer
+ * network that uses the internet protocol for communication.
+ *
+ * @see https://en.wikipedia.org/wiki/IPv6
+ * @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
+     *
+     * @param {bigint} bigIntValue the decimal value of the IP number in BigInt
+     * @returns {IPv6} the IPv6 instance
+     */
+    static fromBigInt(bigIntValue) {
+        return new IPv6(bigIntValue);
+    }
+    /**
+     * A convenience method for creating an {@link IPv6} by providing the IP number in hexadecatet notation. E.g
+     * "2001:800:0:0:0:0:0:2002"
+     *
+     * {@see https://en.wikipedia.org/wiki/IPv6_address#Representation} for more information on hexadecatet notation.
+     *
+     * @param {string} ipString the IP number in hexadecatet
+     * @returns {IPv6} the IPv6 instance
+     */
+    static fromHexadecatet(ipString) {
+        return new IPv6(ipString);
+    }
+    /**
+     * Alias for IPv6.fromHexadecimalString
+     *
+     * @param {string} ipString the IP number in hexadecatet
+     * @returns {IPv6} the IPv6 instance
+     */
+    static fromString(ipString) {
+        return IPv6.fromHexadecatet(ipString);
+    }
+    /**
+     * A convenience method for creating an {@link IPv6} from binary string
+     *
+     * @param {string} ipBinaryString the binary string representing the IPv6 number to be created
+     * @returns {IPv6} the IPv6 instance
+     */
+    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));
+        }
+        else {
+            throw Error(validationResult[1].join(','));
+        }
+    }
+    /**
+     * A convenience method for creating an IPv4-Compatible {@link IPv6} Address from an instance of {@link IPv4}
+     *
+     * @param {IPv4} ipv4 to create an IPv4-Compatible {@link IPv6} Address
+     * @returns {IPv6} the IPv4-Compatible {@link IPv6} Address
+     */
+    static fromIPv4(ipv4) {
+        return ipv4.toIPv4MappedIPv6();
+    }
+    /**
+     * A convenience method for creating an IPv4-Compatible {@link IPv6} Address from a IPv4 represented in
+     * dot-decimal notation i.e. 127.0.0.1
+     *
+     * @param {IPv4} ip4DotDecimalString string represented in a dot decimal string
+     * @returns {IPv6} the IPv4-Compatible {@link IPv6} Address
+     */
+    static fromIPv4DotDecimalString(ip4DotDecimalString) {
+        return new IPv4(ip4DotDecimalString).toIPv4MappedIPv6();
+    }
+    /**
+     * A string representation of the IPv6 number.
+     *
+     * @returns {string} The string representation of IPv6
+     */
+    toString() {
+        let ipv6String = this.hexadecatet.map((value) => { return value.toString(); }).join(":");
+        if (this.hexadecatet.length < 8) {
+            return "::" + ipv6String;
+        }
+        else {
+            return ipv6String;
+        }
+    }
+    /**
+     * Gets the individual {@link Hexadecatet} that makes up the IPv6 number
+     *
+     * @returns {Array<Hexadecatet>} The individual {@link Hexadecatet} that makes up the IPv6 number
+     */
+    //TODO maybe rename to something like getSegments? so it can be same with getOctet
+    getHexadecatet() {
+        return this.hexadecatet;
+    }
+    /**
+     * Returns the next IPv6 number
+     *
+     * @returns {IPv6} the next IPv6 number
+     */
+    nextIPNumber() {
+        return IPv6.fromBigInt(this.getValue() + 1n);
+    }
+    /**
+     * Returns the previous IPv6 number
+     *
+     * @returns {IPv6} the previous IPv6 number
+     */
+    previousIPNumber() {
+        return IPv6.fromBigInt(this.getValue() - 1n);
+    }
+    constructFromBigIntValue(ipv6Number) {
+        let [isValid, message] = Validator_1$2.Validator.isValidIPv6Number(ipv6Number);
+        if (!isValid) {
+            throw new Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        let binaryString = BinaryUtils_4.numberToBinaryString(ipv6Number);
+        return [ipv6Number, this.binaryStringToHexadecatets(binaryString)];
+    }
+    constructFromHexadecimalDottedString(expandedIPv6) {
+        let [isValid, message] = Validator_1$2.Validator.isValidIPv6String(expandedIPv6);
+        if (!isValid) {
+            throw new Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        let stringHexadecimals = expandedIPv6.split(":");
+        let hexadecatet = stringHexadecimals.map((stringHexadecatet) => {
+            return Hexadecatet_1$1.Hexadecatet.fromString(stringHexadecatet);
+        });
+        let value = BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(expandedIPv6)}`);
+        return [value, hexadecatet];
+    }
+    binaryStringToHexadecatets(binaryString) {
+        let hexadecimalString = HexadecimalUtils_1$1.binaryStringToHexadecimalString(binaryString);
+        while (hexadecimalString.length % 4 != 0) {
+            hexadecimalString = '0' + hexadecimalString;
+        }
+        let hexadecimalStrings = hexadecimalString.match(/.{1,4}/g);
+        return hexadecimalStrings.map((stringHexadecatet) => {
+            return Hexadecatet_1$1.Hexadecatet.fromString(stringHexadecatet);
+        });
+    }
+}
+IPNumber.IPv6 = IPv6;
+/**
+ * The IPv4Mask can be seen as a specialized IPv4 number where, in a 32 bit number, starting from the left, you
+ * have continuous bits turned on (with 1 value) followed by bits turned off (with 0 value). In networking, it is used
+ * 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 {
+    /**
+     * Constructor for creating an instance of IPv4Mask.
+     * The passed strings need to be a valid IPv4 mask number in dot-decimal notation.
+     *
+     * @param {string} ipString The passed string in dot-decimal notation
+     */
+    constructor(ipString) {
+        super(ipString);
+        /**
+         * An array of {@link Octet}'s
+         *
+         * @type {Array} the octets that makes up the IPv4Mask
+         */
+        this.octets = [];
+        let isValid;
+        let message;
+        [isValid, message] = Validator_1$2.Validator.isValidIPv4Mask(ipString);
+        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);
+    }
+    ;
+}
+IPNumber.IPv4Mask = IPv4Mask;
+/**
+ * The IPv6Mask can be seen as a specialized IPv4 number where, in a 128 bit number, starting from the left,
+ * you have continuous bits turned on (with 1 value) followed by bits turned off (with 0 value). In networking, it
+ * is used to demarcate which bits are used to identify a network, and the ones that are used to identify hosts
+ * on the network
+ */
+class IPv6Mask extends IPv6 {
+    /**
+     * Constructor for creating an instance of IPv6Mask.
+     * The passed strings need to be a valid IPv6 mask number in dot-decimal notation
+     *
+     * @param {string} ipString The passed IPv6 string
+     */
+    constructor(ipString) {
+        super(ipString);
+        /**
+         * An array of {@link Hexadecatet}'s
+         *
+         * @type {Array} the hexadecatet that makes up the IPv6 number
+         */
+        this.hexadecatet = [];
+        let isValid;
+        let message;
+        let expandedIPv6 = IPv6Utils_1.expandIPv6Number(ipString);
+        [isValid, message] = Validator_1$2.Validator.isValidIPv6Mask(expandedIPv6);
+        if (!isValid) {
+            throw new Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        let stringHexadecimals = expandedIPv6.split(":");
+        this.hexadecatet = stringHexadecimals.map((stringHexadecatet) => {
+            return Hexadecatet_1$1.Hexadecatet.fromString(stringHexadecatet);
+        });
+        let binaryString = 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);
+    }
+    ;
+}
+IPNumber.IPv6Mask = IPv6Mask;
+/**
+ * Check is the given IP number is an {@link IPv4} or not
+ * @param ip the IP number to check if it is IPv4.
+ */
+function isIPv4(ip) {
+    return ip.bitSize === 32;
+}
+IPNumber.isIPv4 = isIPv4;
+
+var IPNumType = {};
+
+Object.defineProperty(IPNumType, "__esModule", { value: true });
+
+var IPPool = {};
+
+var IPRange = {};
+
+var Prefix = {};
+
+Object.defineProperty(Prefix, "__esModule", { value: true });
+Prefix.isIPv4Prefix = Prefix.IPv6Prefix = Prefix.IPv4Prefix = void 0;
+const Validator_1$1 = requireValidator();
+const IPNumber_1$1 = IPNumber;
+const BinaryUtils_1$1 = BinaryUtils;
+const HexadecimalUtils_1 = requireHexadecimalUtils();
+const Hexadecatet_1 = Hexadecatet$1;
+/**
+ * Represents the prefix portion in the CIDR notation for representing IP ranges
+ *
+ * The IPv4 prefix portion represents the mask. It is the number of continuous bits turned on (with value 1)
+ * counting from the left side of an 8 bit value.
+ *
+ * {@see https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing} for more information on CIDR
+ */
+class IPv4Prefix {
+    /**
+     * Constructor for 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
+     */
+    constructor(rawValue) {
+        this.type = "IPv4";
+        this.bitValue = 32n;
+        let isValid;
+        let message;
+        [isValid, message] = Validator_1$1.Validator.isValidPrefixValue(rawValue, "IPv4" /* 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
+     *
+     * @returns {number} the decimal value of the IPv4 prefix
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Gets the decimal value of the IPv4 prefix as string
+     * @returns {string} The decimal value of the IPv4 prefix as string
+     */
+    toString() {
+        return this.value.toString();
+    }
+    /**
+     * Converts the IPv4 prefix to a {@link IPv4Mask}
+     *
+     * The IPv4 mask is the representation of the prefix in the dot-decimal notation
+     *
+     * @returns {IPv4Mask} the mask representation of the prefix
+     */
+    toMask() {
+        let onBits = '1'.repeat(Number(this.value));
+        let offBits = '0'.repeat(Number(32n - this.value));
+        return IPNumber_1$1.IPv4Mask.fromDecimalDottedString(this.toDecimalNotation(`${onBits}${offBits}`));
+    }
+    /**
+     * Returns the size (number of IP numbers) of range of this prefix
+     *
+     * @return {bigint} the size (number of IP numbers) of range of this prefix
+     */
+    toRangeSize() {
+        /**
+         * Using bitwise shift operation this will be
+         * 1 << (this.bitValue - this.getValue())
+         * Since left shift a number by x is equivalent to multiplying the number by the power x raised to 2
+         * 2 << 4 = 2 * (2 raised to 4)
+         */
+        return 1n << (this.bitValue - this.getValue());
+    }
+    /**
+     * Returns a prefix for when this prefix is merged
+     * with another prefix of the same size
+     */
+    merge() {
+        return new IPv4Prefix(this.value - 1n);
+    }
+    /**
+     * Returns a prefix for when this prefix is split
+     * into two equal halves
+     */
+    split() {
+        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))}`;
+    }
+}
+Prefix.IPv4Prefix = IPv4Prefix;
+/**
+ * Represents the prefix portion in the CIDR notation for representing IP ranges
+ *
+ * The IPv6 prefix portion represents the mask. It is the number of continuous bits turned on (with value 1)
+ * counting from the left side of an 128 bit value.
+ *
+ * {@see https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing} for more information on CIDR
+ */
+class IPv6Prefix {
+    /**
+     * Constructor for an instance of IPv6 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
+     */
+    constructor(rawValue) {
+        this.type = "IPv6";
+        this.bitValue = 128n;
+        let isValid;
+        let message;
+        [isValid, message] = Validator_1$1.Validator.isValidPrefixValue(rawValue, "IPv6" /* 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
+     *
+     * @returns {number} the decimal value of the IPv6 prefix
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Gets the decimal value of the IPv4 prefix as string
+     * @returns {string} he decimal value of the IPv4 prefix as string
+     */
+    toString() {
+        return this.value.toString();
+    }
+    /**
+     * Converts the IPv6 prefix to a {@link IPv6Mask}
+     *
+     * The IPv6 mask is the representation of the prefix in 8 groups of 16 bit values represented in hexadecimal
+     *
+     * @returns {IPv6Mask} the mask representation of the prefix
+     */
+    toMask() {
+        let onBits = '1'.repeat(Number(this.value));
+        let offBits = '0'.repeat(128 - Number(this.value));
+        return IPNumber_1$1.IPv6Mask.fromHexadecatet(this.toHexadecatetNotation(`${onBits}${offBits}`));
+    }
+    /**
+     * Returns the size (number of IP numbers) of range of this prefix
+     *
+     * @return {bigint} the size (number of IP numbers) of range of this prefix
+     */
+    toRangeSize() {
+        /**
+         * Using bitwise shift operation this will be
+         * 1 << (this.bitValue - this.getValue())
+         * Since left shift a number by x is equivalent to multiplying the number by the power x raised to 2
+         * 2 << 4 = 2 * (2 raised to 4)
+         */
+        return 1n << (this.bitValue - this.getValue());
+    }
+    /**
+     * Returns a prefix for when this prefix is merged
+     * with another prefix of the same size
+     */
+    merge() {
+        return new IPv6Prefix(this.value - 1n);
+    }
+    /**
+     * Returns a prefix for when this prefix is split
+     * into two equal halves
+     */
+    split() {
+        return new IPv6Prefix(this.value + 1n);
+    }
+    toHexadecatetNotation(bits) {
+        let binaryStrings = bits.match(/.{1,16}/g);
+        let hexadecimalStrings = binaryStrings.map((binaryString) => {
+            return Hexadecatet_1.Hexadecatet.fromString(HexadecimalUtils_1.binaryStringToHexadecimalString(binaryString));
+        });
+        return hexadecimalStrings.map((value) => { return value.toString(); }).join(":");
+    }
+}
+Prefix.IPv6Prefix = IPv6Prefix;
+function rangeSizeToPrefix(rangeSize, rangeMaxSize) {
+    let ipType = rangeMaxSize > (Validator_1$1.Validator.IPV4_SIZE) ? "IPv6" : "IPv4";
+    if (rangeSize > (rangeMaxSize) || rangeSize === (0n)) {
+        throw new Error(Validator_1$1.Validator.invalidIPRangeSizeMessage.replace("$iptype", ipType));
+    }
+    try {
+        return BinaryUtils_1$1.intLog2(rangeSize);
+    }
+    catch (e) {
+        throw new Error(Validator_1$1.Validator.invalidIPRangeSizeForCidrMessage);
+    }
+}
+/**
+ * Check is the given Prefix is an {@link IPv4Prefix} or not
+ * @param prefix the IP prefix to check if it is IPv4Prefix.
+ */
+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;
+const IPNumber_1 = IPNumber;
+const Prefix_1$1 = Prefix;
+const BinaryUtils_1 = BinaryUtils;
+const Validator_1 = requireValidator();
+/**
+ * Represents a continuous segment of either IPv4 or IPv6 numbers
+ * without adhering to classless inter-domain routing scheme
+ * 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.
+     *
+     * @param ip The IP number, either IPv4 or IPv6 to construct the range from.
+     */
+    static fromSingleIP(ip) {
+        return new RangedSet(ip, ip);
+    }
+    /**
+     * Convenience method for constructing an instance of {@link RangedSet} from an
+     * instance of either {@link IPv4CidrRange} or {@link IPv6CidrRange}
+     *
+     * @param cidrRange an instance of {@link RangedSet}
+     */
+    static fromCidrRange(cidrRange) {
+        return new RangedSet(cidrRange.getFirst(), cidrRange.getLast());
+    }
+    /**
+     * Convenience method for constructing an instance of {@link RangedSet} from
+     * a range string in the form of firstIp-lastIp
+     *
+     * @param rangeString  string in the form of firstIp-lastIp
+     */
+    static fromRangeString(rangeString) {
+        let ips = rangeString.split("-").map(ip => ip.trim());
+        if (ips.length !== 2) {
+            throw new Error("Argument should be in the format firstip-lastip");
+        }
+        let [firstIPString, lastIPString] = ips;
+        let [isValidFirstIPv4,] = Validator_1.Validator.isValidIPv4String(firstIPString);
+        let [isValidSecondIPv4,] = Validator_1.Validator.isValidIPv4String(lastIPString);
+        let [isValidFirstIPv6,] = Validator_1.Validator.isValidIPv6String(firstIPString);
+        let [isValidLastIPv6,] = Validator_1.Validator.isValidIPv6String(lastIPString);
+        if (isValidFirstIPv4 && isValidSecondIPv4) {
+            return new RangedSet(IPNumber_1.IPv4.fromDecimalDottedString(firstIPString), IPNumber_1.IPv4.fromDecimalDottedString(lastIPString));
+        }
+        else if (isValidFirstIPv6 && isValidLastIPv6) {
+            return new RangedSet(IPNumber_1.IPv6.fromHexadecatet(firstIPString), IPNumber_1.IPv6.fromHexadecatet(lastIPString));
+        }
+        else {
+            throw new Error("First IP and Last IP should be valid and same type");
+        }
+    }
+    /**
+     * Returns the first IP number in the range
+     */
+    getFirst() {
+        return this.first;
+    }
+    /**
+     * Returns the last IP number in the range
+     */
+    getLast() {
+        return this.last;
+    }
+    /**
+     * Returns the size, which is the number of IP numbers in the range.
+     */
+    getSize() {
+        return this.last.getValue() - (this.first.getValue()) + 1n;
+    }
+    /**
+     * Converts to a string representation of the range in the form of:
+     * <first-ip>-<last-ip>
+     */
+    toRangeString() {
+        return `${this.getFirst()}-${this.getLast()}`;
+    }
+    /**
+     * Checks if this range is inside another range.
+     *
+     * @param otherRange the other range to check if this range is inside of.
+     */
+    inside(otherRange) {
+        return otherRange.contains(this);
+    }
+    /**
+     * Checks if this range contains the given other range.
+     *
+     * @param otherRange the other range to check if this range contains
+     */
+    contains(otherRange) {
+        let thisFirst = this.getFirst();
+        let thisLast = this.getLast();
+        let otherFirst = otherRange.getFirst();
+        let otherLast = otherRange.getLast();
+        return (thisFirst.isLessThanOrEquals(otherFirst) && thisLast.isGreaterThanOrEquals(otherLast));
+    }
+    /**
+     * Check if this range is equal to the given other range.
+     *
+     * @param otherRange the other range to check if equal to this range.
+     */
+    isEquals(otherRange) {
+        return this.getFirst().isEquals(otherRange.getFirst())
+            && this.getLast().isEquals(otherRange.getLast());
+    }
+    ;
+    /**
+     * Check if this range is less than the given range.
+     *
+     * @param otherRange the other range to check if less than.
+     */
+    isLessThan(otherRange) {
+        if (this.isEquals(otherRange)) {
+            return false;
+        }
+        else {
+            if (this.getFirst().isEquals(otherRange.getFirst())) {
+                return this.getSize() < (otherRange.getSize());
+            }
+            return this.getFirst().isLessThan(otherRange.getFirst());
+        }
+    }
+    /**
+     * Check if this range is greater than the given range.
+     *
+     * @param otherRange the other range to check if greater than.
+     */
+    isGreaterThan(otherRange) {
+        if (this.isEquals(otherRange)) {
+            return false;
+        }
+        else {
+            if (this.getFirst().isEquals(otherRange.getFirst())) {
+                return this.getSize() > (otherRange.getSize());
+            }
+            return this.getFirst().isGreaterThan(otherRange.getFirst());
+        }
+    }
+    /**
+     * Checks of this range overlaps with a given other range.
+     *
+     * This means it checks if part of a range is part of another range without
+     * being totally contained in the other range. Hence Equal or ranges contained inside one
+     * another are not considered as overlapping.
+     *
+     * @param otherRange the other range to check if it overlaps with this range.
+     */
+    isOverlapping(otherRange) {
+        let thisFirst = this.getFirst();
+        let thisLast = this.getLast();
+        let otherFirst = otherRange.getFirst();
+        let otherLast = otherRange.getLast();
+        return (thisLast.isGreaterThan(otherFirst) && thisLast.isLessThanOrEquals(otherLast) && thisFirst.isLessThan(otherFirst)
+            ||
+                otherLast.isGreaterThan(thisFirst) && otherLast.isLessThanOrEquals(thisLast) && otherFirst.isLessThan(thisFirst));
+    }
+    /**
+     * Check if this range can be converted to a CIDR range.
+     */
+    isCidrAble() {
+        if (this.getSize() === 1n) {
+            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 */));
+            return (this.first.getValue()) === (netmask & (this.first.getValue()));
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Converts an instance of range to an instance of CIDR range
+     */
+    toCidrRange() {
+        if (IPNumber_1.isIPv4(this.currentValue)) {
+            return this.toIPv4CidrRange();
+        }
+        else {
+            return this.toIPv6CidrRange();
+        }
+    }
+    ;
+    /**
+     * Checks if this range is consecutive with another range.
+     *
+     * This means if the two ranges can be placed side by side, without any gap. Hence Equal
+     * or ranges contained inside one another, or overlapping ranges are not considered as consecutive.
+     *
+     * @param otherRange the other range to check if this range is consecutive to.
+     */
+    isConsecutive(otherRange) {
+        let thisFirst = this.getFirst();
+        let thisLast = this.getLast();
+        let otherFirst = otherRange.getFirst();
+        let otherLast = otherRange.getLast();
+        return (thisLast.hasNext() && thisLast.nextIPNumber().isEquals(otherFirst)
+            ||
+                otherLast.hasNext() && otherLast.nextIPNumber().isEquals(thisFirst));
+    }
+    /**
+     * Creates a range that is a union of this range and the given other range.
+     *
+     * @param otherRange the other range to combine with this range
+     */
+    union(otherRange) {
+        if (this.isEquals(otherRange)) {
+            return new RangedSet(otherRange.getFirst(), otherRange.getLast());
+        }
+        if (this.isOverlapping(otherRange)) {
+            if (this.getFirst().isLessThan(otherRange.getFirst())) {
+                return new RangedSet(this.getFirst(), otherRange.getLast());
+            }
+            else {
+                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");
+    }
+    /**
+     * Prepends given range with this range.
+     * The last IP in the given range should be adjacent to the first IP in this range
+     *
+     * @param otherRange the other range to prepend
+     */
+    prepend(otherRange) {
+        if (otherRange.getLast().nextIPNumber().isEquals(this.getFirst())) {
+            return new RangedSet(otherRange.getFirst(), this.getLast());
+        }
+        else {
+            throw new Error("Range to prepend must be adjacent");
+        }
+    }
+    /**
+     * Appends given range with this range.
+     * The last IP in this range should be adjacent to the first IP in range to append
+     *
+     * @param otherRange the other range to append
+     */
+    append(otherRange) {
+        if (this.getLast().nextIPNumber().isEquals(otherRange.getFirst())) {
+            return new RangedSet(this.getFirst(), otherRange.getLast());
+        }
+        else {
+            throw new Error("Range to append must be adjacent");
+        }
+    }
+    subtract(otherRange) {
+        if (!this.isOverlapping(otherRange)) {
+            throw new Error("Cannot subtract ranges that are not overlapping");
+        }
+        if (!this.isLessThan(otherRange)) {
+            throw new Error("Cannot subtract a larger range from this range");
+        }
+        return new RangedSet(this.getFirst(), otherRange.getLast());
+    }
+    /**
+     * Returns a sub range of a given size from this range.
+     *
+     * @param offset offset from this range where the subrange should begin
+     * @param size the size of the range
+     */
+    takeSubRange(offset, size) {
+        if (offset + (size) > (this.getSize())) {
+            throw new RangeError("Requested range is greater than what can be taken");
+        }
+        if (size === (0n)) {
+            throw new Error("Sub range cannot be zero");
+        }
+        let valueOfFirstIp = this.getFirst().value + (offset);
+        let firstIp = 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);
+        return new RangedSet(firstIp, lastIp);
+    }
+    /**
+     * Performs a subtraction operation, where the passed range is removed from the original range.
+     *
+     * The return range from the subtraction operation could be a single or multiple ranges
+     *
+     * @param range
+     */
+    difference(range) {
+        if (range.getSize() > (this.getSize())) {
+            throw new Error("Range is greater than range to be subtracted from");
+        }
+        if (!this.contains(range)) {
+            throw new Error("Range to subtract is not contained in this range");
+        }
+        let reminders = [];
+        try {
+            reminders.push(new RangedSet(this.getFirst(), range.getFirst().previousIPNumber()));
+        }
+        catch (e) { }
+        try {
+            reminders.push(new RangedSet(range.getLast().nextIPNumber(), this.getLast()));
+        }
+        catch (e) { }
+        return reminders;
+    }
+    *take(count) {
+        let computed = this.getFirst();
+        let returnCount = count === undefined ? this.getSize().valueOf() : count;
+        while (returnCount > 0) {
+            returnCount--;
+            yield computed;
+            computed = computed.nextIPNumber();
+        }
+    }
+    *[Symbol.iterator]() {
+        yield* this.take();
+    }
+    toIPv4CidrRange() {
+        let candidateRange = new IPv4CidrRange(IPNumber_1.IPv4.fromNumber(this.getFirst().getValue()), Prefix_1$1.IPv4Prefix.fromRangeSize(this.getSize()));
+        if (candidateRange.getFirst().isEquals(this.getFirst())) {
+            return candidateRange;
+        }
+        else {
+            throw new Error("Range cannot be converted to CIDR");
+        }
+    }
+    toIPv6CidrRange() {
+        let candidateRange = new IPv6CidrRange(IPNumber_1.IPv6.fromBigInt(this.getFirst().getValue()), Prefix_1$1.IPv6Prefix.fromRangeSize(this.getSize()));
+        if (candidateRange.getFirst().isEquals(this.getFirst())) {
+            return candidateRange;
+        }
+        else {
+            throw new Error("Range cannot be converted to CIDR");
+        }
+    }
+}
+IPRange.RangedSet = RangedSet;
+/**
+ * Provides the implementation of functionality that are common to {@link IPv4CidrRange} and {@link IPv6CidrRange}
+ */
+class AbstractIPRange {
+    hasNextRange() {
+        let sizeOfCurrentRange = this.getSize();
+        return ((2n ** this.bitValue) - sizeOfCurrentRange) >= (this.getFirst().getValue() + (sizeOfCurrentRange));
+    }
+    hasPreviousRange() {
+        return this.getSize() <= (this.getFirst().getValue());
+    }
+    toRangeSet() {
+        return new RangedSet(this.getFirst(), this.getLast());
+    }
+    inside(otherRange) {
+        return this.toRangeSet().inside(otherRange.toRangeSet());
+    }
+    contains(otherRange) {
+        return this.toRangeSet().contains(otherRange.toRangeSet());
+    }
+    toRangeString() {
+        return this.toRangeSet().toRangeString();
+    }
+    isOverlapping(otherRange) {
+        return this.toRangeSet().isOverlapping(otherRange.toRangeSet());
+    }
+    isConsecutive(otherRange) {
+        return this.toRangeSet().isConsecutive(otherRange.toRangeSet());
+    }
+    isCidrMergeable(otherRange) {
+        const count = BigInt(BinaryUtils_1.matchingBitCount(this.getFirst().toBinaryString(), otherRange.getFirst().toBinaryString()));
+        if (this.getPrefix().value - count !== 1n) {
+            return false;
+        }
+        return this.isConsecutive(otherRange) && this.getSize() === (otherRange.getSize());
+    }
+    isMergeable(otherRange) {
+        return this.isCidrMergeable(otherRange)
+            || this.contains(otherRange)
+            || this.inside(otherRange);
+    }
+    isEquals(otherRange) {
+        return this.toRangeSet().isEquals(otherRange.toRangeSet());
+    }
+    merge(otherRange) {
+        if (!this.isCidrMergeable(otherRange)) {
+            throw new Error(`Cannot merge. Ranges (${this.toRangeString()},${otherRange.toRangeString()}) are not consecutive and/or of same size`);
+        }
+        return this.newInstance(this.getFirst(), this.getPrefix().merge());
+    }
+    /**
+     * Returns a lazily evaluated representation of the IP range that produces IP numbers by either:
+     *
+     * - iterating over using the for of syntax
+     * - converting to array using spread syntax
+     * - or assigning values to variables using deconstruction
+     *
+     * @param count the number of IP numbers to lazily evaluate.
+     * If none is given, the whole IP range is lazily returned.
+     */
+    *takeStream(count) {
+        return this.toRangeSet().take(count);
+    }
+    *[Symbol.iterator]() {
+        yield* this.toRangeSet();
+    }
+}
+IPRange.AbstractIPRange = AbstractIPRange;
+/**
+ * Represents a continuous segment of IPv4 numbers following the
+ * classless inter-domain routing scheme for allocating IP addresses.
+ *
+ * @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
+     *
+     * @param {string} rangeIncidrNotation the range of the IPv4 number in CIDR notation
+     * @returns {IPv4CidrRange} the IPv4CidrRange
+     */
+    static fromCidr(rangeIncidrNotation) {
+        let [isValid, errorMessages] = Validator_1.Validator.isValidIPv4CidrNotation(rangeIncidrNotation);
+        if (!isValid) {
+            let messages = errorMessages.filter(message => { return message !== ''; });
+            throw new Error(messages.join(' and '));
+        }
+        let cidrComponents = rangeIncidrNotation.split("/");
+        let ipString = cidrComponents[0];
+        let prefix = BigInt(parseInt(cidrComponents[1]));
+        return new IPv4CidrRange(IPNumber_1.IPv4.fromDecimalDottedString(ipString), Prefix_1$1.IPv4Prefix.fromNumber(prefix));
+    }
+    /**
+     * Gets the size of IPv4 numbers contained within the IPv4 range
+     *
+     * @returns {bigint} the amount of IPv4 numbers in the range
+     */
+    getSize() {
+        return this.cidrPrefix.toRangeSize();
+    }
+    /**
+     * Method that returns the IPv4 range in CIDR (Classless Inter-Domain Routing) notation.
+     *
+     * See {@link https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation} for more information
+     * on the Classless Inter-Domain Routing notation
+     *
+     * @returns {string} the IPv4 range in CIDR (Classless Inter-Domain Routing) notation
+     */
+    toCidrString() {
+        let first = this.ipv4.toString();
+        return `${first.toString()}/${this.cidrPrefix.toString()}`;
+    }
+    /**
+     * Method that returns the IPv4 range in string notation where the first IPv4 number and last IPv4 number are
+     * separated by an hyphen. eg. 192.198.0.0-192.198.0.255
+     *
+     * @returns {string} the range in [first IPv4 number] - [last IPv4 number] format
+     */
+    toRangeString() {
+        return super.toRangeString();
+    }
+    /**
+     * Method that returns the first IPv4 number in the IPv4 range
+     *
+     * @returns {IPv4} the first IPv4 number in the IPv4 range
+     */
+    getFirst() {
+        return IPNumber_1.IPv4.fromNumber(this.ipv4.getValue() & (this.cidrPrefix.toMask().getValue()));
+    }
+    /**
+     * Method that returns the last IPv4 number in the IPv4 range
+     *
+     * @returns {IPv4} the last IPv4 number in the IPv4 range
+     */
+    getLast() {
+        return last(this, this.ipv4);
+    }
+    newInstance(num, prefix) {
+        return new IPv4CidrRange(num, prefix);
+    }
+    getPrefix() {
+        return this.cidrPrefix;
+    }
+    /**
+     * Indicates whether the given IPv4 range is an adjacent range.
+     *
+     * An adjacent range being one where the end of the given range, when incremented by one marks the start of the
+     * other range. Or where the start of the given range, when decreased by one, marks the end of the other range
+     *
+     * @param {IPv4CidrRange} otherRange the other IPv4 range to compare with
+     * @returns {boolean} true if the two IPv4 ranges are consecutive, false otherwise
+     */
+    isConsecutive(otherRange) {
+        return super.isConsecutive(otherRange);
+    }
+    /**
+     * Indicates if the given IPv4 range is a subset.
+     *
+     * By a subset range, it means all the values of the given range are contained by this IPv4 range
+     *
+     * @param {IPv4CidrRange} otherRange the other IPv4 range
+     * @returns {boolean} true if the other Ipv4 range is a subset. False otherwise.
+     */
+    contains(otherRange) {
+        return super.contains(otherRange);
+    }
+    /**
+     * Indicate if the given range is a container range.
+     *
+     * By container range, it means all the IP number in this current range can be found within the given range.
+     *
+     * @param {IPv4CidrRange} otherRange he other IPv4 range
+     * @returns {boolean} true if the other Ipv4 range is a container range. False otherwise.
+     */
+    inside(otherRange) {
+        return super.inside(otherRange);
+    }
+    /**
+     * Checks if two IPv4 ranges overlap
+     * @param {IPv4CidrRange} otherRange the other IPv4 range
+     * @returns {boolean} true if the ranges overlap, false otherwise
+     */
+    isOverlapping(otherRange) {
+        return super.isOverlapping(otherRange);
+    }
+    /**
+     * Method that takes IPv4 number from within an IPv4 range, starting from the first IPv4 number
+     *
+     * @param {bigint} count the amount of IPv4 number to take from the IPv4 range
+     * @returns {Array<IPv4>} an array of IPv4 number, taken from the IPv4 range
+     */
+    take(count) {
+        let ipv4s = [this.getFirst()];
+        let iteratingIPv4 = this.getFirst();
+        if (count > (this.getSize())) {
+            let errMessage = Validator_1.Validator.takeOutOfRangeSizeMessage
+                .replace("$count", count.toString())
+                .replace("$size", this.getSize().toString());
+            throw new Error(errMessage);
+        }
+        for (let counter = 0; counter < count - 1n; counter++) {
+            ipv4s.push(iteratingIPv4.nextIPNumber());
+            iteratingIPv4 = iteratingIPv4.nextIPNumber();
+        }
+        return ipv4s;
+    }
+    /**
+     * Method that splits an IPv4 range into two halves
+     *
+     * @returns {Array<IPv4CidrRange>} An array of two {@link IPv4CidrRange}
+     */
+    split() {
+        let prefixToSplit = this.cidrPrefix.getValue();
+        if (prefixToSplit === 32n) {
+            throw new Error("Cannot split an IP range with a single IP number");
+        }
+        let splitCidr = Prefix_1$1.IPv4Prefix.fromNumber(prefixToSplit + 1n);
+        let firstIPOfFirstRange = this.getFirst();
+        let firstRange = new IPv4CidrRange(firstIPOfFirstRange, splitCidr);
+        let firstIPOfSecondRange = firstRange.getLast().nextIPNumber();
+        let secondRange = new IPv4CidrRange(firstIPOfSecondRange, splitCidr);
+        return [firstRange, secondRange];
+    }
+    /**
+     * Method that split prefix into ranges of the given prefix,
+     * throws an exception if the size of the given prefix is larger than target prefix
+     *
+     * @param prefix the prefix to use to split
+     * @returns {Array<IPv4CidrRange>} An array of two {@link IPv4CidrRange}
+     */
+    splitInto(prefix) {
+        let splitCount = prefix.getValue() - this.cidrPrefix.getValue();
+        if (splitCount < 0) {
+            throw new Error("Prefix to split into is larger than source prefix");
+        }
+        else if (splitCount === 0n) {
+            return [new IPv4CidrRange(this.getFirst(), prefix)];
+        }
+        else if (splitCount === 1n) {
+            return this.split();
+        }
+        else {
+            let results = this.split();
+            while (splitCount > 1) {
+                results = results.flatMap(result => result.split());
+                splitCount = splitCount - 1n;
+            }
+            return results;
+        }
+    }
+    /**
+     * Returns true if there is an adjacent IPv4 cidr range of exactly the same size next to this range
+     */
+    hasNextRange() {
+        return super.hasNextRange();
+    }
+    /**
+     * Returns true if there is an adjacent IPv4 cidr range of exactly the same size previous to this range
+     */
+    hasPreviousRange() {
+        return super.hasPreviousRange();
+    }
+    /**
+     * Return the next IPv6 cidr range, or undefined if no next range
+     */
+    nextRange() {
+        if (this.hasNextRange()) {
+            let sizeOfCurrentRange = this.getSize();
+            let startOfNextRange = this.getFirst().getValue() + (sizeOfCurrentRange);
+            return new IPv4CidrRange(new IPNumber_1.IPv4(startOfNextRange), this.cidrPrefix);
+        }
+        return;
+    }
+    /**
+     * Return the previous IPv6 cidr range, or undefined if no next range
+     */
+    previousRange() {
+        if (this.hasPreviousRange()) {
+            let sizeOfCurrentRange = this.getSize();
+            let startOfPreviousRange = this.getFirst().getValue() - (sizeOfCurrentRange);
+            return new IPv4CidrRange(new IPNumber_1.IPv4(startOfPreviousRange), this.cidrPrefix);
+        }
+        return;
+    }
+}
+IPRange.IPv4CidrRange = IPv4CidrRange;
+/**
+ * Represents a continuous segment of IPv6 number following the
+ * classless inter-domain routing scheme for allocating IP addresses.
+ *
+ * @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
+     *
+     * @param {string} rangeInCidrNotation the range of the IPv6 number in CIDR notation
+     * @returns {IPv6CidrRange} the IPV6Range
+     */
+    static fromCidr(rangeInCidrNotation) {
+        let [isValid, message] = Validator_1.Validator.isValidIPv6CidrNotation(rangeInCidrNotation);
+        if (!isValid) {
+            throw new Error(message.filter(msg => { return msg !== ''; }).toString());
+        }
+        let cidrComponents = rangeInCidrNotation.split("/");
+        let ipString = cidrComponents[0];
+        let prefix = BigInt(parseInt(cidrComponents[1]));
+        return new IPv6CidrRange(IPNumber_1.IPv6.fromHexadecatet(ipString), Prefix_1$1.IPv6Prefix.fromNumber(prefix));
+    }
+    ;
+    /**
+     * Gets the size of IPv6 numbers contained within the IPv6 range
+     *
+     * @returns {bigint} the amount of IPv6 numbers in the range
+     */
+    getSize() {
+        return this.cidrPrefix.toRangeSize();
+    }
+    /**
+     * Method that returns the IPv6 range in CIDR (Classless Inter-Domain Routing) notation.
+     *
+     * See {@link https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation} for more information
+     * on the Classless Inter-Domain Routing notation
+     *
+     * @returns {string} the IPv6 range in CIDR (Classless Inter-Domain Routing) notation
+     */
+    toCidrString() {
+        let first = this.ipv6.toString();
+        return `${first.toString()}/${this.cidrPrefix.toString()}`;
+    }
+    /**
+     * Method that returns the IPv6 range in string notation where the first IPv6 number and last IPv6 number are
+     * separated by an hyphen. eg. "2001:db8:0:0:0:0:0:0-2001:db8:0:ffff:ffff:ffff:ffff:ffff"
+     *
+     * @returns {string} the range in [first IPv6 number] - [last IPv6 number] format
+     */
+    toRangeString() {
+        return super.toRangeString();
+    }
+    /**
+     * Method that returns the first IPv6 number in the IPv6 range
+     *
+     * @returns {IPv6} the first IPv6 number in the IPv6 range
+     */
+    getFirst() {
+        return IPNumber_1.IPv6.fromBigInt(this.ipv6.getValue() & (this.cidrPrefix.toMask().getValue()));
+    }
+    /**
+     * Method that returns the last IPv6 number in the IPv6 range
+     *
+     * @returns {IPv6} the last IPv6 number in the IPv6 range
+     */
+    getLast() {
+        return last(this, this.ipv6);
+    }
+    newInstance(num, prefix) {
+        return new IPv6CidrRange(num, prefix);
+    }
+    getPrefix() {
+        return this.cidrPrefix;
+    }
+    /**
+     * Indicates whether the given IPv6 range is an adjacent range.
+     *
+     * An adjacent range being one where the end of the given range, when incremented by one marks the start of the
+     * other range. Or where the start of the given range, when decreased by one, marks the end of the other range
+     *
+     * @param {IPv6CidrRange} otherRange the other IPv6 range to compare with
+     * @returns {boolean} true if the two IPv6 ranges are consecutive, false otherwise
+     */
+    isConsecutive(otherRange) {
+        return super.isConsecutive(otherRange);
+    }
+    /**
+     * Indicates if the given IPv6 range is a subset.
+     *
+     * By a subset range, it means all the values of the given range are contained by this IPv6 range
+     *
+     * @param {IPv6CidrRange} otherRange the other IPv6 range
+     * @returns {boolean} true if the other Ipv6 range is a subset. False otherwise.
+     */
+    contains(otherRange) {
+        return super.contains(otherRange);
+    }
+    /**
+     * Indicate if the given range is a container range.
+     *
+     * By container range, it means all the IP number in this current range can be found within the given range.
+     *
+     * @param {IPv6CidrRange} otherRange he other IPv6 range
+     * @returns {boolean} true if the other Ipv6 range is a container range. False otherwise.
+     */
+    inside(otherRange) {
+        return super.inside(otherRange);
+    }
+    /**
+     * Checks if two IPv6 ranges overlap
+     * @param {IPv6CidrRange} otherRange the other IPv6 range
+     * @returns {boolean} true if the ranges overlap, false otherwise
+     */
+    isOverlapping(otherRange) {
+        return super.isOverlapping(otherRange);
+    }
+    /**
+     * Method that takes IPv6 number from within an IPv6 range, starting from the first IPv6 number
+     *
+     * @param {bigint} count the amount of IPv6 number to take from the IPv6 range
+     * @returns {Array<IPv6>} an array of IPv6 number, taken from the IPv6 range
+     */
+    take(count) {
+        let iPv6s = [this.getFirst()];
+        let iteratingIPv6 = this.getFirst();
+        if (count > (this.getSize())) {
+            throw new Error(`${count.toString()} is greater than ${this.getSize().toString()}, the size of the range`);
+        }
+        for (var counter = 0; counter < count - 1n; counter++) {
+            iPv6s.push(iteratingIPv6.nextIPNumber());
+            iteratingIPv6 = iteratingIPv6.nextIPNumber();
+        }
+        return iPv6s;
+    }
+    /**
+     * Method that splits an IPv6 cidr range into two halves
+     *
+     * @returns {Array<IPv6CidrRange>} An array of two {@link IPv6CidrRange}
+     */
+    split() {
+        let prefixToSplit = this.cidrPrefix.getValue();
+        if (prefixToSplit === 128n) {
+            throw new Error("Cannot split an IP range with a single IP number");
+        }
+        let splitCidr = Prefix_1$1.IPv6Prefix.fromNumber(prefixToSplit + 1n);
+        let firstIPOfFirstRange = this.getFirst();
+        let firstRange = new IPv6CidrRange(firstIPOfFirstRange, splitCidr);
+        let firstIPOfSecondRange = firstRange.getLast().nextIPNumber();
+        let secondRange = new IPv6CidrRange(firstIPOfSecondRange, splitCidr);
+        return [firstRange, secondRange];
+    }
+    /**
+     * Method that split prefix into ranges of the given prefix,
+     * throws an exception if the size of the given prefix is larger than target prefix
+     *
+     * @param prefix the prefix to use to split
+     * @returns {Array<IPv6CidrRange>} An array of two {@link IPv6CidrRange}
+     */
+    splitInto(prefix) {
+        let splitCount = prefix.getValue() - this.cidrPrefix.getValue();
+        if (splitCount < 0) {
+            throw new Error("Prefix to split into is larger than source prefix");
+        }
+        else if (splitCount === 0n) {
+            return [new IPv6CidrRange(this.getFirst(), prefix)];
+        }
+        else if (splitCount === 1n) {
+            return this.split();
+        }
+        else {
+            let results = this.split();
+            while (splitCount > 1) {
+                results = results.flatMap(result => result.split());
+                splitCount = splitCount - 1n;
+            }
+            return results;
+        }
+    }
+    /**
+     * Returns true if there is an adjacent IPv6 cidr range of exactly the same size next to this range
+     */
+    hasNextRange() {
+        return super.hasNextRange();
+    }
+    /**
+     * Returns true if there is an adjacent IPv6 cidr range of exactly the same size previous to this range
+     */
+    hasPreviousRange() {
+        return super.hasPreviousRange();
+    }
+    /**
+     * Return the next IPv6 cidr range, or undefined if no next range
+     */
+    nextRange() {
+        if (this.hasNextRange()) {
+            let sizeOfCurrentRange = this.getSize();
+            let startOfNextRange = this.getFirst().getValue() + (sizeOfCurrentRange);
+            return new IPv6CidrRange(new IPNumber_1.IPv6(startOfNextRange), this.cidrPrefix);
+        }
+        return;
+    }
+    /**
+     * Return the previous IPv6 cidr range, or undefined if no next range
+     */
+    previousRange() {
+        if (this.hasPreviousRange()) {
+            let sizeOfCurrentRange = this.getSize();
+            let startOfPreviousRange = this.getFirst().getValue() - sizeOfCurrentRange;
+            return new IPv6CidrRange(new IPNumber_1.IPv6(startOfPreviousRange), this.cidrPrefix);
+        }
+        return;
+    }
+}
+IPRange.IPv6CidrRange = IPv6CidrRange;
+// utility functions shared by both IPv6CidrRange and IPv4CidrRange
+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);
+    if (isIPv4CidrRange(range)) {
+        return IPNumber_1.IPv4.fromNumber((ip.getValue()) | (BinaryUtils_1.parseBinaryStringToBigInt(invertedMask)));
+    }
+    else {
+        return IPNumber_1.IPv6.fromBigInt((ip.getValue()) | (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;
+const IPRange_1 = IPRange;
+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.
+     */
+    static fromIP(ipNumbers) {
+        let ranges = ipNumbers.map((ip) => {
+            return IPRange_1.RangedSet.fromSingleIP(ip);
+        });
+        return new Pool(ranges);
+    }
+    /**
+     * Convenient method for creating an instance from arrays of {@link RangedSet}.
+     *
+     * @param ipRanges the arrays of {@link RangedSet}'s that will make up the pool.
+     */
+    // TODO: TSE: This makes it possible to create an instance containing both Range set of IPv4 and IPv6
+    static fromRangeSet(ipRanges) {
+        return new Pool(ipRanges);
+    }
+    /**
+     * Convenient method for creating an instance from arrays of {@link IPv4CidrRange} or {@link IPv6CidrRange}.
+     *
+     * @param cidrRanges the arrays of {@link IPv4CidrRange} or {@link IPv6CidrRange} that will make up the pool.
+     */
+    static fromCidrRanges(cidrRanges) {
+        let cidr = cidrRanges;
+        let rangeSet = cidr.map((range) => {
+            return range.toRangeSet();
+        });
+        return new Pool(rangeSet);
+    }
+    /**
+     * Returns an array of {@link RangedSet}'s that is contained within the pool
+     */
+    getRanges() {
+        return this.backingSet.asArray();
+    }
+    /**
+     * Returns an new {@link Pool} with all the IP ranges aggregated
+     */
+    aggregate() {
+        let sortedRanges = this.backingSet.asArray();
+        let mergedRanges = sortedRanges.reduce((accumulator, currentRange, currentIndex, array) => {
+            if (accumulator.length == 0) {
+                accumulator.push(currentRange);
+                return accumulator;
+            }
+            else {
+                let previous = accumulator.pop();
+                let previousCidrRange = previous.toCidrRange();
+                let currentCidrRange = currentRange.toCidrRange();
+                if (previousCidrRange.isCidrMergeable(currentCidrRange)) {
+                    let merged = previousCidrRange.merge(currentCidrRange);
+                    accumulator.push(merged.toRangeSet());
+                    return accumulator;
+                }
+                else {
+                    if (!previous.contains(currentRange)) {
+                        accumulator.push(previous);
+                        accumulator.push(currentRange);
+                    }
+                    else {
+                        accumulator.push(previous);
+                    }
+                    return accumulator;
+                }
+            }
+        }, []);
+        let aggregatedPool = Pool.fromRangeSet(mergedRanges);
+        if (aggregatedPool.getRanges().length !== this.getRanges().length) {
+            return aggregatedPool.aggregate();
+        }
+        else {
+            return aggregatedPool;
+        }
+    }
+    /**
+     * Gets a single range of size of the given prefix from pool.
+     * Only returns a range if there is a single range in the pool of same size or greater than given prefix.
+     *
+     * throws exception if the requested range cannot be got from the pool.
+     *
+     * @param prefix prefix range to retrieve
+     * TODO TSE
+     */
+    getCidrRange(prefix) {
+        if (prefix.toRangeSize() > (this.getSize())) {
+            throw new Error(`Not enough IP number in the pool for requested prefix: ${prefix}`);
+        }
+        let selectedCidrRange;
+        let error;
+        loop: for (let range of this.getRanges()) {
+            for (let offset = 0n; offset + (prefix.toRangeSize()) <= (range.getSize()); offset = offset + 1n)
+                try {
+                    let selectedRange = range.takeSubRange(offset, prefix.toRangeSize());
+                    selectedCidrRange = selectedRange.toCidrRange();
+                    let remaining = range.difference(selectedRange);
+                    this.removeExact(range);
+                    this.add(remaining);
+                    break loop;
+                }
+                catch (e) {
+                    if (e instanceof RangeError) {
+                        continue loop;
+                    }
+                    error = e;
+                }
+        }
+        if (selectedCidrRange) {
+            return selectedCidrRange;
+        }
+        else {
+            throw (error === undefined ? new Error(`No range big enough in the pool for requested prefix: ${prefix}`) : error);
+        }
+    }
+    /**
+     * Gets a single or multiple ranges that fulfils the given prefix from the pool.
+     *
+     * throws exception if the requested range cannot be got from the pool.
+     *
+     * @param reqprefix prefix range to retrieve
+     */
+    getCidrRanges(reqprefix) {
+        if (reqprefix.toRangeSize() > (this.getSize())) {
+            throw new Error("Prefix greater than pool");
+        }
+        let go = (reqprefix, prefix, accummulated) => {
+            try {
+                let singleCidrRange = this.getCidrRange(prefix);
+                accummulated.push(singleCidrRange);
+                let currentSize = accummulated.reduce((previous, current) => {
+                    return previous + (current.getSize());
+                }, 0n);
+                if (reqprefix.toRangeSize() === (currentSize)) {
+                    return accummulated;
+                }
+                else {
+                    return go(reqprefix, prefix, accummulated);
+                }
+            }
+            catch (e) {
+                let lowerPrefix = Prefix_1.isIPv4Prefix(prefix) ?
+                    Prefix_1.IPv4Prefix.fromNumber(prefix.getValue() + 1n) : Prefix_1.IPv6Prefix.fromNumber(prefix.getValue() + 1n);
+                return go(reqprefix, lowerPrefix, accummulated);
+            }
+        };
+        return go(reqprefix, reqprefix, []);
+    }
+    /**
+     * Returns the size of IP numbers in the pool
+     */
+    getSize() {
+        return this
+            .aggregate()
+            .getRanges()
+            .reduce((previous, current) => {
+            return previous + current.getSize();
+        }, 0n);
+    }
+    /**
+     * Empties the pool and fill it with given ranges
+     *
+     * @param ipRanges the range to fill the pool with after emptying
+     */
+    resetWith(ipRanges) {
+        this.backingSet.clear();
+        this.backingSet = this.backingSet.add(ipRanges);
+    }
+    /**
+     * Removes the given range from the pool. It only removes if the exact range exist in the pool.
+     * It is a Noop and returns false, if the given range does not exist in the pool. Returns true otherwise
+     *
+     * @param rangeToRemove range to remove from ppol
+     */
+    removeExact(rangeToRemove) {
+        let updatedSet = this.backingSet.removeExact(rangeToRemove);
+        let isUpdated = !this.backingSet.isEquals(updatedSet);
+        this.backingSet = updatedSet;
+        return isUpdated;
+    }
+    /**
+     * Removes the given range from the pool. If the given range overlaps, then it removes the overlapping portion.
+     * It is a Noop and returns false, if the given range does not exist in the pool. Returns true otherwise
+     *
+     * @param rangeToRemove range to remove from ppol
+     */
+    removeOverlapping(rangeToRemove) {
+        let updatedSet = this.backingSet.removeOverlapping(rangeToRemove);
+        let isUpdated = !this.backingSet.isEquals(updatedSet);
+        this.backingSet = updatedSet;
+        return isUpdated;
+    }
+    /**
+     * Adds the given range to the pool.
+     *
+     * @param range to add to pool.
+     */
+    add(range) {
+        this.backingSet = this.backingSet.add(range);
+    }
+    /**
+     * Removes all ranges from pool
+     */
+    clear() {
+        this.backingSet.clear();
+    }
+}
+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)) {
+                return -1;
+            }
+            if (a.isGreaterThan(b)) {
+                return 1;
+            }
+            return 0;
+        });
+        return array;
+    }
+    asArray() {
+        return this.backingArray;
+    }
+    isEquals(other) {
+        if (this.backingArray.length !== other.asArray().length) {
+            return false;
+        }
+        return this.backingArray.every((value, index) => {
+            return value.getSize() === (other.asArray()[index].getSize());
+        });
+    }
+    add(item) {
+        let array = this.backingArray;
+        if ("push" in item) {
+            array = array.concat(item);
+        }
+        else {
+            array.push(item);
+        }
+        return new SortedSet(this.sortArray(array));
+    }
+    removeExact(items) {
+        let filtered = this.backingArray
+            .filter(currentItem => {
+            if ("push" in items) {
+                return items.find(item => item.isEquals(currentItem)) !== undefined;
+            }
+            else {
+                return !items.isEquals(currentItem);
+            }
+        });
+        return new SortedSet(this.sortArray(filtered));
+    }
+    removeOverlapping(items) {
+        let filtered = this.backingArray
+            .flatMap(backingItem => {
+            if ("push" in items) {
+                return items.flatMap(item => {
+                    if (backingItem.contains(item)) {
+                        return backingItem.difference(item);
+                    }
+                    else if (backingItem.inside(item)) {
+                        return new Array();
+                    }
+                    else if (backingItem.isOverlapping(item)) {
+                        return [backingItem.subtract(item)];
+                    }
+                    else {
+                        return [item];
+                    }
+                });
+            }
+            else {
+                try {
+                    return backingItem.difference(items);
+                }
+                catch (e) {
+                    return backingItem;
+                }
+            }
+        });
+        return new SortedSet(this.sortArray(filtered));
+    }
+    clear() {
+        this.backingArray = [];
+    }
+}
+
+(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]; } });
+	}) : (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);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	 * Exposes all the library's modules making them available from the "ip-num" module.
+	 * Making it possible to get access to all any of the modules by doing require("ip-num")
+	 *
+	 * @example
+	 * let ipNum = require("ip-num")
+	 * ipNum.IPv4CidrRange // gets access to IPv4CidrRange
+	 * ipNum.Asn // gets access to Asn
+	 */
+	__exportStar(BinaryUtils, exports);
+	__exportStar(Hexadecatet$1, exports);
+	__exportStar(requireHexadecimalUtils(), exports);
+	__exportStar(IPNumber, exports);
+	__exportStar(IPNumType, exports);
+	__exportStar(IPPool, exports);
+	__exportStar(IPRange, exports);
+	__exportStar(requireIPv6Utils(), exports);
+	__exportStar(Octet$1, exports);
+	__exportStar(Prefix, exports);
+	__exportStar(requireValidator(), exports);
+	
+} (ipNum));
+
 var toLabelAndValue = function toLabelAndValue(value) {
   return {
     label: humanizeIpAddressFormat(value),
@@ -35,10 +3121,10 @@ var toLabelAndValue = function toLabelAndValue(value) {
   };
 };
 var isValidIPv4String = function isValidIPv4String(ip) {
-  return isNotNil(ip) && Validator.isValidIPv4String(ip)[0];
+  return isNotNil(ip) && ipNum.Validator.isValidIPv4String(ip)[0];
 };
 var isValidIPv6String = function isValidIPv6String(ip) {
-  return isNotNil(ip) && Validator.isValidIPv6String(ip)[0];
+  return isNotNil(ip) && ipNum.Validator.isValidIPv6String(ip)[0];
 };
 var isValidIpString = function isValidIpString(ip) {
   return isValidIPv4String(ip) || isValidIPv6String(ip);
@@ -47,13 +3133,13 @@ var areIpAddressesInSameFormat = function areIpAddressesInSameFormat(ipStart, ip
   return isValidIPv4String(ipStart) && isValidIPv4String(ipEnd) || isValidIPv6String(ipStart) && isValidIPv6String(ipEnd);
 };
 var isValidIPv4Range = function isValidIPv4Range(ipStart, ipEnd) {
-  var ipStartAddr = IPv4.fromDecimalDottedString(ipStart);
-  var ipEndAddr = IPv4.fromDecimalDottedString(ipEnd);
+  var ipStartAddr = ipNum.IPv4.fromDecimalDottedString(ipStart);
+  var ipEndAddr = ipNum.IPv4.fromDecimalDottedString(ipEnd);
   return ipStartAddr.isLessThanOrEquals(ipEndAddr);
 };
 var isValidIPv6Range = function isValidIPv6Range(ipStart, ipEnd) {
-  var ipStartAddr = IPv6.fromString(ipStart);
-  var ipEndAddr = IPv6.fromString(ipEnd);
+  var ipStartAddr = ipNum.IPv6.fromString(ipStart);
+  var ipEndAddr = ipNum.IPv6.fromString(ipEnd);
   return ipStartAddr.isLessThanOrEquals(ipEndAddr);
 };
 var isValidIPRange = function isValidIPRange(ipStart, ipEnd) {