@itpay/cli 2.1.45 → 2.1.47

package/node_modules/ip-address/dist/common.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInSubnet = isInSubnet;
-exports.isHostInSubnet = isHostInSubnet;
-exports.isGloballyReachable = isGloballyReachable;
-exports.offsetBigInt = offsetBigInt;
-exports.isCorrect = isCorrect;
-exports.prefixLengthFromMask = prefixLengthFromMask;
-exports.assertByteArray = assertByteArray;
-exports.numberToPaddedHex = numberToPaddedHex;
-exports.stringToPaddedHex = stringToPaddedHex;
-exports.testBit = testBit;
-const address_error_1 = require("./address-error");
-/**
- * Returns whether this address's *network* is contained within `address`,
- * i.e. whether every address this one can represent also falls inside
- * `address`. A network wider than `address` is not contained in it, so
- * `10.0.0.0/8` is not in `10.0.0.0/16`.
- *
- * To ask whether the address itself falls inside a range, ignoring any CIDR
- * suffix it was written with, use {@link isHostInSubnet} instead. That is the
- * question the special-use classifiers ask.
- */
-function isInSubnet(address) {
-    if (this.subnetMask < address.subnetMask) {
-        return false;
-    }
-    return isHostInSubnet.call(this, address);
-}
-/**
- * Returns whether this address's host bits fall inside `address`, ignoring
- * this address's own subnet mask.
- *
- * This is the primitive the special-use classifiers (`isLoopback`,
- * `isPrivate`, `isLinkLocal`, `getType`, …) are built on: they answer a
- * question about the address, so the answer must not change with the CIDR
- * suffix the caller happened to write. Use this rather than
- * {@link isInSubnet} when classifying a single address — notably when the
- * address came from untrusted input and the result backs a trust-boundary
- * decision such as an SSRF allow/deny filter.
- */
-function isHostInSubnet(address) {
-    return this.mask(address.subnetMask) === address.mask();
-}
-/**
- * Returns whether the registry marks this address globally reachable: the
- * answer of the most specific entry containing it that has one, or `true`
- * when no entry contains it.
- */
-function isGloballyReachable(entries) {
-    let best = null;
-    for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        if (entry.reachable !== null &&
-            isHostInSubnet.call(this, entry.subnet) &&
-            (best === null || entry.subnet.subnetMask > best.subnet.subnetMask)) {
-            best = entry;
-        }
-    }
-    return best === null ? true : best.reachable;
-}
-/**
- * Adds `n` to `value` and returns the result, throwing `AddressError` unless
- * `n` is an integer and the result stays within `[0, 2**bits - 1]`.
- */
-function offsetBigInt(value, n, bits, family) {
-    if (typeof n === 'number' && !Number.isSafeInteger(n)) {
-        throw new address_error_1.AddressError(`${family} offset must be an integer`);
-    }
-    if (typeof n !== 'number' && typeof n !== 'bigint') {
-        throw new address_error_1.AddressError(`${family} offset must be an integer`);
-    }
-    const result = value + BigInt(n);
-    if (result < BigInt(0) || result > (BigInt(1) << BigInt(bits)) - BigInt(1)) {
-        throw new address_error_1.AddressError(`${family} offset leaves the address space`);
-    }
-    return result;
-}
-function isCorrect(defaultBits) {
-    return function isCorrectForm() {
-        if (this.addressMinusSuffix !== this.correctForm()) {
-            return false;
-        }
-        if (this.subnetMask === defaultBits && !this.parsedSubnet) {
-            return true;
-        }
-        return this.parsedSubnet === String(this.subnetMask);
-    };
-}
-/**
- * Returns the prefix length (number of leading 1 bits) of a contiguous
- * subnet mask. Throws `AddressError` if the mask is non-contiguous (e.g.
- * `255.0.255.0`).
- */
-function prefixLengthFromMask(value, totalBits) {
-    const binary = value.toString(2).padStart(totalBits, '0');
-    if (binary.length > totalBits) {
-        throw new address_error_1.AddressError('Invalid subnet mask.');
-    }
-    const firstZero = binary.indexOf('0');
-    if (firstZero === -1) {
-        return totalBits;
-    }
-    if (binary.slice(firstZero).includes('1')) {
-        throw new address_error_1.AddressError('Invalid subnet mask.');
-    }
-    return firstZero;
-}
-/**
- * Throws `AddressError` unless `bytes` holds exactly `byteCount` integers,
- * each from `minimum` to 255. Pass a `minimum` of `-128` where signed bytes
- * are accepted and folded to unsigned, and `0` where they are not.
- */
-function assertByteArray(bytes, byteCount, family, minimum) {
-    if (bytes.length !== byteCount) {
-        throw new address_error_1.AddressError(`${family} addresses require exactly ${byteCount} bytes`);
-    }
-    for (let i = 0; i < bytes.length; i++) {
-        if (!Number.isInteger(bytes[i]) || bytes[i] < minimum || bytes[i] > 255) {
-            throw new address_error_1.AddressError(`All bytes must be integers between ${minimum} and 255`);
-        }
-    }
-}
-function numberToPaddedHex(number) {
-    return number.toString(16).padStart(2, '0');
-}
-function stringToPaddedHex(numberString) {
-    return numberToPaddedHex(parseInt(numberString, 10));
-}
-/**
- * @param binaryValue Binary representation of a value (e.g. `10`)
- * @param position Byte position, where 0 is the least significant bit
- */
-function testBit(binaryValue, position) {
-    const { length } = binaryValue;
-    if (position > length) {
-        return false;
-    }
-    const positionInString = length - position;
-    return binaryValue.substring(positionInString, positionInString + 1) === '1';
-}
-//# sourceMappingURL=common.js.map

