Brunobkr/llama.cpp_AlgMor24_github

1import * as common from './common';2import { Address4 } from './ipv4';3interface SixToFourProperties {4    prefix: string;5    gateway: string;6}7interface TeredoProperties {8    prefix: string;9    server4: string;10    client4: string;11    flags: string;12    coneNat: boolean;13    microsoft: {14        reserved: boolean;15        universalLocal: boolean;16        groupIndividual: boolean;17        nonce: string;18    };19    udpPort: string;20}21/**22 * Represents an IPv6 address23 * @param {string} address - An IPv6 address string24 * @param {number} [groups=8] - How many octets to parse25 * @example26 * var address = new Address6('2001::/32');27 */28export declare class Address6 {29    address4?: Address4;30    address: string;31    addressMinusSuffix: string;32    elidedGroups?: number;33    elisionBegin?: number;34    elisionEnd?: number;35    groups: number;36    parsedAddress4?: string;37    parsedAddress: string[];38    parsedSubnet: string;39    subnet: string;40    subnetMask: number;41    v4: boolean;42    zone: string;43    private _binaryZeroPad?;44    constructor(address: string, optionalGroups?: number);45    /**46     * Returns true if the given string is a valid IPv6 address (with optional47     * CIDR subnet and zone identifier), false otherwise. Host bits in the48     * subnet portion are allowed (e.g. `2001:db8::1/32` is valid); for strict49     * network-address validation compare `correctForm()` to50     * `startAddress().correctForm()`, or use `networkForm()`.51     */52    static isValid(address: string): boolean;53    /**54     * Convert a BigInt to a v6 address object. The value must be in the55     * range `[0, 2**128 - 1]`; otherwise `AddressError` is thrown.56     * @param {bigint} bigInt - a BigInt to convert57     * @returns {Address6}58     * @example59     * var bigInt = BigInt('1000000000000');60     * var address = Address6.fromBigInt(bigInt);61     * address.correctForm(); // '::e8:d4a5:1000'62     */63    static fromBigInt(bigInt: bigint): Address6;64    /**65     * Parse a URL (with optional bracketed host and port) into an address and66     * port. Returns either `{ address, port }` on success or67     * `{ error, address: null, port: null }` if the URL could not be parsed.68     * Ports are returned as numbers (or `null` if absent or out of range).69     * @example70     * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');71     * addressAndPort.address.correctForm(); // 'ffff::'72     * addressAndPort.port; // 808073     */74    static fromURL(url: string): {75        error: string;76        address: null;77        port: null;78    } | {79        address: Address6;80        port: number | null;81        error?: undefined;82    };83    /**84     * Construct an `Address6` from an address and a hex subnet mask given as85     * separate strings (e.g. as returned by Node's `os.networkInterfaces()`).86     * Throws `AddressError` if the mask is non-contiguous (e.g.87     * `ffff::ffff`).88     * @example89     * var address = Address6.fromAddressAndMask('fe80::1', 'ffff:ffff:ffff:ffff::');90     * address.subnetMask; // 6491     */92    static fromAddressAndMask(address: string, mask: string): Address6;93    /**94     * Construct an `Address6` from an address and a Cisco-style wildcard mask95     * given as separate strings (e.g. `::ffff:ffff:ffff:ffff` for a `/64`).96     * The wildcard mask is the bitwise inverse of the subnet mask. Throws97     * `AddressError` if the mask is non-contiguous.98     * @example99     * var address = Address6.fromAddressAndWildcardMask('fe80::1', '::ffff:ffff:ffff:ffff');100     * address.subnetMask; // 64101     */102    static fromAddressAndWildcardMask(address: string, wildcardMask: string): Address6;103    /**104     * Construct an `Address6` from a wildcard pattern with trailing `*`105     * groups. The number of trailing wildcards determines the prefix106     * length: each `*` represents 16 bits. `::` is expanded to zero groups107     * (not wildcards) before evaluating trailing wildcards.108     *109     * Only trailing whole-group wildcards are supported. Partial-group110     * wildcards (e.g. `2001:db8::0*`) and interior wildcards (e.g.111     * `*::1`) throw `AddressError`.112     * @example113     * Address6.fromWildcard('2001:db8:*:*:*:*:*:*').subnet;  // '/32'114     * Address6.fromWildcard('2001:db8::*').subnet;           // '/112'115     * Address6.fromWildcard('*:*:*:*:*:*:*:*').subnet;       // '/0'116     */117    static fromWildcard(input: string): Address6;118    /**119     * Create an IPv6-mapped address given an IPv4 address120     * @param {string} address - An IPv4 address string121     * @returns {Address6}122     * @example123     * var address = Address6.fromAddress4('192.168.0.1');124     * address.correctForm(); // '::ffff:c0a8:1'125     * address.to4in6(); // '::ffff:192.168.0.1'126     */127    static fromAddress4(address: string): Address6;128    /**129     * Return an address from ip6.arpa form130     * @param {string} arpaFormAddress - an 'ip6.arpa' form address131     * @returns {Adress6}132     * @example133     * 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.)134     * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe'135     */136    static fromArpa(arpaFormAddress: string): Address6;137    /**138     * Return the Microsoft UNC transcription of the address139     * @returns {String} the Microsoft UNC transcription of the address140     */141    microsoftTranscription(): string;142    /**143     * Return the first n bits of the address, defaulting to the subnet mask144     * @param {number} [mask=subnet] - the number of bits to mask145     * @returns {String} the first n bits of the address as a string146     */147    mask(mask?: number): string;148    /**149     * Return the number of possible subnets of a given size in the address150     * @param {number} [subnetSize=128] - the subnet size151     * @returns {String}152     */153    possibleSubnets(subnetSize?: number): string;154    /**155     * Helper function getting start address.156     * @returns {bigint}157     */158    _startAddress(): bigint;159    /**160     * The first address in the range given by this address' subnet161     * Often referred to as the Network Address.162     * @returns {Address6}163     */164    startAddress(): Address6;165    /**166     * The first host address in the range given by this address's subnet ie167     * the first address after the Network Address168     * @returns {Address6}169     */170    startAddressExclusive(): Address6;171    /**172     * Helper function getting end address.173     * @returns {bigint}174     */175    _endAddress(): bigint;176    /**177     * The last address in the range given by this address' subnet178     * Often referred to as the Broadcast179     * @returns {Address6}180     */181    endAddress(): Address6;182    /**183     * The last host address in the range given by this address's subnet ie184     * the last address prior to the Broadcast Address185     * @returns {Address6}186     */187    endAddressExclusive(): Address6;188    /**189     * The hex form of the subnet mask, e.g. `ffff:ffff:ffff:ffff::` for a190     * `/64`. Returns an `Address6`; call `.correctForm()` for the string.191     * @returns {Address6}192     */193    subnetMaskAddress(): Address6;194    /**195     * The Cisco-style wildcard mask, e.g. `::ffff:ffff:ffff:ffff` for a196     * `/64`. This is the bitwise inverse of `subnetMaskAddress()`. Returns197     * an `Address6`; call `.correctForm()` for the string.198     * @returns {Address6}199     */200    wildcardMask(): Address6;201    /**202     * The network address in CIDR string form, e.g. `2001:db8::/32` for203     * `2001:db8::1/32`. For an address with no explicit subnet the prefix204     * is `/128`, e.g. `networkForm()` on `2001:db8::1` returns205     * `2001:db8::1/128`.206     * @returns {string}207     */208    networkForm(): string;209    /**210     * Return the scope of the address. The 4-bit scope field211     * ([RFC 4291 §2.7](https://datatracker.ietf.org/doc/html/rfc4291#section-2.7))212     * is only defined for multicast addresses; for unicast addresses the scope213     * is derived from the address type per214     * [RFC 4007 §6](https://datatracker.ietf.org/doc/html/rfc4007#section-6).215     * @returns {String}216     */217    getScope(): string;218    /**219     * Return the type of the address220     * @returns {String}221     */222    getType(): string;223    /**224     * Return the bits in the given range as a BigInt225     * @returns {bigint}226     */227    getBits(start: number, end: number): bigint;228    /**229     * Return the bits in the given range as a base-2 string230     * @returns {String}231     */232    getBitsBase2(start: number, end: number): string;233    /**234     * Return the bits in the given range as a base-16 string235     * @returns {String}236     */237    getBitsBase16(start: number, end: number): string;238    /**239     * Return the bits that are set past the subnet mask length240     * @returns {String}241     */242    getBitsPastSubnet(): string;243    /**244     * Return the reversed ip6.arpa form of the address245     * @param {Object} options246     * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix247     * @returns {String}248     */249    reverseForm(options?: common.ReverseFormOptions): string;250    /**251     * Returns the address in correct form, per252     * [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952): leading zeros253     * stripped, the longest run of zero groups collapsed to `::`, and hex digits254     * lowercased (e.g. `2001:db8::1`). This is the recommended form for display.255     */256    correctForm(): string;257    /**258     * Return a zero-padded base-2 string representation of the address259     * @returns {String}260     * @example261     * var address = new Address6('2001:4860:4001:803::1011');262     * address.binaryZeroPad();263     * // '0010000000000001010010000110000001000000000000010000100000000011264     * //  0000000000000000000000000000000000000000000000000001000000010001'265     */266    binaryZeroPad(): string;267    /**268     * Parses a v4-in-v6 string (e.g. `::ffff:192.168.0.1`) by extracting the269     * trailing IPv4 address into `this.address4` / `this.parsedAddress4` and270     * returning the address with the v4 portion converted to two v6 groups.271     * Used internally by `parse()`.272     */273    parse4in6(address: string): string;274    /**275     * Parses an IPv6 address string into its 8 hexadecimal groups (expanding276     * any `::` elision and any trailing v4-in-v6 portion) and stores the result277     * on `this.parsedAddress`. Called automatically by the constructor; you278     * typically don't need to call it directly. Throws `AddressError` if the279     * input is malformed.280     */281    parse(address: string): string[];282    /**283     * Returns the canonical (fully expanded) form of the address: all 8 groups,284     * each padded to 4 hex digits, with no `::` collapsing285     * (e.g. `2001:0db8:0000:0000:0000:0000:0000:0001`). Useful for sorting and286     * byte-exact comparison.287     */288    canonicalForm(): string;289    /**290     * Return the decimal form of the address291     * @returns {String}292     */293    decimal(): string;294    /**295     * Return the address as a BigInt296     * @returns {bigint}297     */298    bigInt(): bigint;299    /**300     * Return the last two groups of this address as an IPv4 address string.301     * If this address carries a CIDR prefix that covers the trailing 32 bits302     * (i.e. `subnetMask >= 96`), the resulting `Address4` inherits the303     * corresponding v4 prefix (`subnetMask - 96`); otherwise it defaults to304     * `/32`.305     * @returns {Address4}306     * @example307     * var address = new Address6('2001:4860:4001::1825:bf11');308     * address.to4().correctForm(); // '24.37.191.17'309     */310    to4(): Address4;311    /**312     * Return the v4-in-v6 form of the address313     * @returns {String}314     */315    to4in6(): string;316    /**317     * Decodes the Teredo tunneling fields embedded in this address. Returns the318     * Teredo prefix, server IPv4, client IPv4, raw flag bits, cone-NAT flag,319     * UDP port, and Microsoft-format flag breakdown (reserved, universal/local,320     * group/individual, nonce). Only meaningful for addresses in `2001::/32`.321     */322    inspectTeredo(): TeredoProperties;323    /**324     * Decodes the 6to4 tunneling fields embedded in this address. Returns the325     * 6to4 prefix and the embedded IPv4 gateway address. Only meaningful for326     * addresses in `2002::/16`.327     */328    inspect6to4(): SixToFourProperties;329    /**330     * Return a v6 6to4 address from a v6 v4inv6 address331     * @returns {Address6}332     */333    to6to4(): Address6 | null;334    /**335     * Embed an IPv4 address into a NAT64 IPv6 address using the encoding336     * defined by [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052).337     * The default prefix is the well-known prefix `64:ff9b::/96`. The prefix338     * length must be one of 32, 40, 48, 56, 64, or 96; for prefixes shorter339     * than /64 the IPv4 octets are split around the reserved bits 64–71.340     * @example341     * Address6.fromAddress4Nat64('192.0.2.33').correctForm(); // '64:ff9b::c000:221'342     * Address6.fromAddress4Nat64('192.0.2.33', '2001:db8::/32').correctForm(); // '2001:db8:c000:221::'343     */344    static fromAddress4Nat64(address: string, prefix?: string): Address6;345    /**346     * Extract the embedded IPv4 address from a NAT64 IPv6 address using the347     * encoding defined by [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052).348     * The default prefix is the well-known prefix `64:ff9b::/96`. Returns349     * `null` if this address is not contained within the given prefix.350     * @example351     * new Address6('64:ff9b::c000:221').toAddress4Nat64()!.correctForm(); // '192.0.2.33'352     */353    toAddress4Nat64(prefix?: string): Address4 | null;354    /**355     * Return a byte array.356     *357     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toByteArray())`.358     * @returns {Array}359     */360    toByteArray(): number[];361    /**362     * Return an unsigned byte array.363     *364     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toUnsignedByteArray())`.365     * @returns {Array}366     */367    toUnsignedByteArray(): number[];368    /**369     * Convert a byte array to an Address6 object.370     *371     * Accepts unsigned bytes (0 to 255) or signed bytes (-128 to 127, as an372     * `Int8Array` or a Java `byte[]` holds them), folding signed values to their373     * unsigned equivalent. Throws `AddressError` unless given exactly 16374     * integers from -128 to 255.375     *376     * To convert from a Node.js `Buffer`, spread it: `Address6.fromByteArray([...buf])`.377     * @returns {Address6}378     */379    static fromByteArray(bytes: Array<number>): Address6;380    /**381     * Convert an unsigned byte array to an Address6 object.382     *383     * Throws `AddressError` unless given exactly 16 integers from 0 to 255.384     *385     * To convert from a Node.js `Buffer`, spread it: `Address6.fromUnsignedByteArray([...buf])`.386     * @returns {Address6}387     */388    static fromUnsignedByteArray(bytes: Array<number>): Address6;389    /**390     * Returns true if the given address is in the subnet of the current address391     * @returns {boolean}392     */393    isInSubnet: typeof common.isInSubnet;394    /**395     * Returns true if this address's host bits fall inside the given subnet,396     * ignoring this address's own subnet mask. See397     * {@link common.isHostInSubnet}.398     * @returns {boolean}399     */400    isHostInSubnet: typeof common.isHostInSubnet;401    /**402     * Returns true if the address is correct, false otherwise403     * @returns {boolean}404     */405    isCorrect: (this: Address4 | Address6) => boolean;406    /**407     * Returns true if the address is in the canonical form, false otherwise408     * @returns {boolean}409     */410    isCanonical(): boolean;411    /**412     * Returns true if the address is a link local address, false otherwise413     * @returns {boolean}414     */415    isLinkLocal(): boolean;416    /**417     * Returns true if the address is a multicast address, false otherwise418     * @returns {boolean}419     */420    isMulticast(): boolean;421    /**422     * Returns true if the address was written in v4-in-v6 dotted-quad notation423     * (e.g. `::ffff:127.0.0.1`), false otherwise. This is a notation-level flag424     * and does not reflect whether the address bits lie in the IPv4-mapped425     * (`::ffff:0:0/96`) subnet — for that, see {@link isMapped4}.426     * @returns {boolean}427     */428    is4(): boolean;429    /**430     * Returns true if the address is an IPv4-mapped IPv6 address in431     * `::ffff:0:0/96` ([RFC 4291 §2.5.5.2](https://datatracker.ietf.org/doc/html/rfc4291#section-2.5.5.2)),432     * false otherwise. Unlike {@link is4}, this checks the underlying address433     * bits rather than the textual notation, so `::ffff:127.0.0.1` and434     * `::ffff:7f00:1` both return true.435     * @returns {boolean}436     */437    isMapped4(): boolean;438    /**439     * If this address embeds a routable IPv4 address — i.e. it is IPv4-mapped440     * (`::ffff:0:0/96`) or sits in the NAT64 well-known prefix (`64:ff9b::/96`,441     * [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052)) — return that442     * embedded address as an {@link Address4}; otherwise return null.443     *444     * The special-property checks (`isLoopback`, `isLinkLocal`, `isMulticast`,445     * `isUnspecified`, `isPrivate`, `isCGNAT`, `isBroadcast`) call this first and446     * delegate to the embedded {@link Address4} when present, so a literal such as447     * `::ffff:127.0.0.1` is classified by what it actually reaches (loopback)448     * rather than by its IPv6 wrapper (which `getType()` reports as IPv4-mapped).449     * This matters wherever the checks back a trust-boundary decision (e.g. an450     * SSRF allow/deny filter): without normalization, `::ffff:10.0.0.1`,451     * `::ffff:169.254.169.254`, `64:ff9b::7f00:1`, etc. would all read as452     * non-internal.453     * @returns {Address4 | null}454     */455    embeddedIPv4(): Address4 | null;456    /**457     * Returns true if the address is a Teredo address, false otherwise458     * @returns {boolean}459     */460    isTeredo(): boolean;461    /**462     * Returns true if the address is a 6to4 address, false otherwise463     * @returns {boolean}464     */465    is6to4(): boolean;466    /**467     * Returns true if the address is a loopback address, false otherwise468     * @returns {boolean}469     */470    isLoopback(): boolean;471    /**472     * 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 equivalent of IPv4 [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private addresses.473     * @returns {boolean}474     */475    isULA(): boolean;476    /**477     * Returns true if the address is private, i.e. a Unique Local Address in478     * `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)) or an479     * IPv4-mapped / NAT64 address whose embedded IPv4 address is in one of the480     * [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private ranges481     * (e.g. `::ffff:10.0.0.1`). This is the IPv6 counterpart to482     * {@link Address4.isPrivate}; use it instead of {@link isULA} when you need to483     * catch mapped RFC 1918 addresses as well as native ULAs.484     * @returns {boolean}485     */486    isPrivate(): boolean;487    /**488     * Returns true if the address is an IPv4-mapped / NAT64 address whose embedded489     * IPv4 address is in the carrier-grade NAT range `100.64.0.0/10`490     * ([RFC 6598](https://datatracker.ietf.org/doc/html/rfc6598)), false491     * otherwise. There is no native IPv6 CGNAT range, so this only ever returns492     * true for an embedded IPv4 address (e.g. `::ffff:100.64.0.1`).493     * @returns {boolean}494     */495    isCGNAT(): boolean;496    /**497     * Returns true if the address is an IPv4-mapped / NAT64 address whose embedded498     * IPv4 address is the limited broadcast address `255.255.255.255`499     * ([RFC 919](https://datatracker.ietf.org/doc/html/rfc919)), false otherwise.500     * There is no IPv6 broadcast, so this only ever returns true for an embedded501     * IPv4 address (e.g. `::ffff:255.255.255.255`).502     * @returns {boolean}503     */504    isBroadcast(): boolean;505    /**506     * Returns true if the address is the unspecified address `::`.507     * @returns {boolean}508     */509    isUnspecified(): boolean;510    /**511     * Returns true if the address is in the documentation prefix `2001:db8::/32` ([RFC 3849](https://datatracker.ietf.org/doc/html/rfc3849)).512     * @returns {boolean}513     */514    isDocumentation(): boolean;515    /**516     * Returns the address as an HTTP URL with the host bracketed, e.g.517     * `http://[2001:db8::1]/`. If `optionalPort` is provided it is appended,518     * e.g. `http://[2001:db8::1]:8080/`.519     */520    href(optionalPort?: number | string): string;521    /**522     * Returns an HTML `<a>` element whose `href` encodes the address in a URL523     * hash fragment (default prefix `/#address=`). Useful for linking between524     * pages of an address-inspector UI.525     * @param options.className - CSS class for the rendered `<a>` element526     * @param options.prefix - hash prefix prepended to the address (default `/#address=`)527     * @param options.v4 - when true, render the address in v4-in-v6 form528     */529    link(options?: {530        className?: string;531        prefix?: string;532        v4?: boolean;533    }): string;534    /**535     * Groups an address536     * @returns {String}537     */538    group(): string;539    /**540     * Generate a regular expression string that can be used to find or validate541     * all variations of this address542     * @param {boolean} substringSearch543     * @returns {string}544     */545    regularExpressionString(this: Address6, substringSearch?: boolean): string;546    /**547     * Generate a regular expression that can be used to find or validate all548     * variations of this address.549     * @param {boolean} substringSearch550     * @returns {RegExp}551     */552    regularExpression(this: Address6, substringSearch?: boolean): RegExp;553}554export {};555