* Returns the address in correct form, per * [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952): leading zeros * stripped, the longest ru

* Convert a BigInt to a v6 address object. The value must be in the * range `[0, 2**128 - 1]`; otherwise `AddressError` is thrown. * @param {big

* If this address embeds a routable IPv4 address — i.e. it is IPv4-mapped * (`::ffff:0:0/96`) or sits in the NAT64 well-known prefix (`64:ff9b::/96

* Return the address as a BigInt * @returns {bigint}

* Converts a hex string to an IPv4 address object. Accepts 8 hex digits * with optional `:` separators (e.g. `'7f000001'` or `'7f:00:00:01'`). *

* Converts a BigInt to a v4 address object. The value must be in the * range `[0, 2**32 - 1]`; otherwise `AddressError` is thrown. * @param {big

* Return a zero-padded base-2 string representation of the address * @returns {String} * @example * var address = new Address6('2001:4860:400

* Returns the canonical (fully expanded) form of the address: all 8 groups, * each padded to 4 hex digits, with no `::` collapsing * (e.g. `2001

* Returns the address in correct form: octets joined with `.` and any * leading zeros stripped (e.g. `192.168.1.1`). For IPv4 this matches the *

* Return the bits in the given range as a base-2 string * @returns {String}

* Return the type of the address * @returns {String}

* Convert a byte array to an Address6 object. * * Accepts unsigned bytes (0 to 255) or signed bytes (-128 to 127, as an * `Int8Array` or a Ja

* Convert an unsigned byte array to an Address6 object. * * Throws `AddressError` unless given exactly 16 integers from 0 to 255. * * To c

* Return the bits in the given range as a base-16 string * @returns {String}

* Returns true if the address was written in v4-in-v6 dotted-quad notation * (e.g. `::ffff:127.0.0.1`), false otherwise. This is a notation-level f

* The first address in the range given by this address' subnet * Often referred to as the Network Address. * @returns {Address6}

* Returns the address as a `bigint` * @returns {bigint}

* The last address in the range given by this address' subnet * Often referred to as the Broadcast * @returns {Address6}

* Return the bits in the given range as a BigInt * @returns {bigint}

* Returns true if the address is an IPv4-mapped / NAT64 address whose embedded * IPv4 address is the limited broadcast address `255.255.255.255`

* Returns true if the address is an IPv4-mapped / NAT64 address whose embedded * IPv4 address is in the carrier-grade NAT range `100.64.0.0/10`

* Returns true if the address is a link local address, false otherwise * @returns {boolean}

* Returns true if the address is a loopback address, false otherwise * @returns {boolean}

* Returns true if the address is a multicast address, false otherwise * @returns {boolean}

* Returns true if the address is private, i.e. a Unique Local Address in * `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)) o

* Returns true if the address is the unspecified address `::`. * @returns {boolean}

* Returns true if the given string is a valid IPv6 address (with optional * CIDR subnet and zone identifier), false otherwise. Host bits in the

* Return the first n bits of the address, defaulting to the subnet mask * @param {number} [mask=subnet] - the number of bits to mask * @returns

* Return the last two groups of this address as an IPv4 address string. * If this address carries a CIDR prefix that covers the trailing 32 bits

* Return a byte array. * * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toByteArray())`. * @returns {Array}

* Helper function getting end address. * @returns {bigint}

* Helper function getting end address. * @returns {bigint}

* Helper function getting start address. * @returns {bigint}

* Helper function getting start address. * @returns {bigint}

* Returns a zero-padded base-2 string representation of the address * @returns {string}

* The last host address in the range given by this address's subnet ie * the last address prior to the Broadcast Address * @returns {Address6}

* Create an IPv6-mapped address given an IPv4 address * @param {string} address - An IPv4 address string * @returns {Address6} * @example

* Construct an `Address6` from an address and a hex subnet mask given as * separate strings (e.g. as returned by Node's `os.networkInterfaces()`).

* Construct an `Address6` from an address and a Cisco-style wildcard mask * given as separate strings (e.g. `::ffff:ffff:ffff:ffff` for a `/64`).

* Return an address from ip6.arpa form * @param {string} arpaFormAddress - an 'ip6.arpa' form address * @returns {Adress6} * @example * va

* Converts an integer into a IPv4 address object. The integer must be a * non-negative safe integer in the range `[0, 2**32 - 1]`; otherwise * `

* Parse a URL (with optional bracketed host and port) into an address and * port. Returns either `{ address, port }` on success or * `{ error, a

* Construct an `Address6` from a wildcard pattern with trailing `*` * groups. The number of trailing wildcards determines the prefix * length: e

* Groups an IPv4 address for inclusion at the end of an IPv6 address. * * Returns an HTML fragment: each half of the address is wrapped in a

* Returns true if the address is in the canonical form, false otherwise * @returns {boolean}

* Returns true if the address is an IPv4-mapped IPv6 address in * `::ffff:0:0/96` ([RFC 4291 §2.5.5.2](https://datatracker.ietf.org/doc/html/rfc429

* Returns true if the address is a Unique Local Address in `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)). ULAs are the IPv6 e

* Returns the first n bits of the address, defaulting to the * subnet mask * @returns {String}

* The network address in CIDR string form, e.g. `2001:db8::/32` for * `2001:db8::1/32`. For an address with no explicit subnet the prefix * is `

* Generate a regular expression string that can be used to find or validate * all variations of this address * @param {boolean} substringSearch

* Return the reversed ip6.arpa form of the address * @param {Object} options * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix

* The first host address in the range given by this address's subnet ie * the first address after the Network Address * @returns {Address6}

* The hex form of the subnet mask, e.g. `ffff:ffff:ffff:ffff::` for a * `/64`. Returns an `Address6`; call `.correctForm()` for the string. * @r

* Return the v4-in-v6 form of the address * @returns {String}

* Converts an IPv4 address object to a hex string * @returns {String}

* Return an unsigned byte array. * * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toUnsignedByteArray())`. * @returns {Ar

* The Cisco-style wildcard mask, e.g. `::ffff:ffff:ffff:ffff` for a * `/64`. This is the bitwise inverse of `subnetMaskAddress()`. Returns * an

* Return the decimal form of the address * @returns {String}

* Embed an IPv4 address into a NAT64 IPv6 address using the encoding * defined by [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052). * T

* Convert an unsigned byte array to an Address4 object. Throws * `AddressError` unless given exactly 4 bytes, and rejects values outside * 0 to

* Returns the bits in the given range as a base-2 string * @returns {string}

* Return the bits that are set past the subnet mask length * @returns {String}

* Return the scope of the address. The 4-bit scope field * ([RFC 4291 §2.7](https://datatracker.ietf.org/doc/html/rfc4291#section-2.7)) * is onl

* Groups an address. * * Returns an HTML fragment: each group is wrapped in a `<span>` carrying * the group classes an address-inspector UI h

* Returns the address as an HTTP URL with the host bracketed, e.g. * `http://[2001:db8::1]/`. If `optionalPort` is provided it is appended, * e.

* Decodes the 6to4 tunneling fields embedded in this address. Returns the * 6to4 prefix and the embedded IPv4 gateway address. Only meaningful for

* Decodes the Teredo tunneling fields embedded in this address. Returns the * Teredo prefix, server IPv4, client IPv4, raw flag bits, cone-NAT flag

* Returns true if the address is a 6to4 address, false otherwise * @returns {boolean}

* Returns true if the address is in the documentation prefix `2001:db8::/32` ([RFC 3849](https://datatracker.ietf.org/doc/html/rfc3849)). * @return

* Returns true if the address is a Teredo address, false otherwise * @returns {boolean}

* Returns an HTML `<a>` element whose `href` encodes the address in a URL * hash fragment (default prefix `/#address=`). Useful for linking between

* Return the Microsoft UNC transcription of the address * @returns {String} the Microsoft UNC transcription of the address

* Parses an IPv4 address string into its four octet groups and stores the * result on `this.parsedAddress`. Called automatically by the constructor

* Generate a regular expression that can be used to find or validate all * variations of this address. * @param {boolean} substringSearch * @