package/node_modules/ip-address/dist/common.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"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","sourcesContent":["import { Address4 } from './ipv4';\nimport { Address6 } from './ipv6';\nimport { AddressError } from './address-error';\n\nexport interface ReverseFormOptions {\n  omitSuffix?: boolean;\n}\n\n/**\n * Returns whether this address's *network* is contained within `address`,\n * i.e. whether every address this one can represent also falls inside\n * `address`. A network wider than `address` is not contained in it, so\n * `10.0.0.0/8` is not in `10.0.0.0/16`.\n *\n * To ask whether the address itself falls inside a range, ignoring any CIDR\n * suffix it was written with, use {@link isHostInSubnet} instead. That is the\n * question the special-use classifiers ask.\n */\nexport function isInSubnet(this: Address4 | Address6, address: Address4 | Address6) {\n  if (this.subnetMask < address.subnetMask) {\n    return false;\n  }\n\n  return isHostInSubnet.call(this, address);\n}\n\n/**\n * Returns whether this address's host bits fall inside `address`, ignoring\n * this address's own subnet mask.\n *\n * This is the primitive the special-use classifiers (`isLoopback`,\n * `isPrivate`, `isLinkLocal`, `getType`, …) are built on: they answer a\n * question about the address, so the answer must not change with the CIDR\n * suffix the caller happened to write. Use this rather than\n * {@link isInSubnet} when classifying a single address — notably when the\n * address came from untrusted input and the result backs a trust-boundary\n * decision such as an SSRF allow/deny filter.\n */\nexport function isHostInSubnet(this: Address4 | Address6, address: Address4 | Address6) {\n  return this.mask(address.subnetMask) === address.mask();\n}\n\n/**\n * One parsed row of an IANA special-purpose address registry: the block, and\n * whether the registry marks it globally reachable (`null` when the column is\n * blank, in which case the containing block answers).\n */\nexport interface SpecialPurposeEntry<A extends Address4 | Address6> {\n  subnet: A;\n  reachable: boolean | null;\n}\n\n/**\n * Returns whether the registry marks this address globally reachable: the\n * answer of the most specific entry containing it that has one, or `true`\n * when no entry contains it.\n */\nexport function isGloballyReachable<A extends Address4 | Address6>(\n  this: A,\n  entries: ReadonlyArray<SpecialPurposeEntry<A>>,\n): boolean {\n  let best: SpecialPurposeEntry<A> | null = null;\n\n  for (let i = 0; i < entries.length; i++) {\n    const entry = entries[i];\n\n    if (\n      entry.reachable !== null &&\n      isHostInSubnet.call(this, entry.subnet) &&\n      (best === null || entry.subnet.subnetMask > best.subnet.subnetMask)\n    ) {\n      best = entry;\n    }\n  }\n\n  return best === null ? true : (best.reachable as boolean);\n}\n\n/**\n * Adds `n` to `value` and returns the result, throwing `AddressError` unless\n * `n` is an integer and the result stays within `[0, 2**bits - 1]`.\n */\nexport function offsetBigInt(\n  value: bigint,\n  n: number | bigint,\n  bits: number,\n  family: string,\n): bigint {\n  if (typeof n === 'number' && !Number.isSafeInteger(n)) {\n    throw new AddressError(`${family} offset must be an integer`);\n  }\n\n  if (typeof n !== 'number' && typeof n !== 'bigint') {\n    throw new AddressError(`${family} offset must be an integer`);\n  }\n\n  const result = value + BigInt(n);\n\n  if (result < BigInt(0) || result > (BigInt(1) << BigInt(bits)) - BigInt(1)) {\n    throw new AddressError(`${family} offset leaves the address space`);\n  }\n\n  return result;\n}\n\nexport function isCorrect(defaultBits: number) {\n  return function isCorrectForm(this: Address4 | Address6) {\n    if (this.addressMinusSuffix !== this.correctForm()) {\n      return false;\n    }\n\n    if (this.subnetMask === defaultBits && !this.parsedSubnet) {\n      return true;\n    }\n\n    return this.parsedSubnet === String(this.subnetMask);\n  };\n}\n\n/**\n * Returns the prefix length (number of leading 1 bits) of a contiguous\n * subnet mask. Throws `AddressError` if the mask is non-contiguous (e.g.\n * `255.0.255.0`).\n */\nexport function prefixLengthFromMask(value: bigint, totalBits: number): number {\n  const binary = value.toString(2).padStart(totalBits, '0');\n\n  if (binary.length > totalBits) {\n    throw new AddressError('Invalid subnet mask.');\n  }\n\n  const firstZero = binary.indexOf('0');\n\n  if (firstZero === -1) {\n    return totalBits;\n  }\n\n  if (binary.slice(firstZero).includes('1')) {\n    throw new AddressError('Invalid subnet mask.');\n  }\n\n  return firstZero;\n}\n\n/**\n * Throws `AddressError` unless `bytes` holds exactly `byteCount` integers,\n * each from `minimum` to 255. Pass a `minimum` of `-128` where signed bytes\n * are accepted and folded to unsigned, and `0` where they are not.\n */\nexport function assertByteArray(\n  bytes: number[],\n  byteCount: number,\n  family: 'IPv4' | 'IPv6',\n  minimum: number,\n): void {\n  if (bytes.length !== byteCount) {\n    throw new AddressError(`${family} addresses require exactly ${byteCount} bytes`);\n  }\n\n  for (let i = 0; i < bytes.length; i++) {\n    if (!Number.isInteger(bytes[i]) || bytes[i] < minimum || bytes[i] > 255) {\n      throw new AddressError(`All bytes must be integers between ${minimum} and 255`);\n    }\n  }\n}\n\nexport function numberToPaddedHex(number: number) {\n  return number.toString(16).padStart(2, '0');\n}\n\nexport function stringToPaddedHex(numberString: string) {\n  return numberToPaddedHex(parseInt(numberString, 10));\n}\n\n/**\n * @param binaryValue Binary representation of a value (e.g. `10`)\n * @param position Byte position, where 0 is the least significant bit\n */\nexport function testBit(binaryValue: string, position: number): boolean {\n  const { length } = binaryValue;\n\n  if (position > length) {\n    return false;\n  }\n\n  const positionInString = length - position;\n  return binaryValue.substring(positionInString, positionInString + 1) === '1';\n}\n"]}

