tshttpurl

export declare class IPv6 { private static readonly MAX; private static readonly IPV4PREFIX; private static readonly IPV4MASK; private static readonly ZERO; private static readonly HEX4REGEX; private static readonly HEX2REGEX; private static readonly HEXREGEX; private static readonly DECREGEX; private static readonly SPACEREGEX; private static readonly COLONSREGEX; private static readonly COLONREGEX; private value; /** * * @param value The object from which to create the new instance. E.g. * ```ts * "192.168.0.1" * "::FFFF:192.168.0.1" * "fe80:0:0:0:202:b3ff:fe1e:8329" * 0xfe800000000000000202b3fffe1e8329n * 0xFFFF08080808n // "8.8.8.8" * ``` */ constructor(value: IPv6 | bigint | string); /** * Parses a hexidecimal string. * @param value String made up only of hexidecimal digits * @returns number represented by `value` * @throws RangeError if the whole string isn't parsed. */ private static parseHex; /** * Parses a decimal string. * @param value String made up only of decimal digits * @returns number represented by `value` * @throws RangeError if the whole string isn't parsed. */ private static parseDecimal; /** * Gets the number of times the specified RegExp matches a specified string. * * @param subStr Regular Expression to search for. Should have * the 'g' flag specified so multiple matches are made. * @param superStr The String in which to search. * @returns the number of times `subStr` appears in `superStr` */ private static matchCount; /** * Casts the value to an IPv6 instance. * @param value Value to cast. * @returns the supplied value if it is already an IPv6, otherwise a new * IPv6 constructed from it. * @throws RangeError if a negative or >128 bit bigint is passed, or an * Error if string that can not be parsed is passed. */ static from(value: IPv6 | bigint | string): IPv6; /** * Casts the given object to a bigint. * @param value bigint, IPv6, or IPv6 formatted string to cast to a bigint. * @returns bigint */ private static toBigInt; /** * Helper function that parses an IPv6 string to a bigint * @param value String representing an IPv6 Address * @throws Error if the string can't be parsed * @returns bigint */ private static fromString; /** * Determines if the object represents an IP v 4 address or not. * ```ts * IPv6.isIPv4("10.0.0.1") // true * IPv6.isIPv4("::ffff:a00:1") // true * IPv6.isIPv4(" 2001:db8:a::123") // false * ``` * @param ipv6 The object to test. */ static isIPv4(ipv6: IPv6 | bigint | string): boolean; /** * Determines if the object represents an IP v 4 address or not. * ```ts * (new IPv6("10.0.0.1") ).isIPv4(); // true * (new IPv6("::ffff:a00:1") ).isIPv4(); // true * (new IPv6(" 2001:db8:a::123")).isIPv4(); // false * ``` * @returns true if this is an IP v 4 address, false otherwise. */ isIPv4(): boolean; /** * Gets the [canonical](https://en.wikipedia.org/wiki/IPv6_address#Recommended_representation_as_text) * IP v 6 representation of an IP Address. I.e. Lower case, without leading zeros and the left-most * largest set of consecutive zero parts collapsed to a double colon: * ```ts * "::ffff:192.168.0.1" * "2001:db8::1:0:0:1" * ``` * @param ipv6 The object representing the IPv6 address. * @param dotDec For [IPv4-mapped](https://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses), * indicates whether to use the 'dot-decimal' notation for the IPv4 part. * Defaults to true. For example: * ```ts * IPv6.toIPv6String("10.0.0.1") // "::ffff:10.0.0.1" * IPv6.toIPv6String("10.0.0.1", false) // "::ffff:a00:1" * ``` * @returns The compact IP v 6 representation of this IP Address. */ static toIPv6String(ipv6: IPv6 | bigint | string, dotDec?: boolean): string; /** * Gets the [canonical](https://en.wikipedia.org/wiki/IPv6_address#Recommended_representation_as_text) * IP v 6 representation of an IP Address. I.e. Lower case, without leading zeros and the left-most * largest set of consecutive zero parts collapsed to a double colon: * ```ts * "::ffff:192.168.0.1" * "2001:db8::1:0:0:1" * ``` * @param dotDec For [IPv4-mapped](https://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses), * indicates whether to use the 'dot-decimal' notation for the IPv4 part. * Defaults to true. For example: * ```ts * (new IPv6("10.0.0.1")).toIPv6String() // "::ffff:10.0.0.1" * (new IPv6("10.0.0.1")).toIPv6String(false) // "::ffff:a00:1" * ``` * @returns The compact IP v 6 representation of this IP Address. */ toIPv6String(dotDec?: boolean): string; /** * Gets the IP v 4 "dot-decimal" representation of an IP address, if it * represents an IP v 4 address. E.g. * ```ts * "192.168.0.1" * ``` * @returns The "dot-decimal" representation of this IP Address. * * @throws an Error if ipv6 isn't an IP v 4 address. (if isIPv4() === false) */ static toIPv4String(ipv6: IPv6 | bigint | string): string; /** * Gets the IP v 4 "dot-decimal" representation of this IP address, if this * address represents an IP v 4 address. E.g. * ```ts * "192.168.0.1" * ``` * * @returns The "dot-decimal" representation of this IP Address. * * @throws an Error if this isn't a IP v 4 address. (if isIPv4() === false) */ toIPv4String(): string; /**` * @returns returns the IP v 4 "dot-decimal" representation if * isIPv4() == true, otherwise the IP v 6 formatted version. */ toString(): string; /** * Compares this IP Address to another for order. * @param first The first address to compare * @param second The second address to compare * @returns A negative integer, zero, or a positive integer as first * is less than, equal to, or greater than second. * @throws an Error if either parameter is a string that can not be parsed. */ static compare(first: IPv6 | bigint | string, second: IPv6 | bigint | string): number; /** * Compares this IP Address to another for order. * @param other The address to use as a comparison. * * @returns A negative integer, zero, or a positive integer as this * is less than, equal to, or greater than other. * @throws an Error if other is a string that can not be parsed. */ compare(other: IPv6 | bigint | string): number; /** * Determines whether the arguments represent the same address * @param first The first address to use as a comparison. * @param second The second address to use as a comparison. * @returns boolean */ static equals(first: IPv6 | bigint | string | null, second: IPv6 | bigint | string | null): boolean; /** * Determines whether the passed in value represents the same value as * this instance * @param other The address to use as a comparison. * null or malformed addresses result in false being returned. * @returns boolean */ equals(other: IPv6 | bigint | string | null): boolean; }