"use strict";
|
/* eslint-disable no-param-reassign */
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
if (k2 === undefined) k2 = k;
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
}
|
Object.defineProperty(o, k2, desc);
|
}) : (function(o, m, k, k2) {
|
if (k2 === undefined) k2 = k;
|
o[k2] = m[k];
|
}));
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
}) : function(o, v) {
|
o["default"] = v;
|
});
|
var __importStar = (this && this.__importStar) || function (mod) {
|
if (mod && mod.__esModule) return mod;
|
var result = {};
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
__setModuleDefault(result, mod);
|
return result;
|
};
|
Object.defineProperty(exports, "__esModule", { value: true });
|
exports.Address4 = void 0;
|
const common = __importStar(require("./common"));
|
const constants = __importStar(require("./v4/constants"));
|
const address_error_1 = require("./address-error");
|
/**
|
* Represents an IPv4 address
|
* @class Address4
|
* @param {string} address - An IPv4 address string
|
*/
|
class Address4 {
|
constructor(address) {
|
this.groups = constants.GROUPS;
|
this.parsedAddress = [];
|
this.parsedSubnet = '';
|
this.subnet = '/32';
|
this.subnetMask = 32;
|
this.v4 = true;
|
/**
|
* Returns true if the address is correct, false otherwise
|
* @memberof Address4
|
* @instance
|
* @returns {Boolean}
|
*/
|
this.isCorrect = common.isCorrect(constants.BITS);
|
/**
|
* Returns true if the given address is in the subnet of the current address
|
* @memberof Address4
|
* @instance
|
* @returns {boolean}
|
*/
|
this.isInSubnet = common.isInSubnet;
|
this.address = address;
|
const subnet = constants.RE_SUBNET_STRING.exec(address);
|
if (subnet) {
|
this.parsedSubnet = subnet[0].replace('/', '');
|
this.subnetMask = parseInt(this.parsedSubnet, 10);
|
this.subnet = `/${this.subnetMask}`;
|
if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {
|
throw new address_error_1.AddressError('Invalid subnet mask.');
|
}
|
address = address.replace(constants.RE_SUBNET_STRING, '');
|
}
|
this.addressMinusSuffix = address;
|
this.parsedAddress = this.parse(address);
|
}
|
static isValid(address) {
|
try {
|
// eslint-disable-next-line no-new
|
new Address4(address);
|
return true;
|
}
|
catch (e) {
|
return false;
|
}
|
}
|
/*
|
* Parses a v4 address
|
*/
|
parse(address) {
|
const groups = address.split('.');
|
if (!address.match(constants.RE_ADDRESS)) {
|
throw new address_error_1.AddressError('Invalid IPv4 address.');
|
}
|
return groups;
|
}
|
/**
|
* Returns the correct form of an address
|
* @memberof Address4
|
* @instance
|
* @returns {String}
|
*/
|
correctForm() {
|
return this.parsedAddress.map((part) => parseInt(part, 10)).join('.');
|
}
|
/**
|
* Converts a hex string to an IPv4 address object
|
* @memberof Address4
|
* @static
|
* @param {string} hex - a hex string to convert
|
* @returns {Address4}
|
*/
|
static fromHex(hex) {
|
const padded = hex.replace(/:/g, '').padStart(8, '0');
|
const groups = [];
|
let i;
|
for (i = 0; i < 8; i += 2) {
|
const h = padded.slice(i, i + 2);
|
groups.push(parseInt(h, 16));
|
}
|
return new Address4(groups.join('.'));
|
}
|
/**
|
* Converts an integer into a IPv4 address object
|
* @memberof Address4
|
* @static
|
* @param {integer} integer - a number to convert
|
* @returns {Address4}
|
*/
|
static fromInteger(integer) {
|
return Address4.fromHex(integer.toString(16));
|
}
|
/**
|
* Return an address from in-addr.arpa form
|
* @memberof Address4
|
* @static
|
* @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address
|
* @returns {Adress4}
|
* @example
|
* var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.)
|
* address.correctForm(); // '192.0.2.42'
|
*/
|
static fromArpa(arpaFormAddress) {
|
// remove ending ".in-addr.arpa." or just "."
|
const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, '');
|
const address = leader.split('.').reverse().join('.');
|
return new Address4(address);
|
}
|
/**
|
* Converts an IPv4 address object to a hex string
|
* @memberof Address4
|
* @instance
|
* @returns {String}
|
*/
|
toHex() {
|
return this.parsedAddress.map((part) => common.stringToPaddedHex(part)).join(':');
|
}
|
/**
|
* Converts an IPv4 address object to an array of bytes
|
* @memberof Address4
|
* @instance
|
* @returns {Array}
|
*/
|
toArray() {
|
return this.parsedAddress.map((part) => parseInt(part, 10));
|
}
|
/**
|
* Converts an IPv4 address object to an IPv6 address group
|
* @memberof Address4
|
* @instance
|
* @returns {String}
|
*/
|
toGroup6() {
|
const output = [];
|
let i;
|
for (i = 0; i < constants.GROUPS; i += 2) {
|
output.push(`${common.stringToPaddedHex(this.parsedAddress[i])}${common.stringToPaddedHex(this.parsedAddress[i + 1])}`);
|
}
|
return output.join(':');
|
}
|
/**
|
* Returns the address as a `bigint`
|
* @memberof Address4
|
* @instance
|
* @returns {bigint}
|
*/
|
bigInt() {
|
return BigInt(`0x${this.parsedAddress.map((n) => common.stringToPaddedHex(n)).join('')}`);
|
}
|
/**
|
* Helper function getting start address.
|
* @memberof Address4
|
* @instance
|
* @returns {bigint}
|
*/
|
_startAddress() {
|
return BigInt(`0b${this.mask() + '0'.repeat(constants.BITS - this.subnetMask)}`);
|
}
|
/**
|
* The first address in the range given by this address' subnet.
|
* Often referred to as the Network Address.
|
* @memberof Address4
|
* @instance
|
* @returns {Address4}
|
*/
|
startAddress() {
|
return Address4.fromBigInt(this._startAddress());
|
}
|
/**
|
* The first host address in the range given by this address's subnet ie
|
* the first address after the Network Address
|
* @memberof Address4
|
* @instance
|
* @returns {Address4}
|
*/
|
startAddressExclusive() {
|
const adjust = BigInt('1');
|
return Address4.fromBigInt(this._startAddress() + adjust);
|
}
|
/**
|
* Helper function getting end address.
|
* @memberof Address4
|
* @instance
|
* @returns {bigint}
|
*/
|
_endAddress() {
|
return BigInt(`0b${this.mask() + '1'.repeat(constants.BITS - this.subnetMask)}`);
|
}
|
/**
|
* The last address in the range given by this address' subnet
|
* Often referred to as the Broadcast
|
* @memberof Address4
|
* @instance
|
* @returns {Address4}
|
*/
|
endAddress() {
|
return Address4.fromBigInt(this._endAddress());
|
}
|
/**
|
* The last host address in the range given by this address's subnet ie
|
* the last address prior to the Broadcast Address
|
* @memberof Address4
|
* @instance
|
* @returns {Address4}
|
*/
|
endAddressExclusive() {
|
const adjust = BigInt('1');
|
return Address4.fromBigInt(this._endAddress() - adjust);
|
}
|
/**
|
* Converts a BigInt to a v4 address object
|
* @memberof Address4
|
* @static
|
* @param {bigint} bigInt - a BigInt to convert
|
* @returns {Address4}
|
*/
|
static fromBigInt(bigInt) {
|
return Address4.fromHex(bigInt.toString(16));
|
}
|
/**
|
* Convert a byte array to an Address4 object
|
* @memberof Address4
|
* @static
|
* @param {Array<number>} bytes - an array of 4 bytes (0-255)
|
* @returns {Address4}
|
*/
|
static fromByteArray(bytes) {
|
if (bytes.length !== 4) {
|
throw new address_error_1.AddressError('IPv4 addresses require exactly 4 bytes');
|
}
|
// Validate that all bytes are within valid range (0-255)
|
for (let i = 0; i < bytes.length; i++) {
|
if (!Number.isInteger(bytes[i]) || bytes[i] < 0 || bytes[i] > 255) {
|
throw new address_error_1.AddressError('All bytes must be integers between 0 and 255');
|
}
|
}
|
return this.fromUnsignedByteArray(bytes);
|
}
|
/**
|
* Convert an unsigned byte array to an Address4 object
|
* @memberof Address4
|
* @static
|
* @param {Array<number>} bytes - an array of 4 unsigned bytes (0-255)
|
* @returns {Address4}
|
*/
|
static fromUnsignedByteArray(bytes) {
|
if (bytes.length !== 4) {
|
throw new address_error_1.AddressError('IPv4 addresses require exactly 4 bytes');
|
}
|
const address = bytes.join('.');
|
return new Address4(address);
|
}
|
/**
|
* Returns the first n bits of the address, defaulting to the
|
* subnet mask
|
* @memberof Address4
|
* @instance
|
* @returns {String}
|
*/
|
mask(mask) {
|
if (mask === undefined) {
|
mask = this.subnetMask;
|
}
|
return this.getBitsBase2(0, mask);
|
}
|
/**
|
* Returns the bits in the given range as a base-2 string
|
* @memberof Address4
|
* @instance
|
* @returns {string}
|
*/
|
getBitsBase2(start, end) {
|
return this.binaryZeroPad().slice(start, end);
|
}
|
/**
|
* Return the reversed ip6.arpa form of the address
|
* @memberof Address4
|
* @param {Object} options
|
* @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix
|
* @instance
|
* @returns {String}
|
*/
|
reverseForm(options) {
|
if (!options) {
|
options = {};
|
}
|
const reversed = this.correctForm().split('.').reverse().join('.');
|
if (options.omitSuffix) {
|
return reversed;
|
}
|
return `${reversed}.in-addr.arpa.`;
|
}
|
/**
|
* Returns true if the given address is a multicast address
|
* @memberof Address4
|
* @instance
|
* @returns {boolean}
|
*/
|
isMulticast() {
|
return this.isInSubnet(new Address4('224.0.0.0/4'));
|
}
|
/**
|
* Returns a zero-padded base-2 string representation of the address
|
* @memberof Address4
|
* @instance
|
* @returns {string}
|
*/
|
binaryZeroPad() {
|
return this.bigInt().toString(2).padStart(constants.BITS, '0');
|
}
|
/**
|
* Groups an IPv4 address for inclusion at the end of an IPv6 address
|
* @returns {String}
|
*/
|
groupForV6() {
|
const segments = this.parsedAddress;
|
return this.address.replace(constants.RE_ADDRESS, `<span class="hover-group group-v4 group-6">${segments
|
.slice(0, 2)
|
.join('.')}</span>.<span class="hover-group group-v4 group-7">${segments
|
.slice(2, 4)
|
.join('.')}</span>`);
|
}
|
}
|
exports.Address4 = Address4;
|
//# sourceMappingURL=ipv4.js.map
|