package/node_modules/ip-address/dist/ip-address.d.ts

@@ -1,7 +0,0 @@
-export { Address4 } from './ipv4';
-export { Address6 } from './ipv6';
-export { AddressError } from './address-error';
-import * as helpers from './v6/helpers';
-export declare const v6: {
-    helpers: typeof helpers;
-};

package/node_modules/ip-address/dist/ip-address.js

@@ -1,35 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.v6 = exports.AddressError = exports.Address6 = exports.Address4 = void 0;
-var ipv4_1 = require("./ipv4");
-Object.defineProperty(exports, "Address4", { enumerable: true, get: function () { return ipv4_1.Address4; } });
-var ipv6_1 = require("./ipv6");
-Object.defineProperty(exports, "Address6", { enumerable: true, get: function () { return ipv6_1.Address6; } });
-var address_error_1 = require("./address-error");
-Object.defineProperty(exports, "AddressError", { enumerable: true, get: function () { return address_error_1.AddressError; } });
-const helpers = __importStar(require("./v6/helpers"));
-exports.v6 = { helpers };
-//# sourceMappingURL=ip-address.js.map

package/node_modules/ip-address/dist/ip-address.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ip-address.js","sourceRoot":"","sources":["../src/ip-address.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAAkC;AAAzB,gGAAA,QAAQ,OAAA;AACjB,+BAAkC;AAAzB,gGAAA,QAAQ,OAAA;AACjB,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AAErB,sDAAwC;AAE3B,QAAA,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC","sourcesContent":["export { Address4 } from './ipv4';\nexport { Address6 } from './ipv6';\nexport { AddressError } from './address-error';\n\nimport * as helpers from './v6/helpers';\n\nexport const v6 = { helpers };\n"]}

