* 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

* 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

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

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

* 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

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

* 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 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

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

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

* 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}

* Return the bits in the given range as a base-2 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

* Returns true if the address is a link-local unicast address in `fe80::/10` * ([RFC 4291 §2.4](https://datatracker.ietf.org/doc/html/rfc4291#secti

* 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 the unspecified address `::`. * @returns {boolean}

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

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

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

* The last address in the range given by this address's subnet. IPv6 has * no broadcast address, so this is an ordinary assignable address (in a

* 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 globally reachable: inside the global * unicast allocation `2000::/3` (the only range the [IANA IPv6 Address Space

* 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 private, i.e. a Unique Local Address in * `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)),

* 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 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 address one before {@link endAddress}. This is the IPv6 counterpart * of the IPv4 method that skips the broadcast address; IPv6 has no broadc

* 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. A full 32-nibble name gives a /128 * address; a shorter name, as used for a delegated reverse zone, gives t

* 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 benchmarking range `2001:2::/48` * ([RFC 5180](https://datatracker.ietf.org/doc/html/rfc5180)) or is an

* Returns true if the address is in the canonical form, 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 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 `

* Returns the network that follows this address's network: the address after * {@link endAddress}, with the same subnet mask. Throws `AddressError`

* Returns the address `n` addresses after this one (or before, when `n` is * negative), keeping this address's subnet mask. Throws `AddressError` w

* 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 given address is a multicast address * @returns {boolean}

* Returns true if the address is in the reserved range `240.0.0.0/4` ([RFC 1112](https://datatracker.ietf.org/doc/html/rfc1112)), * which includes

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