Index: node_modules/ip-address/dist/ipv6.js
===================================================================
--- node_modules/ip-address/dist/ipv6.js (revision 81bc7da776d8cda42939ef4ab350c88d13b4941f)
+++ node_modules/ip-address/dist/ipv6.js (revision 81bc7da776d8cda42939ef4ab350c88d13b4941f)
@@ -0,0 +1,1003 @@
+"use strict";
+/* eslint-disable prefer-destructuring */
+/* 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.Address6 = void 0;
+const common = __importStar(require("./common"));
+const constants4 = __importStar(require("./v4/constants"));
+const constants6 = __importStar(require("./v6/constants"));
+const helpers = __importStar(require("./v6/helpers"));
+const ipv4_1 = require("./ipv4");
+const regular_expressions_1 = require("./v6/regular-expressions");
+const address_error_1 = require("./address-error");
+const common_1 = require("./common");
+function assert(condition) {
+ if (!condition) {
+ throw new Error('Assertion failed.');
+ }
+}
+function addCommas(number) {
+ const r = /(\d+)(\d{3})/;
+ while (r.test(number)) {
+ number = number.replace(r, '$1,$2');
+ }
+ return number;
+}
+function spanLeadingZeroes4(n) {
+ n = n.replace(/^(0{1,})([1-9]+)$/, '$1$2');
+ n = n.replace(/^(0{1,})(0)$/, '$1$2');
+ return n;
+}
+/*
+ * A helper function to compact an array
+ */
+function compact(address, slice) {
+ const s1 = [];
+ const s2 = [];
+ let i;
+ for (i = 0; i < address.length; i++) {
+ if (i < slice[0]) {
+ s1.push(address[i]);
+ }
+ else if (i > slice[1]) {
+ s2.push(address[i]);
+ }
+ }
+ return s1.concat(['compact']).concat(s2);
+}
+function paddedHex(octet) {
+ return parseInt(octet, 16).toString(16).padStart(4, '0');
+}
+function unsignByte(b) {
+ // eslint-disable-next-line no-bitwise
+ return b & 0xff;
+}
+/**
+ * Represents an IPv6 address
+ * @class Address6
+ * @param {string} address - An IPv6 address string
+ * @param {number} [groups=8] - How many octets to parse
+ * @example
+ * var address = new Address6('2001::/32');
+ */
+class Address6 {
+ constructor(address, optionalGroups) {
+ this.addressMinusSuffix = '';
+ this.parsedSubnet = '';
+ this.subnet = '/128';
+ this.subnetMask = 128;
+ this.v4 = false;
+ this.zone = '';
+ // #region Attributes
+ /**
+ * Returns true if the given address is in the subnet of the current address
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ this.isInSubnet = common.isInSubnet;
+ /**
+ * Returns true if the address is correct, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ this.isCorrect = common.isCorrect(constants6.BITS);
+ if (optionalGroups === undefined) {
+ this.groups = constants6.GROUPS;
+ }
+ else {
+ this.groups = optionalGroups;
+ }
+ this.address = address;
+ const subnet = constants6.RE_SUBNET_STRING.exec(address);
+ if (subnet) {
+ this.parsedSubnet = subnet[0].replace('/', '');
+ this.subnetMask = parseInt(this.parsedSubnet, 10);
+ this.subnet = `/${this.subnetMask}`;
+ if (Number.isNaN(this.subnetMask) ||
+ this.subnetMask < 0 ||
+ this.subnetMask > constants6.BITS) {
+ throw new address_error_1.AddressError('Invalid subnet mask.');
+ }
+ address = address.replace(constants6.RE_SUBNET_STRING, '');
+ }
+ else if (/\//.test(address)) {
+ throw new address_error_1.AddressError('Invalid subnet mask.');
+ }
+ const zone = constants6.RE_ZONE_STRING.exec(address);
+ if (zone) {
+ this.zone = zone[0];
+ address = address.replace(constants6.RE_ZONE_STRING, '');
+ }
+ this.addressMinusSuffix = address;
+ this.parsedAddress = this.parse(this.addressMinusSuffix);
+ }
+ static isValid(address) {
+ try {
+ // eslint-disable-next-line no-new
+ new Address6(address);
+ return true;
+ }
+ catch (e) {
+ return false;
+ }
+ }
+ /**
+ * Convert a BigInt to a v6 address object
+ * @memberof Address6
+ * @static
+ * @param {bigint} bigInt - a BigInt to convert
+ * @returns {Address6}
+ * @example
+ * var bigInt = BigInt('1000000000000');
+ * var address = Address6.fromBigInt(bigInt);
+ * address.correctForm(); // '::e8:d4a5:1000'
+ */
+ static fromBigInt(bigInt) {
+ const hex = bigInt.toString(16).padStart(32, '0');
+ const groups = [];
+ let i;
+ for (i = 0; i < constants6.GROUPS; i++) {
+ groups.push(hex.slice(i * 4, (i + 1) * 4));
+ }
+ return new Address6(groups.join(':'));
+ }
+ /**
+ * Convert a URL (with optional port number) to an address object
+ * @memberof Address6
+ * @static
+ * @param {string} url - a URL with optional port number
+ * @example
+ * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');
+ * addressAndPort.address.correctForm(); // 'ffff::'
+ * addressAndPort.port; // 8080
+ */
+ static fromURL(url) {
+ let host;
+ let port = null;
+ let result;
+ // If we have brackets parse them and find a port
+ if (url.indexOf('[') !== -1 && url.indexOf(']:') !== -1) {
+ result = constants6.RE_URL_WITH_PORT.exec(url);
+ if (result === null) {
+ return {
+ error: 'failed to parse address with port',
+ address: null,
+ port: null,
+ };
+ }
+ host = result[1];
+ port = result[2];
+ // If there's a URL extract the address
+ }
+ else if (url.indexOf('/') !== -1) {
+ // Remove the protocol prefix
+ url = url.replace(/^[a-z0-9]+:\/\//, '');
+ // Parse the address
+ result = constants6.RE_URL.exec(url);
+ if (result === null) {
+ return {
+ error: 'failed to parse address from URL',
+ address: null,
+ port: null,
+ };
+ }
+ host = result[1];
+ // Otherwise just assign the URL to the host and let the library parse it
+ }
+ else {
+ host = url;
+ }
+ // If there's a port convert it to an integer
+ if (port) {
+ port = parseInt(port, 10);
+ // squelch out of range ports
+ if (port < 0 || port > 65536) {
+ port = null;
+ }
+ }
+ else {
+ // Standardize `undefined` to `null`
+ port = null;
+ }
+ return {
+ address: new Address6(host),
+ port,
+ };
+ }
+ /**
+ * Create an IPv6-mapped address given an IPv4 address
+ * @memberof Address6
+ * @static
+ * @param {string} address - An IPv4 address string
+ * @returns {Address6}
+ * @example
+ * var address = Address6.fromAddress4('192.168.0.1');
+ * address.correctForm(); // '::ffff:c0a8:1'
+ * address.to4in6(); // '::ffff:192.168.0.1'
+ */
+ static fromAddress4(address) {
+ const address4 = new ipv4_1.Address4(address);
+ const mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask);
+ return new Address6(`::ffff:${address4.correctForm()}/${mask6}`);
+ }
+ /**
+ * Return an address from ip6.arpa form
+ * @memberof Address6
+ * @static
+ * @param {string} arpaFormAddress - an 'ip6.arpa' form address
+ * @returns {Adress6}
+ * @example
+ * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.)
+ * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe'
+ */
+ static fromArpa(arpaFormAddress) {
+ // remove ending ".ip6.arpa." or just "."
+ let address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, '');
+ const semicolonAmount = 7;
+ // correct ip6.arpa form with ending removed will be 63 characters
+ if (address.length !== 63) {
+ throw new address_error_1.AddressError("Invalid 'ip6.arpa' form.");
+ }
+ const parts = address.split('.').reverse();
+ for (let i = semicolonAmount; i > 0; i--) {
+ const insertIndex = i * 4;
+ parts.splice(insertIndex, 0, ':');
+ }
+ address = parts.join('');
+ return new Address6(address);
+ }
+ /**
+ * Return the Microsoft UNC transcription of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String} the Microsoft UNC transcription of the address
+ */
+ microsoftTranscription() {
+ return `${this.correctForm().replace(/:/g, '-')}.ipv6-literal.net`;
+ }
+ /**
+ * Return the first n bits of the address, defaulting to the subnet mask
+ * @memberof Address6
+ * @instance
+ * @param {number} [mask=subnet] - the number of bits to mask
+ * @returns {String} the first n bits of the address as a string
+ */
+ mask(mask = this.subnetMask) {
+ return this.getBitsBase2(0, mask);
+ }
+ /**
+ * Return the number of possible subnets of a given size in the address
+ * @memberof Address6
+ * @instance
+ * @param {number} [subnetSize=128] - the subnet size
+ * @returns {String}
+ */
+ // TODO: probably useful to have a numeric version of this too
+ possibleSubnets(subnetSize = 128) {
+ const availableBits = constants6.BITS - this.subnetMask;
+ const subnetBits = Math.abs(subnetSize - constants6.BITS);
+ const subnetPowers = availableBits - subnetBits;
+ if (subnetPowers < 0) {
+ return '0';
+ }
+ return addCommas((BigInt('2') ** BigInt(subnetPowers)).toString(10));
+ }
+ /**
+ * Helper function getting start address.
+ * @memberof Address6
+ * @instance
+ * @returns {bigint}
+ */
+ _startAddress() {
+ return BigInt(`0b${this.mask() + '0'.repeat(constants6.BITS - this.subnetMask)}`);
+ }
+ /**
+ * The first address in the range given by this address' subnet
+ * Often referred to as the Network Address.
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+ startAddress() {
+ return Address6.fromBigInt(this._startAddress());
+ }
+ /**
+ * The first host address in the range given by this address's subnet ie
+ * the first address after the Network Address
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+ startAddressExclusive() {
+ const adjust = BigInt('1');
+ return Address6.fromBigInt(this._startAddress() + adjust);
+ }
+ /**
+ * Helper function getting end address.
+ * @memberof Address6
+ * @instance
+ * @returns {bigint}
+ */
+ _endAddress() {
+ return BigInt(`0b${this.mask() + '1'.repeat(constants6.BITS - this.subnetMask)}`);
+ }
+ /**
+ * The last address in the range given by this address' subnet
+ * Often referred to as the Broadcast
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+ endAddress() {
+ return Address6.fromBigInt(this._endAddress());
+ }
+ /**
+ * The last host address in the range given by this address's subnet ie
+ * the last address prior to the Broadcast Address
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+ endAddressExclusive() {
+ const adjust = BigInt('1');
+ return Address6.fromBigInt(this._endAddress() - adjust);
+ }
+ /**
+ * Return the scope of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ getScope() {
+ let scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)];
+ if (this.getType() === 'Global unicast' && scope !== 'Link local') {
+ scope = 'Global';
+ }
+ return scope || 'Unknown';
+ }
+ /**
+ * Return the type of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ getType() {
+ for (const subnet of Object.keys(constants6.TYPES)) {
+ if (this.isInSubnet(new Address6(subnet))) {
+ return constants6.TYPES[subnet];
+ }
+ }
+ return 'Global unicast';
+ }
+ /**
+ * Return the bits in the given range as a BigInt
+ * @memberof Address6
+ * @instance
+ * @returns {bigint}
+ */
+ getBits(start, end) {
+ return BigInt(`0b${this.getBitsBase2(start, end)}`);
+ }
+ /**
+ * Return the bits in the given range as a base-2 string
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ getBitsBase2(start, end) {
+ return this.binaryZeroPad().slice(start, end);
+ }
+ /**
+ * Return the bits in the given range as a base-16 string
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ getBitsBase16(start, end) {
+ const length = end - start;
+ if (length % 4 !== 0) {
+ throw new Error('Length of bits to retrieve must be divisible by four');
+ }
+ return this.getBits(start, end)
+ .toString(16)
+ .padStart(length / 4, '0');
+ }
+ /**
+ * Return the bits that are set past the subnet mask length
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ getBitsPastSubnet() {
+ return this.getBitsBase2(this.subnetMask, constants6.BITS);
+ }
+ /**
+ * Return the reversed ip6.arpa form of the address
+ * @memberof Address6
+ * @param {Object} options
+ * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix
+ * @instance
+ * @returns {String}
+ */
+ reverseForm(options) {
+ if (!options) {
+ options = {};
+ }
+ const characters = Math.floor(this.subnetMask / 4);
+ const reversed = this.canonicalForm()
+ .replace(/:/g, '')
+ .split('')
+ .slice(0, characters)
+ .reverse()
+ .join('.');
+ if (characters > 0) {
+ if (options.omitSuffix) {
+ return reversed;
+ }
+ return `${reversed}.ip6.arpa.`;
+ }
+ if (options.omitSuffix) {
+ return '';
+ }
+ return 'ip6.arpa.';
+ }
+ /**
+ * Return the correct form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ correctForm() {
+ let i;
+ let groups = [];
+ let zeroCounter = 0;
+ const zeroes = [];
+ for (i = 0; i < this.parsedAddress.length; i++) {
+ const value = parseInt(this.parsedAddress[i], 16);
+ if (value === 0) {
+ zeroCounter++;
+ }
+ if (value !== 0 && zeroCounter > 0) {
+ if (zeroCounter > 1) {
+ zeroes.push([i - zeroCounter, i - 1]);
+ }
+ zeroCounter = 0;
+ }
+ }
+ // Do we end with a string of zeroes?
+ if (zeroCounter > 1) {
+ zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]);
+ }
+ const zeroLengths = zeroes.map((n) => n[1] - n[0] + 1);
+ if (zeroes.length > 0) {
+ const index = zeroLengths.indexOf(Math.max(...zeroLengths));
+ groups = compact(this.parsedAddress, zeroes[index]);
+ }
+ else {
+ groups = this.parsedAddress;
+ }
+ for (i = 0; i < groups.length; i++) {
+ if (groups[i] !== 'compact') {
+ groups[i] = parseInt(groups[i], 16).toString(16);
+ }
+ }
+ let correct = groups.join(':');
+ correct = correct.replace(/^compact$/, '::');
+ correct = correct.replace(/(^compact)|(compact$)/, ':');
+ correct = correct.replace(/compact/, '');
+ return correct;
+ }
+ /**
+ * Return a zero-padded base-2 string representation of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ * @example
+ * var address = new Address6('2001:4860:4001:803::1011');
+ * address.binaryZeroPad();
+ * // '0010000000000001010010000110000001000000000000010000100000000011
+ * // 0000000000000000000000000000000000000000000000000001000000010001'
+ */
+ binaryZeroPad() {
+ return this.bigInt().toString(2).padStart(constants6.BITS, '0');
+ }
+ // TODO: Improve the semantics of this helper function
+ parse4in6(address) {
+ const groups = address.split(':');
+ const lastGroup = groups.slice(-1)[0];
+ const address4 = lastGroup.match(constants4.RE_ADDRESS);
+ if (address4) {
+ this.parsedAddress4 = address4[0];
+ this.address4 = new ipv4_1.Address4(this.parsedAddress4);
+ for (let i = 0; i < this.address4.groups; i++) {
+ if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) {
+ throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join('.')));
+ }
+ }
+ this.v4 = true;
+ groups[groups.length - 1] = this.address4.toGroup6();
+ address = groups.join(':');
+ }
+ return address;
+ }
+ // TODO: Make private?
+ parse(address) {
+ address = this.parse4in6(address);
+ const badCharacters = address.match(constants6.RE_BAD_CHARACTERS);
+ if (badCharacters) {
+ throw new address_error_1.AddressError(`Bad character${badCharacters.length > 1 ? 's' : ''} detected in address: ${badCharacters.join('')}`, address.replace(constants6.RE_BAD_CHARACTERS, '$1'));
+ }
+ const badAddress = address.match(constants6.RE_BAD_ADDRESS);
+ if (badAddress) {
+ throw new address_error_1.AddressError(`Address failed regex: ${badAddress.join('')}`, address.replace(constants6.RE_BAD_ADDRESS, '$1'));
+ }
+ let groups = [];
+ const halves = address.split('::');
+ if (halves.length === 2) {
+ let first = halves[0].split(':');
+ let last = halves[1].split(':');
+ if (first.length === 1 && first[0] === '') {
+ first = [];
+ }
+ if (last.length === 1 && last[0] === '') {
+ last = [];
+ }
+ const remaining = this.groups - (first.length + last.length);
+ if (!remaining) {
+ throw new address_error_1.AddressError('Error parsing groups');
+ }
+ this.elidedGroups = remaining;
+ this.elisionBegin = first.length;
+ this.elisionEnd = first.length + this.elidedGroups;
+ groups = groups.concat(first);
+ for (let i = 0; i < remaining; i++) {
+ groups.push('0');
+ }
+ groups = groups.concat(last);
+ }
+ else if (halves.length === 1) {
+ groups = address.split(':');
+ this.elidedGroups = 0;
+ }
+ else {
+ throw new address_error_1.AddressError('Too many :: groups found');
+ }
+ groups = groups.map((group) => parseInt(group, 16).toString(16));
+ if (groups.length !== this.groups) {
+ throw new address_error_1.AddressError('Incorrect number of groups found');
+ }
+ return groups;
+ }
+ /**
+ * Return the canonical form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ canonicalForm() {
+ return this.parsedAddress.map(paddedHex).join(':');
+ }
+ /**
+ * Return the decimal form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ decimal() {
+ return this.parsedAddress.map((n) => parseInt(n, 16).toString(10).padStart(5, '0')).join(':');
+ }
+ /**
+ * Return the address as a BigInt
+ * @memberof Address6
+ * @instance
+ * @returns {bigint}
+ */
+ bigInt() {
+ return BigInt(`0x${this.parsedAddress.map(paddedHex).join('')}`);
+ }
+ /**
+ * Return the last two groups of this address as an IPv4 address string
+ * @memberof Address6
+ * @instance
+ * @returns {Address4}
+ * @example
+ * var address = new Address6('2001:4860:4001::1825:bf11');
+ * address.to4().correctForm(); // '24.37.191.17'
+ */
+ to4() {
+ const binary = this.binaryZeroPad().split('');
+ return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join('')}`).toString(16));
+ }
+ /**
+ * Return the v4-in-v6 form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+ to4in6() {
+ const address4 = this.to4();
+ const address6 = new Address6(this.parsedAddress.slice(0, 6).join(':'), 6);
+ const correct = address6.correctForm();
+ let infix = '';
+ if (!/:$/.test(correct)) {
+ infix = ':';
+ }
+ return correct + infix + address4.address;
+ }
+ /**
+ * Return an object containing the Teredo properties of the address
+ * @memberof Address6
+ * @instance
+ * @returns {Object}
+ */
+ inspectTeredo() {
+ /*
+ - Bits 0 to 31 are set to the Teredo prefix (normally 2001:0000::/32).
+ - Bits 32 to 63 embed the primary IPv4 address of the Teredo server that
+ is used.
+ - Bits 64 to 79 can be used to define some flags. Currently only the
+ higher order bit is used; it is set to 1 if the Teredo client is
+ located behind a cone NAT, 0 otherwise. For Microsoft's Windows Vista
+ and Windows Server 2008 implementations, more bits are used. In those
+ implementations, the format for these 16 bits is "CRAAAAUG AAAAAAAA",
+ where "C" remains the "Cone" flag. The "R" bit is reserved for future
+ use. The "U" bit is for the Universal/Local flag (set to 0). The "G" bit
+ is Individual/Group flag (set to 0). The A bits are set to a 12-bit
+ randomly generated number chosen by the Teredo client to introduce
+ additional protection for the Teredo node against IPv6-based scanning
+ attacks.
+ - Bits 80 to 95 contains the obfuscated UDP port number. This is the
+ port number that is mapped by the NAT to the Teredo client with all
+ bits inverted.
+ - Bits 96 to 127 contains the obfuscated IPv4 address. This is the
+ public IPv4 address of the NAT with all bits inverted.
+ */
+ const prefix = this.getBitsBase16(0, 32);
+ const bitsForUdpPort = this.getBits(80, 96);
+ // eslint-disable-next-line no-bitwise
+ const udpPort = (bitsForUdpPort ^ BigInt('0xffff')).toString();
+ const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64));
+ const bitsForClient4 = this.getBits(96, 128);
+ // eslint-disable-next-line no-bitwise
+ const client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt('0xffffffff')).toString(16));
+ const flagsBase2 = this.getBitsBase2(64, 80);
+ const coneNat = (0, common_1.testBit)(flagsBase2, 15);
+ const reserved = (0, common_1.testBit)(flagsBase2, 14);
+ const groupIndividual = (0, common_1.testBit)(flagsBase2, 8);
+ const universalLocal = (0, common_1.testBit)(flagsBase2, 9);
+ const nonce = BigInt(`0b${flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16)}`).toString(10);
+ return {
+ prefix: `${prefix.slice(0, 4)}:${prefix.slice(4, 8)}`,
+ server4: server4.address,
+ client4: client4.address,
+ flags: flagsBase2,
+ coneNat,
+ microsoft: {
+ reserved,
+ universalLocal,
+ groupIndividual,
+ nonce,
+ },
+ udpPort,
+ };
+ }
+ /**
+ * Return an object containing the 6to4 properties of the address
+ * @memberof Address6
+ * @instance
+ * @returns {Object}
+ */
+ inspect6to4() {
+ /*
+ - Bits 0 to 15 are set to the 6to4 prefix (2002::/16).
+ - Bits 16 to 48 embed the IPv4 address of the 6to4 gateway that is used.
+ */
+ const prefix = this.getBitsBase16(0, 16);
+ const gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48));
+ return {
+ prefix: prefix.slice(0, 4),
+ gateway: gateway.address,
+ };
+ }
+ /**
+ * Return a v6 6to4 address from a v6 v4inv6 address
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+ to6to4() {
+ if (!this.is4()) {
+ return null;
+ }
+ const addr6to4 = [
+ '2002',
+ this.getBitsBase16(96, 112),
+ this.getBitsBase16(112, 128),
+ '',
+ '/16',
+ ].join(':');
+ return new Address6(addr6to4);
+ }
+ /**
+ * Return a byte array
+ * @memberof Address6
+ * @instance
+ * @returns {Array}
+ */
+ toByteArray() {
+ const valueWithoutPadding = this.bigInt().toString(16);
+ const leadingPad = '0'.repeat(valueWithoutPadding.length % 2);
+ const value = `${leadingPad}${valueWithoutPadding}`;
+ const bytes = [];
+ for (let i = 0, length = value.length; i < length; i += 2) {
+ bytes.push(parseInt(value.substring(i, i + 2), 16));
+ }
+ return bytes;
+ }
+ /**
+ * Return an unsigned byte array
+ * @memberof Address6
+ * @instance
+ * @returns {Array}
+ */
+ toUnsignedByteArray() {
+ return this.toByteArray().map(unsignByte);
+ }
+ /**
+ * Convert a byte array to an Address6 object
+ * @memberof Address6
+ * @static
+ * @returns {Address6}
+ */
+ static fromByteArray(bytes) {
+ return this.fromUnsignedByteArray(bytes.map(unsignByte));
+ }
+ /**
+ * Convert an unsigned byte array to an Address6 object
+ * @memberof Address6
+ * @static
+ * @returns {Address6}
+ */
+ static fromUnsignedByteArray(bytes) {
+ const BYTE_MAX = BigInt('256');
+ let result = BigInt('0');
+ let multiplier = BigInt('1');
+ for (let i = bytes.length - 1; i >= 0; i--) {
+ result += multiplier * BigInt(bytes[i].toString(10));
+ multiplier *= BYTE_MAX;
+ }
+ return Address6.fromBigInt(result);
+ }
+ /**
+ * Returns true if the address is in the canonical form, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ isCanonical() {
+ return this.addressMinusSuffix === this.canonicalForm();
+ }
+ /**
+ * Returns true if the address is a link local address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ isLinkLocal() {
+ // Zeroes are required, i.e. we can't check isInSubnet with 'fe80::/10'
+ if (this.getBitsBase2(0, 64) ===
+ '1111111010000000000000000000000000000000000000000000000000000000') {
+ return true;
+ }
+ return false;
+ }
+ /**
+ * Returns true if the address is a multicast address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ isMulticast() {
+ return this.getType() === 'Multicast';
+ }
+ /**
+ * Returns true if the address is a v4-in-v6 address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ is4() {
+ return this.v4;
+ }
+ /**
+ * Returns true if the address is a Teredo address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ isTeredo() {
+ return this.isInSubnet(new Address6('2001::/32'));
+ }
+ /**
+ * Returns true if the address is a 6to4 address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ is6to4() {
+ return this.isInSubnet(new Address6('2002::/16'));
+ }
+ /**
+ * Returns true if the address is a loopback address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+ isLoopback() {
+ return this.getType() === 'Loopback';
+ }
+ // #endregion
+ // #region HTML
+ /**
+ * @returns {String} the address in link form with a default port of 80
+ */
+ href(optionalPort) {
+ if (optionalPort === undefined) {
+ optionalPort = '';
+ }
+ else {
+ optionalPort = `:${optionalPort}`;
+ }
+ return `http://[${this.correctForm()}]${optionalPort}/`;
+ }
+ /**
+ * @returns {String} a link suitable for conveying the address via a URL hash
+ */
+ link(options) {
+ if (!options) {
+ options = {};
+ }
+ if (options.className === undefined) {
+ options.className = '';
+ }
+ if (options.prefix === undefined) {
+ options.prefix = '/#address=';
+ }
+ if (options.v4 === undefined) {
+ options.v4 = false;
+ }
+ let formFunction = this.correctForm;
+ if (options.v4) {
+ formFunction = this.to4in6;
+ }
+ const form = formFunction.call(this);
+ if (options.className) {
+ return `${form}`;
+ }
+ return `${form}`;
+ }
+ /**
+ * Groups an address
+ * @returns {String}
+ */
+ group() {
+ if (this.elidedGroups === 0) {
+ // The simple case
+ return helpers.simpleGroup(this.address).join(':');
+ }
+ assert(typeof this.elidedGroups === 'number');
+ assert(typeof this.elisionBegin === 'number');
+ // The elided case
+ const output = [];
+ const [left, right] = this.address.split('::');
+ if (left.length) {
+ output.push(...helpers.simpleGroup(left));
+ }
+ else {
+ output.push('');
+ }
+ const classes = ['hover-group'];
+ for (let i = this.elisionBegin; i < this.elisionBegin + this.elidedGroups; i++) {
+ classes.push(`group-${i}`);
+ }
+ output.push(``);
+ if (right.length) {
+ output.push(...helpers.simpleGroup(right, this.elisionEnd));
+ }
+ else {
+ output.push('');
+ }
+ if (this.is4()) {
+ assert(this.address4 instanceof ipv4_1.Address4);
+ output.pop();
+ output.push(this.address4.groupForV6());
+ }
+ return output.join(':');
+ }
+ // #endregion
+ // #region Regular expressions
+ /**
+ * Generate a regular expression string that can be used to find or validate
+ * all variations of this address
+ * @memberof Address6
+ * @instance
+ * @param {boolean} substringSearch
+ * @returns {string}
+ */
+ regularExpressionString(substringSearch = false) {
+ let output = [];
+ // TODO: revisit why this is necessary
+ const address6 = new Address6(this.correctForm());
+ if (address6.elidedGroups === 0) {
+ // The simple case
+ output.push((0, regular_expressions_1.simpleRegularExpression)(address6.parsedAddress));
+ }
+ else if (address6.elidedGroups === constants6.GROUPS) {
+ // A completely elided address
+ output.push((0, regular_expressions_1.possibleElisions)(constants6.GROUPS));
+ }
+ else {
+ // A partially elided address
+ const halves = address6.address.split('::');
+ if (halves[0].length) {
+ output.push((0, regular_expressions_1.simpleRegularExpression)(halves[0].split(':')));
+ }
+ assert(typeof address6.elidedGroups === 'number');
+ output.push((0, regular_expressions_1.possibleElisions)(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0));
+ if (halves[1].length) {
+ output.push((0, regular_expressions_1.simpleRegularExpression)(halves[1].split(':')));
+ }
+ output = [output.join(':')];
+ }
+ if (!substringSearch) {
+ output = [
+ '(?=^|',
+ regular_expressions_1.ADDRESS_BOUNDARY,
+ '|[^\\w\\:])(',
+ ...output,
+ ')(?=[^\\w\\:]|',
+ regular_expressions_1.ADDRESS_BOUNDARY,
+ '|$)',
+ ];
+ }
+ return output.join('');
+ }
+ /**
+ * Generate a regular expression that can be used to find or validate all
+ * variations of this address.
+ * @memberof Address6
+ * @instance
+ * @param {boolean} substringSearch
+ * @returns {RegExp}
+ */
+ regularExpression(substringSearch = false) {
+ return new RegExp(this.regularExpressionString(substringSearch), 'i');
+ }
+}
+exports.Address6 = Address6;
+//# sourceMappingURL=ipv6.js.map