package/node_modules/ip-address/dist/ipv4.d.ts

@@ -1,340 +0,0 @@
-import * as common from './common';
-/**
- * Represents an IPv4 address
- * @param {string} address - An IPv4 address string
- */
-export declare class Address4 {
-    address: string;
-    addressMinusSuffix: string;
-    groups: number;
-    parsedAddress: string[];
-    parsedSubnet: string;
-    subnet: string;
-    subnetMask: number;
-    v4: boolean;
-    private _binaryZeroPad?;
-    constructor(address: string);
-    /**
-     * Returns true if the given string is a valid IPv4 address (with optional
-     * CIDR subnet), false otherwise. Host bits in the subnet portion are
-     * allowed (e.g. `192.168.1.5/24` is valid); for strict network-address
-     * validation compare `correctForm()` to `startAddress().correctForm()`,
-     * or use `networkForm()`.
-     */
-    static isValid(address: string): boolean;
-    /**
-     * Parses an IPv4 address string into its four octet groups and stores the
-     * result on `this.parsedAddress`. Called automatically by the constructor;
-     * you typically don't need to call it directly. Throws `AddressError` if
-     * the input is not a valid IPv4 address.
-     */
-    parse(address: string): string[];
-    /**
-     * 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
-     * canonical dotted-decimal representation.
-     */
-    correctForm(): string;
-    /**
-     * Returns true if the address is correct, false otherwise
-     * @returns {Boolean}
-     */
-    isCorrect: (this: Address4 | import("./ipv6").Address6) => boolean;
-    /**
-     * Construct an `Address4` from an address and a dotted-decimal subnet
-     * mask given as separate strings (e.g. as returned by Node's
-     * `os.networkInterfaces()`). Throws `AddressError` if the mask is
-     * non-contiguous (e.g. `255.0.255.0`).
-     * @example
-     * var address = Address4.fromAddressAndMask('192.168.1.1', '255.255.255.0');
-     * address.subnetMask; // 24
-     */
-    static fromAddressAndMask(address: string, mask: string): Address4;
-    /**
-     * Construct an `Address4` from an address and a Cisco-style wildcard mask
-     * given as separate strings (e.g. `0.0.0.255` for a `/24`). The wildcard
-     * mask is the bitwise inverse of the subnet mask. Throws `AddressError`
-     * if the mask is non-contiguous (e.g. `0.255.0.255`).
-     * @example
-     * var address = Address4.fromAddressAndWildcardMask('10.0.0.1', '0.0.0.255');
-     * address.subnetMask; // 24
-     */
-    static fromAddressAndWildcardMask(address: string, wildcardMask: string): Address4;
-    /**
-     * Construct an `Address4` from a wildcard pattern with trailing `*`
-     * octets. The number of trailing wildcards determines the prefix
-     * length: each `*` represents 8 bits.
-     *
-     * Only trailing whole-octet wildcards are supported. Partial-octet
-     * wildcards (e.g. `192.168.0.1*`) and interior wildcards (e.g.
-     * `192.*.0.1`) throw `AddressError`.
-     * @example
-     * Address4.fromWildcard('192.168.0.*').subnet;   // '/24'
-     * Address4.fromWildcard('192.168.*.*').subnet;   // '/16'
-     * Address4.fromWildcard('*.*.*.*').subnet;       // '/0'
-     */
-    static fromWildcard(input: string): Address4;
-    /**
-     * Converts a hex string to an IPv4 address object. Accepts 8 hex digits
-     * with optional `:` separators (e.g. `'7f000001'` or `'7f:00:00:01'`).
-     * Throws `AddressError` for any other length or for non-hex characters.
-     * @param {string} hex - a hex string to convert
-     * @returns {Address4}
-     */
-    static fromHex(hex: string): Address4;
-    /**
-     * 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
-     * `AddressError` is thrown.
-     * @param {integer} integer - a number to convert
-     * @returns {Address4}
-     */
-    static fromInteger(integer: number): Address4;
-    /**
-     * Return an address from in-addr.arpa form
-     * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address
-     * @returns {Adress4}
-     * @example
-     * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.)
-     * address.correctForm(); // '192.0.2.42'
-     */
-    static fromArpa(arpaFormAddress: string): Address4;
-    /**
-     * Converts an IPv4 address object to a hex string
-     * @returns {String}
-     */
-    toHex(): string;
-    /**
-     * Converts an IPv4 address object to an array of bytes.
-     *
-     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toArray())`.
-     * @returns {Array}
-     */
-    toArray(): number[];
-    /**
-     * Converts an IPv4 address object to an IPv6 address group
-     * @returns {String}
-     */
-    toGroup6(): string;
-    /**
-     * Returns the address as a `bigint`
-     * @returns {bigint}
-     */
-    bigInt(): bigint;
-    /**
-     * Helper function getting start address.
-     * @returns {bigint}
-     */
-    _startAddress(): bigint;
-    /**
-     * The first address in the range given by this address' subnet.
-     * Often referred to as the Network Address.
-     * @returns {Address4}
-     */
-    startAddress(): Address4;
-    /**
-     * The first host address in the range given by this address's subnet ie
-     * the first address after the Network Address
-     * @returns {Address4}
-     */
-    startAddressExclusive(): Address4;
-    /**
-     * Returns the address `n` addresses after this one (or before, when `n` is
-     * negative), keeping this address's subnet mask. Throws `AddressError` when
-     * the result would fall outside the IPv4 address space or `n` is not an
-     * integer.
-     * @param {number | bigint} n
-     * @returns {Address4}
-     * @example
-     * new Address4('10.0.0.0/24').offset(1).correctForm(); // '10.0.0.1'
-     */
-    offset(n: number | bigint): Address4;
-    /**
-     * Returns the network that follows this address's network: the address after
-     * {@link endAddress}, with the same subnet mask. Throws `AddressError` when
-     * this network is the last one in the address space.
-     * @returns {Address4}
-     * @example
-     * new Address4('10.0.0.0/24').nextNetwork().networkForm(); // '10.0.1.0/24'
-     */
-    nextNetwork(): Address4;
-    private withSubnetMask;
-    /**
-     * Helper function getting end address.
-     * @returns {bigint}
-     */
-    _endAddress(): bigint;
-    /**
-     * The last address in the range given by this address' subnet
-     * Often referred to as the Broadcast
-     * @returns {Address4}
-     */
-    endAddress(): Address4;
-    /**
-     * The last host address in the range given by this address's subnet ie
-     * the last address prior to the Broadcast Address
-     * @returns {Address4}
-     */
-    endAddressExclusive(): Address4;
-    /**
-     * The dotted-decimal form of the subnet mask, e.g. `255.255.240.0` for
-     * a `/20`. Returns an `Address4`; call `.correctForm()` for the string.
-     * @returns {Address4}
-     */
-    subnetMaskAddress(): Address4;
-    /**
-     * The Cisco-style wildcard mask, e.g. `0.0.0.255` for a `/24`. This is
-     * the bitwise inverse of `subnetMaskAddress()`. Returns an `Address4`;
-     * call `.correctForm()` for the string.
-     * @returns {Address4}
-     */
-    wildcardMask(): Address4;
-    /**
-     * The network address in CIDR string form, e.g. `192.168.1.0/24` for
-     * `192.168.1.5/24`. For an address with no explicit subnet the prefix is
-     * `/32`, e.g. `networkForm()` on `192.168.1.5` returns `192.168.1.5/32`.
-     * @returns {string}
-     */
-    networkForm(): string;
-    /**
-     * Converts a BigInt to a v4 address object. The value must be in the
-     * range `[0, 2**32 - 1]`; otherwise `AddressError` is thrown.
-     * @param {bigint} bigInt - a BigInt to convert
-     * @returns {Address4}
-     */
-    static fromBigInt(bigInt: bigint): Address4;
-    /**
-     * Convert a byte array to an Address4 object. Throws `AddressError` unless
-     * given exactly 4 integers from 0 to 255. Signed bytes are rejected, so
-     * this differs from `Address6.fromByteArray`, which folds them; the two
-     * contracts converge on this stricter form in the next major version.
-     *
-     * To convert from a Node.js `Buffer`, spread it: `Address4.fromByteArray([...buf])`.
-     * @param {Array<number>} bytes - an array of 4 bytes (0-255)
-     * @returns {Address4}
-     */
-    static fromByteArray(bytes: Array<number>): Address4;
-    /**
-     * Convert an unsigned byte array to an Address4 object. Throws
-     * `AddressError` unless given exactly 4 bytes, and rejects values outside
-     * 0 to 255 when parsing the resulting address.
-     *
-     * To convert from a Node.js `Buffer`, spread it:
-     * `Address4.fromUnsignedByteArray([...buf])`.
-     * @param {Array<number>} bytes - an array of 4 unsigned bytes (0-255)
-     * @returns {Address4}
-     */
-    static fromUnsignedByteArray(bytes: Array<number>): Address4;
-    /**
-     * Returns the first n bits of the address, defaulting to the
-     * subnet mask
-     * @returns {String}
-     */
-    mask(mask?: number): string;
-    /**
-     * Returns the bits in the given range as a base-2 string
-     * @returns {string}
-     */
-    getBitsBase2(start: number, end: number): string;
-    /**
-     * Return the reversed in-addr.arpa form of the address, e.g.
-     * `42.2.0.192.in-addr.arpa.` for `192.0.2.42`.
-     * @param {Object} options
-     * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix
-     * @returns {String}
-     */
-    reverseForm(options?: common.ReverseFormOptions): string;
-    /**
-     * Returns true if the given address is in the subnet of the current address
-     * @returns {boolean}
-     */
-    isInSubnet: typeof common.isInSubnet;
-    /**
-     * Returns true if this address's host bits fall inside the given subnet,
-     * ignoring this address's own subnet mask. Prefer this over `isInSubnet`
-     * when classifying a single address, so the answer doesn't change with the
-     * CIDR suffix the caller happened to write — notably when the address came
-     * from untrusted input and the result backs a trust-boundary decision.
-     * @returns {boolean}
-     */
-    isHostInSubnet: typeof common.isHostInSubnet;
-    /**
-     * Returns true if the given address is a multicast address
-     * @returns {boolean}
-     */
-    isMulticast(): boolean;
-    /**
-     * Returns true if the address is in one of the [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private address ranges (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`).
-     * @returns {boolean}
-     */
-    isPrivate(): boolean;
-    /**
-     * Returns true if the address is in the loopback range `127.0.0.0/8` ([RFC 1122](https://datatracker.ietf.org/doc/html/rfc1122)).
-     * @returns {boolean}
-     */
-    isLoopback(): boolean;
-    /**
-     * Returns true if the address is in the link-local range `169.254.0.0/16` ([RFC 3927](https://datatracker.ietf.org/doc/html/rfc3927)).
-     * @returns {boolean}
-     */
-    isLinkLocal(): boolean;
-    /**
-     * Returns true if the address is the unspecified address `0.0.0.0`.
-     * @returns {boolean}
-     */
-    isUnspecified(): boolean;
-    /**
-     * Returns true if the address is the limited broadcast address `255.255.255.255` ([RFC 919](https://datatracker.ietf.org/doc/html/rfc919)).
-     * @returns {boolean}
-     */
-    isBroadcast(): boolean;
-    /**
-     * Returns true if the address is in the carrier-grade NAT range `100.64.0.0/10` ([RFC 6598](https://datatracker.ietf.org/doc/html/rfc6598)).
-     * @returns {boolean}
-     */
-    isCGNAT(): boolean;
-    /**
-     * Returns true if the address is in one of the documentation ranges
-     * `192.0.2.0/24`, `198.51.100.0/24`, or `203.0.113.0/24` ([RFC 5737](https://datatracker.ietf.org/doc/html/rfc5737)).
-     * @returns {boolean}
-     */
-    isDocumentation(): boolean;
-    /**
-     * Returns true if the address is in the benchmarking range `198.18.0.0/15` ([RFC 2544](https://datatracker.ietf.org/doc/html/rfc2544)).
-     * @returns {boolean}
-     */
-    isBenchmarking(): 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 the limited broadcast address.
-     * @returns {boolean}
-     */
-    isReserved(): boolean;
-    /**
-     * Returns true if the address is globally reachable: not multicast, and not
-     * in any block the [IANA IPv4 Special-Purpose Address Registry](https://www.iana.org/assignments/iana-ipv4-special-registry/)
-     * marks as not globally reachable. That covers everything the individual
-     * classifiers name (private, loopback, link-local, CGNAT, unspecified,
-     * broadcast, documentation, benchmarking, reserved) and the blocks they do
-     * not, such as `0.0.0.0/8` and the IETF protocol assignments in
-     * `192.0.0.0/24`. This is the single predicate to use where a request must
-     * not reach an internal or special-purpose destination; see SECURITY.md.
-     * @returns {boolean}
-     */
-    isGlobal(): boolean;
-    /**
-     * Returns a zero-padded base-2 string representation of the address
-     * @returns {string}
-     */
-    binaryZeroPad(): string;
-    /**
-     * 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
-     * `<span>` carrying the group classes an address-inspector UI hovers on.
-     * The address content is HTML-escaped; anything you concatenate around it
-     * is your responsibility.
-     * @returns {String}
-     */
-    groupForV6(): string;
-}