net-address 0.1.2 → 0.2.0

package/dist/index.d.cts

@@ -1,30 +1,60 @@
-import { IOption, IResult } from "@luolapeikko/result-option";
+import { CoreResult } from "core-result";
 //#region src/Ipv6Addr.d.ts
 /**
  * Represents an IPv6 address.
  * @example
- * const addr1 = Ipv6Addr.from('2001:db8::1').unwrap();
+ * const addrRes1 = Ipv6Addr.from('2001:db8::1');
+ * const addr1 = Ipv6Addr.fromOrThrow('2001:db8::1');
  * const addr2 = new Ipv6Addr([0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]);
  * const addr3 = new Ipv6Addr(0x20010db8000000000000000000000001n);
  * @since v0.0.1
  */
-declare class Ipv6Addr {
+export declare class Ipv6Addr {
   #private;
-  private static regex;
   /**
    * Creates an IPv6 address from text.
    * @returns A successful result with an IPv6 address, or an error when the input is invalid.
    * @example
-   * const addr = Ipv6Addr.from('2001:db8::1').unwrap();
+   * const addrRes: CoreResult<Ipv6Addr, TypeError | RangeError> = Ipv6Addr.from('2001:db8::1');
    * @since v0.0.1
    */
-  static from(value: string): IResult<Ipv6Addr, TypeError | RangeError>;
+  static from(value: string): CoreResult<Ipv6Addr, TypeError | RangeError>;
+  /**
+   * Creates an IPv6 address from text and throws an error if the input is invalid.
+   * @param value The IPv6 address in string format.
+   * @returns The IPv6 address instance.
+   * @example
+   * const addr: Ipv6Addr = Ipv6Addr.fromOrThrow('2001:db8::1');
+   * @since v0.2.0
+   */
+  static fromOrThrow(value: string): Ipv6Addr;
   /**
    * Creates an IPv6 address from a 16-byte buffer.
    * @returns A successful result with an IPv6 address, or an error when the buffer cannot be read.
+   * @example
+   * const addrRes: CoreResult<Ipv6Addr> = Ipv6Addr.fromBuffer(buffer);
    * @since v0.0.1
    */
-  static fromBuffer(buffer: ArrayBuffer, littleEndian?: boolean): IResult<Ipv6Addr>;
+  static fromBuffer(buffer: ArrayBuffer, littleEndian?: boolean): CoreResult<Ipv6Addr>;
+  /**
+   * Creates an IPv6 address from a 16-byte buffer and throws an error if the buffer cannot be read.
+   * @param buffer The 16-byte buffer containing the IPv6 address.
+   * @param littleEndian Whether the buffer is in little-endian format. Defaults to false (big-endian).
+   * @returns The IPv6 address instance.
+   * @example
+   * const addr: Ipv6Addr = Ipv6Addr.fromBufferOrThrow(buffer);
+   * @since v0.2.0
+   */
+  static fromBufferOrThrow(buffer: ArrayBuffer, littleEndian?: boolean): Ipv6Addr;
+  /**
+   * Creates an IPv6 address from a raw bigint value.
+   * @param value The raw bigint value representing the IPv6 address.
+   * @returns The IPv6 address instance.
+   * @example
+   * const addr: Ipv6Addr = Ipv6Addr.fromRaw(0x20010db8000000000000000000000001n);
+   * @since v0.2.0
+   */
+  static fromRaw(value: bigint): Ipv6Addr;
   /**
    * The number of bits in an IPv6 address.
    * @since v0.0.1
@@ -46,11 +76,12 @@ declare class Ipv6Addr {
    */
   readonly family = "ipv6";
   /**
-   * Gets the raw bigint representation of the IPv6 address.
+   * Gets the raw {@link BigInt} representation of the {@link Ipv6Addr} address.
+   * @since v0.2.0
    */
   get value(): bigint;
   /**
-   * Creates a new IPv6 address instance.
+   * Creates a new {@link Ipv6Addr} address instance.
    * @param value - A bigint representing the IPv6 address or an array of 8 numbers representing the segments of the address.
    * @throws {RangeError} If the segments array does not have exactly 8 elements or if any segment is out of range.
    * @throws {TypeError} If the input is neither a bigint nor an array of 8 numbers.
@@ -106,6 +137,36 @@ declare class Ipv6Addr {
    * @since v0.0.2
    */
   isMulticastLinkLocal(): boolean;
+  /**
+   * Checks whether this address is the all-nodes multicast group address.
+   * @returns `true` when the address is multicast and the group ID is 1, otherwise `false`.
+   * @since v0.2.0
+   */
+  isAllNodesMulticastGroup(): boolean;
+  /**
+   * Checks whether this address is the all-routers multicast group address.
+   * @returns `true` when the address is multicast and the group ID is 2, otherwise `false`.
+   * @since v0.2.0
+   */
+  isAllRoutersMulticastGroup(): boolean;
+  /**
+   * Checks whether this address is the mDNS multicast group address.
+   * @returns `true` when the address is `ff02::fb`, otherwise `false`.
+   * @since v0.2.0
+   */
+  isMdnsMulticastGroup(): boolean;
+  /**
+   * Checks whether this address is the SSDP multicast group address.
+   * @returns `true` when the address is `ff02::c`, otherwise `false`.
+   * @since v0.2.0
+   */
+  isSsdpMulticastGroup(): boolean;
+  /**
+   * Checks whether this address is the DHCPv6 multicast group address.
+   * @returns `true` when the address is `ff02::12`, otherwise `false`.
+   * @since v0.2.0
+   */
+  isDhcpv6MulticastGroup(): boolean;
   /**
    * Checks whether this address is a multicast realm-local address.
    * @see https://datatracker.ietf.org/doc/html/rfc4291#section-2.7
@@ -184,79 +245,129 @@ declare class Ipv6Addr {
   isUniqueLocal(): boolean;
   /**
    * Converts this address to IPv4 when compatible or mapped.
-   * @returns An IPv4 address for `::a.b.c.d` or `::ffff:a.b.c.d`; otherwise `None`.
+   * @returns A {@link CoreResult} containing either the resulting {@link Ipv4Addr} or a {@link RangeError} if the address is not IPv4 compatible or mapped.
    * @since v0.0.1
    */
-  toIpv4(): IOption<Ipv4Addr>;
+  toIpv4(): CoreResult<Ipv4Addr, RangeError>;
+  /**
+   * Converts this address to IPv4 when compatible or mapped, throwing on failure.
+   * @returns An {@link Ipv4Addr} for `::a.b.c.d` or `::ffff:a.b.c.d`.
+   * @throws {RangeError} If the address is not IPv4 compatible or mapped.
+   * @since v0.2.0
+   */
+  toIpv4OrThrow(): Ipv4Addr;
   /**
    * Converts this address to IPv4 only when it is IPv4-mapped.
-   * @returns An IPv4 address for `::ffff:a.b.c.d`; otherwise `None`.
+   * @returns A {@link CoreResult} containing either the resulting {@link Ipv4Addr} or a {@link RangeError} if the address is not IPv4 mapped.
    * @since v0.0.1
    */
-  toIpv4Mapped(): IOption<Ipv4Addr>;
+  toIpv4Mapped(): CoreResult<Ipv4Addr, RangeError>;
+  /**
+   * Converts this address to IPv4 only when it is IPv4-mapped, throwing on failure.
+   * @returns An {@link Ipv4Addr} address for `::ffff:a.b.c.d`.
+   * @throws {RangeError} If the address is not IPv4 mapped.
+   * @since v0.2.0
+   */
+  toIpv4MappedOrThrow(): Ipv4Addr;
   /**
    * Formats this address as a compressed IPv6 string.
    * @returns The shortest standard IPv6 text form.
    * @since v0.0.1
    */
   toString(): string;
+  /**
+   * Converts this address to its fully expanded IPv6 string representation.
+   * @returns The expanded IPv6 string (e.g., `2001:0db8:0000:0000:0000:ff00:0042:8329`).
+   * @since v0.2.0
+   */
+  toExpandedString(): string;
   /**
    * Encodes this address to a 16-byte buffer.
    * @param littleEndian Whether to use little-endian byte order. Defaults to `false`.
-   * @returns An `ArrayBuffer` containing the IPv6 integer value.
+   * @returns An {@link ArrayBuffer} containing the IPv6 integer value.
    * @since v0.0.1
    */
   toBuffer(littleEndian?: boolean): ArrayBuffer;
   /**
-   * Compares this IPv6 address with another for equality.
-   * @param other instance of another IPv6 address to compare with.
+   * Compares this address with another for equality.
+   * @param other instance of another {@link Ipv6Addr} or {@link Ipv4Addr} address to compare with.
    * @returns `true` if both addresses are equal, otherwise `false`.
    * @since v0.1.0
    */
-  equals(other: Ipv6Addr | Ipv4Addr | object): boolean;
+  equals(other?: unknown): boolean;
 }
 //#endregion
 //#region src/Ipv4Addr.d.ts
 /**
  * Represents an IPv4 address.
  * @example
- * const addr1 = Ipv4Addr.from('192.168.0.1').unwrap();
+ * const addr1Res = Ipv4Addr.from('192.168.0.1');
+ * const addr1 = Ipv4Addr.fromOrThrow('192.168.0.1');
  * const addr2 = new Ipv4Addr(192, 168, 0, 1);
  * const addr3 = new Ipv4Addr(0xc0a80001);
  * @since v0.0.1
  */
-declare class Ipv4Addr {
+export declare class Ipv4Addr {
   #private;
   /**
    * Creates an IPv4 address from dotted-decimal text.
-   * @returns A successful {@link IResult} with an IPv4 address, or an error when the input is invalid.
+   * @returns A successful {@link CoreResult} with an {@link Ipv4Addr}, or an {@link TypeError} when the input is invalid.
+   * @example
+   * const addr: CoreResult<Ipv4Addr, TypeError> = Ipv4Addr.from('192.168.0.1');
    * @since v0.0.1
    */
-  static from(value: string): IResult<Ipv4Addr, TypeError>;
+  static from(value: string): CoreResult<Ipv4Addr, TypeError>;
+  /**
+   * Creates an IPv4 address from text and throws an error if the input is invalid.
+   * @param value The IPv4 address in string format.
+   * @returns The {@link Ipv4Addr} instance.
+   * @throws {TypeError} If the input is not a valid IPv4 address.
+   * @example
+   * const addr: Ipv4Addr = Ipv4Addr.fromOrThrow('192.168.0.1');
+   * @since v0.2.0
+   */
+  static fromOrThrow(value: string): Ipv4Addr;
   /**
    * Creates an IPv4 address from a 4-byte buffer.
-   * @returns A successful {@link IResult} with an IPv4 address, or an error when the buffer cannot be read.
+   * @returns A successful {@link CoreResult} with an {@link Ipv4Addr}, or an {@link Error} when the buffer cannot be read.
+   * @example
+   * const result: CoreResult<Ipv4Addr, Error> = Ipv4Addr.fromBuffer(buffer);
    * @since v0.0.1
    */
-  static fromBuffer(buffer: ArrayBuffer, littleEndian?: boolean): IResult<Ipv4Addr>;
+  static fromBuffer(buffer: ArrayBuffer, littleEndian?: boolean): CoreResult<Ipv4Addr, Error>;
+  /**
+   * Creates an IPv4 address from a 4-byte buffer and throws an error if the buffer cannot be read.
+   * @param buffer The 4-byte buffer containing the IPv4 address.
+   * @param littleEndian Whether the buffer is in little-endian format. Defaults to false (big-endian).
+   * @returns The {@link Ipv4Addr} instance.
+   * @throws {Error} If the buffer cannot be read.
+   * @example
+   * const addr: Ipv4Addr = Ipv4Addr.fromBufferOrThrow(buffer);
+   * @since v0.2.0
+   */
+  static fromBufferOrThrow(buffer: ArrayBuffer, littleEndian?: boolean): Ipv4Addr;
   /**
    * The number of bits in an IPv4 address.
    * @since v0.0.1
+   * @see https://doc.rust-lang.org/stable/std/net/struct.Ipv4Addr.html#associatedconstant.BITS
    */
   static readonly BITS = 32;
   /**
    * The broadcast address `255.255.255.255`.
    * @since v0.0.1
+   * @see https://doc.rust-lang.org/stable/std/net/struct.Ipv4Addr.html#associatedconstant.BROADCAST
    */
   static readonly BROADCAST: Ipv4Addr;
   /**
    * The localhost address `127.0.0.1`.
    * @since v0.0.1
+   * @see https://doc.rust-lang.org/stable/std/net/struct.Ipv4Addr.html#associatedconstant.LOCALHOST
    */
   static readonly LOCALHOST: Ipv4Addr;
   /**
    * The unspecified address `0.0.0.0`.
    * @since v0.0.1
+   * @see https://doc.rust-lang.org/stable/std/net/struct.Ipv4Addr.html#associatedconstant.UNSPECIFIED
    */
   static readonly UNSPECIFIED: Ipv4Addr;
   /**
@@ -357,23 +468,32 @@ declare class Ipv4Addr {
    * @see https://datatracker.ietf.org/doc/html/rfc6598
    * @returns `true` when the address is in `100.64.0.0/10`, otherwise `false`.
    * @since v0.0.1
+   * @see https://doc.rust-lang.org/stable/std/net/struct.Ipv4Addr.html#method.is_shared
    */
   isShared(): boolean;
   /**
    * Checks whether this address is the unspecified address.
    * @returns `true` when the address is `0.0.0.0`, otherwise `false`.
    * @since v0.0.1
+   * @see https://doc.rust-lang.org/stable/std/net/struct.Ipv4Addr.html#method.is_unspecified
    */
   isUnspecified(): boolean;
   /**
-   * Converts this address to an IPv4-compatible IPv6 address.
-   * @returns An IPv6 address in the form `::a.b.c.d`.
+   * Gets the four octets of this IPv4 address.
+   * @returns An array containing the four octets `[num1, num2, num3, num4]`.
+   * @see https://doc.rust-lang.org/stable/std/net/struct.Ipv4Addr.html#method.octets
+   * @since v0.2.0
+   */
+  toOctets(): [number, number, number, number];
+  /**
+   * Converts this address to an IPv4-compatible {@link Ipv6Addr}.
+   * @returns An {@link Ipv6Addr} in the form `::a.b.c.d`.
    * @since v0.0.1
    */
   toIpv6(): Ipv6Addr;
   /**
-   * Converts this address to an IPv4-mapped IPv6 address.
-   * @returns An IPv6 address in the form `::ffff:a.b.c.d`.
+   * Converts this address to an IPv4-mapped {@link Ipv6Addr}.
+   * @returns An {@link Ipv6Addr} in the form `::ffff:a.b.c.d`.
    * @since v0.0.1
    */
   toIpv6Mapped(): Ipv6Addr;
@@ -385,54 +505,343 @@ declare class Ipv4Addr {
   toString(): string;
   /**
    * Encodes this address to a 4-byte buffer.
-   * @returns An `ArrayBuffer` containing the IPv4 integer value.
+   * @returns An {@link ArrayBuffer} containing the IPv4 integer value.
    * @since v0.0.1
+   * @example
+   * const buffer: ArrayBuffer = addr.toBuffer();
    */
   toBuffer(littleEndian?: boolean): ArrayBuffer;
   /**
    * Compares this IPv4 address with another for equality.
-   * @param other instance of another IPv4 address to compare with.
+   * @param other instance of another address like to compare with.
    * @returns `true` if both addresses are equal, otherwise `false`.
    * @since v0.1.0
    */
-  equals(other: Ipv4Addr | Ipv6Addr | object): boolean;
+  equals(other?: unknown): boolean;
 }
 //#endregion
 //#region src/Ipv4Net.d.ts
 /**
  * Represents an IPv4 network.
  * @example
- * const addr = Ipv4Addr.from('192.168.0.1').unwrap();
+ * const addrRes = Ipv4Addr.from('192.168.0.1');
+ * const addr = Ipv4Addr.fromOrThrow('192.168.0.1');
  * const network = Ipv4Net.fromAddr(addr, 24);
  * @since v0.1.2
  */
-declare class Ipv4Net {
+export declare class Ipv4Net {
   #private;
-  readonly address: Ipv4Addr;
+  /**
+   * Size of the network (subnet mask length).
+   * @since v0.1.2
+   */
   readonly size: number;
+  /**
+   * Address family of the network.
+   * @since v0.1.2
+   */
+  readonly family: "ipv4";
   private constructor();
-  static fromAddr(address: Ipv4Addr, size: number): Ipv4Net;
-  static from(value: string): Ipv4Net;
-  isInRange(address: Ipv4Addr): boolean;
+  /**
+   * Creates an IPv4 network from address and a subnet mask length.
+   * @param address The starting {@link Ipv4Addr} of the network.
+   * @param size The size of the network (subnet mask length).
+   * @returns A {@link CoreResult} containing the parsed {@link Ipv4Net} instance or a {@link RangeError} if the network size is invalid.
+   * @example
+   * const networkRes: CoreResult<Ipv4Net, RangeError> = Ipv4Net.fromAddr(addr, 24);
+   * @since v0.2.0
+   */
+  static fromAddr(address: Ipv4Addr, size: number): CoreResult<Ipv4Net, RangeError>;
+  /**
+   * Creates an IPv4 network from address and a subnet mask length, throwing an error if creation fails.
+   * @param address The starting {@link Ipv4Addr} of the network.
+   * @param size The size of the network (subnet mask length).
+   * @returns The parsed {@link Ipv4Net} instance.
+   * @throws {RangeError} If the network size is invalid.
+   * @example
+   * const network: Ipv4Net = Ipv4Net.fromAddrOrThrow(addr, 24);
+   * @since v0.2.0
+   */
+  static fromAddrOrThrow(address: Ipv4Addr, size: number): Ipv4Net;
+  /**
+   * Creates an IPv4 network from its string representation.
+   * @param value The string representation of the IPv4 network, e.g., `192.168.0.1/24`.
+   * @returns A {@link CoreResult} containing the parsed {@link Ipv4Net} instance or a {@link TypeError} if parsing fails.
+   * @example
+   * const networkRes: CoreResult<Ipv4Net, TypeError> = Ipv4Net.from('192.168.0.1/24');
+   * @since v0.2.0
+   */
+  static from(value: string): CoreResult<Ipv4Net, TypeError>;
+  /**
+   * Creates an IPv4 network from its string representation, throwing an error if parsing fails.
+   * @param value The string representation of the IPv4 network, e.g., `192.168.0.1/24`.
+   * @returns The parsed {@link Ipv4Net} instance.
+   * @throws {TypeError} If the string representation is invalid.
+   * @example
+   * const network: Ipv4Net = Ipv4Net.fromOrThrow('192.168.0.1/24');
+   * @since v0.2.0
+   */
+  static fromOrThrow(value: string): Ipv4Net;
+  /**
+   * Checks if the given IPv4 address is contained within the network.
+   * @param addr The {@link Ipv4Addr} to check.
+   * @returns `true` if the given address is contained within the network, otherwise `false`.
+   * @since v0.2.0
+   */
+  contains(addr: Ipv4Addr): boolean;
+  /**
+   * Gets the broadcast address of the network.
+   * @returns The broadcast address as an {@link Ipv4Addr} instance.
+   * @since v0.2.0
+   */
+  broadcast(): Ipv4Addr;
+  /**
+   * Gets the network mask of the IPv4 network.
+   * @returns The network mask as an {@link Ipv4Addr} instance.
+   * @since v0.2.0
+   */
+  netmask(): Ipv4Addr;
+  /**
+   * Gets the string representation of the IPv4 network.
+   * @returns The IPv4 network as a string, e.g., `192.168.0.1/24`.
+   * @since v0.2.0
+   */
+  toString(): string;
+  /**
+   * Gets the first address within the network.
+   * @returns The first address as an {@link Ipv4Addr} instance.
+   * @since v0.2.0
+   */
+  first(): Ipv4Addr;
+  /**
+   * Gets the last address within the network.
+   * @returns The last address as an {@link Ipv4Addr} instance.
+   * @since v0.2.0
+   */
+  last(): Ipv4Addr;
+  /**
+   * Gets the first usable address within the network.
+   * @returns The first usable address as an {@link Ipv4Addr} instance.
+   * @since v0.2.0
+   */
+  firstUsable(): Ipv4Addr;
+  /**
+   * Gets the last usable address within the network.
+   * @returns The last usable address as an {@link Ipv4Addr} instance.
+   * @since v0.2.0
+   */
+  lastUsable(): Ipv4Addr;
+  /**
+   * Checks if the current network is equal to another network.
+   * @param other The other network to compare with.
+   * @returns `true` if the networks are equal, otherwise `false`.
+   * @example
+   * const isEqual = Ipv4Net.fromOrThrow('192.168.0.0/24').equals(Ipv4Net.fromOrThrow('192.168.0.0/24'));
+   * @since v0.2.0
+   */
+  equals(other?: unknown): boolean;
+  /**
+   * Assigns an address to the current network, effectively combining the network with the given address.
+   * @param value The other IPv4 address to combine with (e.g., `0.0.0.100`)
+   * @returns The combined IPv4 address as a {@link CoreResult} containing either the resulting {@link Ipv4Addr} or a {@link RangeError} if the address does not fit within the host portion of the network.
+   * @example
+   * const network = Ipv4Net.fromOrThrow('192.168.0.0/24');
+   * const result: CoreResult<Ipv4Addr, RangeError | TypeError> = network.assignAddress('0.0.0.100');
+   * const result: CoreResult<Ipv4Addr, RangeError | TypeError> = network.assignAddress(Ipv4Addr.fromOrThrow('0.0.0.100'))
+   * @since v0.2.0
+   */
+  assignAddress(value: Ipv4Addr | string): CoreResult<Ipv4Addr, RangeError | TypeError>;
+  /**
+   * Assigns an address to the current network, effectively combining the network with the given address.
+   * @param other The other IPv4 address to combine with (e.g., `0.0.0.100`)
+   * @returns The combined IPv4 address as an {@link Ipv4Addr} instance. (e.g., combining `192.168.0.0/24` with `0.0.0.100` would result in `192.168.0.100`)
+   * @throws {RangeError} If the given address does not fit within the host portion of the network.
+   * @example
+   * const network = Ipv4Net.fromOrThrow('192.168.0.0/24');
+   * const combined = network.assignAddressOrThrow('0.0.0.100'); // Ipv4Addr(192.168.0.100)
+   * const combined = network.assignAddressOrThrow(Ipv4Addr.fromOrThrow('0.0.0.100')); // Ipv4Addr(192.168.0.100)
+   * @since v0.2.0
+   */
+  assignAddressOrThrow(other: Ipv4Addr | string): Ipv4Addr;
+  /**
+   * Checks if the current network is a subnet of the given parent network.
+   * @param parent The parent network to check against.
+   * @returns `true` if the current network is a subnet of the parent network, `false` otherwise.
+   * @since v0.2.0
+   */
+  isSubnetOf(parent: Ipv4Net): boolean;
+  /**
+   * Checks if the current network contains the given child network.
+   * @param child The child network to check for containment.
+   * @returns `true` if the current network contains the child network, `false` otherwise.
+   * @since v0.2.0
+   */
+  containsNet(child: Ipv4Net): boolean;
+  /**
+   * Returns an iterable of all addresses within the network.
+   * @returns An {@link Ipv4Addr} {@link Iterable} of all addresses within the network.
+   * @since v0.2.0
+   */
+  addresses(): Iterable<Ipv4Addr>;
+  /**
+   * Returns an iterable of all usable host addresses within the network.
+   * @returns An {@link Ipv4Addr} {@link Iterable} of all usable host addresses within the network.
+   * @since v0.2.0
+   */
+  hosts(): Iterable<Ipv4Addr>;
 }
 //#endregion
 //#region src/Ipv6Net.d.ts
 /**
  * Represents an IPv6 network.
  * @example
- * const addr = Ipv6Addr.from('2001:db8::1').unwrap();
+ * const addrRes = Ipv6Addr.from('2001:db8::1');
+ * const addr = Ipv6Addr.fromOrThrow('2001:db8::1');
  * const network = Ipv6Net.fromAddr(addr, 64);
  * @since v0.1.2
  */
-declare class Ipv6Net {
+export declare class Ipv6Net {
   #private;
-  readonly address: Ipv6Addr;
+  /**
+   * Size of the network (prefix length).
+   * @since v0.1.2
+   */
   readonly size: number;
+  /**
+   * Address family of the network.
+   * @since v0.1.2
+   */
+  readonly family: "ipv6";
   private constructor();
-  static fromAddr(address: Ipv6Addr, size: number): Ipv6Net;
-  static from(value: string): Ipv6Net;
-  isInRange(address: Ipv6Addr): boolean;
+  /**
+   * Creates an instance of {@link Ipv6Net} from {@link Ipv6Addr} and network size.
+   * @param address The interface address as an {@link Ipv6Addr} instance.
+   * @param size The network size (prefix length) as a number.
+   * @returns A {@link CoreResult} containing the instance of {@link Ipv6Net} if successful, or a {@link RangeError} if the network size is invalid.
+   * @since v0.1.2
+   */
+  static fromAddr(address: Ipv6Addr, size: number): CoreResult<Ipv6Net, RangeError>;
+  /**
+   * Creates an instance of {@link Ipv6Net} from {@link Ipv6Addr} and network size, throwing an error if the size is invalid.
+   * @param address The interface address as an {@link Ipv6Addr} instance.
+   * @param size The network size (prefix length) as a number.
+   * @returns An instance of {@link Ipv6Net}.
+   * @throws {RangeError} If the network size is not between 0 and 128.
+   * @since v0.2.0
+   */
+  static fromAddrOrThrow(address: Ipv6Addr, size: number): Ipv6Net;
+  /**
+   * Creates an instance of {@link Ipv6Net} from a string representation.
+   * @param value The string representation of the IPv6 network, e.g., `2001:db8::/64` or full interface address with size.
+   * @returns A {@link CoreResult} containing the instance of {@link Ipv6Net} if successful, or a {@link TypeError} if the input is invalid.
+   * @since v0.1.2
+   */
+  static from(value: string): CoreResult<Ipv6Net, TypeError>;
+  /**
+   * Creates an instance of {@link Ipv6Net} from a string representation.
+   * @param value The string representation of the IPv6 network, e.g., `2001:db8::/64` or full interface address with size.
+   * @returns An instance of {@link Ipv6Net}.
+   * @throws {TypeError} If the input string is not a valid IPv6 network representation.
+   * @since v0.2.0
+   */
+  static fromOrThrow(value: string): Ipv6Net;
+  /**
+   * Checks if the given IPv6 address is contained within the network.
+   * @param addr The {@link Ipv6Addr} to check.
+   * @returns `true` if the given address is contained within the network, otherwise `false`.
+   * @since v0.2.0
+   */
+  contains(addr: Ipv6Addr): boolean;
+  /**
+   * Gets the network mask of the IPv6 network.
+   * @returns The network mask as an {@link Ipv6Addr} instance.
+   * @since v0.2.0
+   */
+  netmask(): Ipv6Addr;
+  /**
+   * Gets the string representation of the IPv6 network.
+   * @returns The IPv6 network as a string, e.g., `2001:db8::1/64`.
+   * @since v0.2.0
+   */
+  toString(): string;
+  /**
+   * Returns the expanded string representation of the IPv6 network.
+   * @returns The IPv6 network in expanded notation, e.g., `2001:0db8:0000:0000:0000:0000:0000:0001/64`.
+   * @since v0.2.0
+   */
+  toExpandedString(): string;
+  /**
+   * Gets the first address within the network.
+   * @returns The first address as an {@link Ipv6Addr} instance.
+   * @since v0.2.0
+   */
+  first(): Ipv6Addr;
+  /**
+   * Gets the last address within the network.
+   * @returns The last address as an {@link Ipv6Addr} instance.
+   * @since v0.2.0
+   */
+  last(): Ipv6Addr;
+  /**
+   * Gets the first usable address within the network.
+   * @returns The first usable address as an {@link Ipv6Addr} instance.
+   * @since v0.2.0
+   */
+  firstUsable(): Ipv6Addr;
+  /**
+   * Gets the last usable address within the network.
+   * @returns The last usable address as an {@link Ipv6Addr} instance.
+   * @since v0.2.0
+   */
+  lastUsable(): Ipv6Addr;
+  /**
+   * Checks if the current network is equal to another network.
+   * @param other The other network to compare with.
+   * @returns `true` if the networks are equal, otherwise `false`.
+   * @since v0.2.0
+   */
+  equals(other?: unknown): boolean;
+  /**
+   * Assigns an address to the current network, effectively combining the network with the given address.
+   * @param value The other IPv6 address to combine with (e.g., `::100`)
+   * @returns The combined IPv6 address as a {@link CoreResult} containing either the resulting {@link Ipv6Addr} or a {@link RangeError} if the address does not fit within the host portion of the network.
+   * @since v0.2.0
+   */
+  assignAddress(value: Ipv6Addr | string): CoreResult<Ipv6Addr, RangeError>;
+  /**
+   * Assigns an address to the current network, effectively combining the network with the given address.
+   * @param other The other IPv6 address to combine with (e.g., `::100`)
+   * @returns The combined IPv6 address as an {@link Ipv6Addr} instance. (e.g., combining `2001:db8::/64` with `::100` would result in `2001:db8::100`)
+   * @throws {RangeError} If the given address does not fit within the host portion of the network.
+   * @since v0.2.0
+   */
+  assignAddressOrThrow(other: Ipv6Addr | string): Ipv6Addr;
+  /**
+   * Checks if the current network is a subnet of the given parent network.
+   * @param parent The parent network to check against.
+   * @returns `true` if the current network is a subnet of the parent network, `false` otherwise.
+   * @since v0.2.0
+   */
+  isSubnetOf(parent: Ipv6Net): boolean;
+  /**
+   * Checks if the current network contains the given child network.
+   * @param child The child network to check for containment.
+   * @returns `true` if the current network contains the child network, `false` otherwise.
+   * @since v0.2.0
+   */
+  containsNet(child: Ipv6Net): boolean;
+  /**
+   * Gets an iterable of all addresses within the network.
+   * @returns An {@link Ipv6Addr} {@link Iterable} of all addresses within the network.
+   * @since v0.2.0
+   */
+  addresses(): Iterable<Ipv6Addr>;
+  /**
+   * Gets an iterable of all usable host addresses within the network.
+   * @returns An {@link Ipv6Addr} {@link Iterable} of all usable host addresses within the network.
+   * @since v0.2.0
+   */
+  hosts(): Iterable<Ipv6Addr>;
 }
 //#endregion
-export { Ipv4Addr, Ipv4Net, Ipv6Addr, Ipv6Net };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/Ipv6Addr.ts","../src/Ipv4Addr.ts","../src/Ipv4Net.ts","../src/Ipv6Net.ts"],"mappings":";;;;;;;;;;cAWa;;iBACG;;;;;;;;SAUD,KAAK,gBAAgB,QAAQ,UAAU,YAAY;;;;;;SAgCnD,WAAW,QAAQ,aAAa,yBAAyB,QAAQ;;;;;kBA6DxD;;;;;kBAMA,WAAW;;;;;kBAMX,aAAa;;;;;WAMpB;;;;MAOL;;;;;;;EAUX,YAAmB;EACnB,YAAmB;;;;;;;EAiBnB;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;EASA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAmBA;;;;;;EASA,UAAiB,QAAQ;;;;;;EAazB,gBAAuB,QAAQ;;;;;;EAa/B;;;;;;;EAyCA,SAAgB,yBAAyB;;;;;;;EAmBzC,OAAc,OAAO,WAAW;;;;;;;;;;;;cC9apB;;;;;;;SAME,KAAK,gBAAgB,QAAQ,UAAU;;;;;;SAiBvC,WAAW,QAAQ,aAAa,yBAAyB,QAAQ;;;;;kBAaxD;;;;;kBAMA,WAAW;;;;;kBAMX,WAAW;;;;;kBAMX,aAAa;;;;;WAMpB;;;;MAOL;;;;;;;;;;;;EAeX,YAAmB,cAAc,cAAc,cAAc;;;;;;;;;EAS7D,YAAmB;;;;;;;EAqBnB;;;;;;;EAUA;;;;;;;EAcA;;;;;;;EAUA;;;;;;;EAqBA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAUA;;;;;;;EAcA;;;;;;;EAUA;;;;;;EASA;;;;;;EASA,UAAiB;;;;;;EASjB,gBAAuB;;;;;;EASvB;;;;;;EAUA,SAAgB,yBAAyB;;;;;;;EAazC,OAAc,OAAO,WAAW;;;;;;;;;;;cC1RpB;;WAGI,SAAS;WACT;UACR;SAUM,SAAS,SAAS,UAAU,eAAe;SAI3C,KAAK,gBAAgB;EAanC,UAAiB,SAAS;;;;;;;;;;;cChCd;;WAGI,SAAS;WACT;UACR;SASM,SAAS,SAAS,UAAU,eAAe;SAI3C,KAAK,gBAAgB;EAanC,UAAiB,SAAS"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/Ipv6Addr.ts","../src/Ipv4Addr.ts","../src/Ipv4Net.ts","../src/Ipv6Net.ts"],"mappings":"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"}