net.cidr

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { formatIpv4 } from "./net_ipv4_format_ipv4.ts";
import { cidrBlock } from "./net_cidr_is_cidr.ts";  ← isCidr, another function of this group · built into the same file, even by a slim install
import { type CidrInfo } from "./net_cidr_types.ts";

/**
 * Everything a subnet calculator shows for one IPv4 block. Host bits in the
 * input are dropped (192.168.1.77/24 describes 192.168.1.0/24), since that is
 * how an interface address is usually written. A /31 is a point-to-point link
 * with two usable addresses and no broadcast (RFC 3021); a /32 is one host.
 */
export function cidrInfo(cidr: string): CidrInfo {
  const block = cidrBlock(cidr);
  if (block === null) throw new Error(`"${String(cidr)}" is not a CIDR block`);
  if (block.version !== 4) throw new Error(`cidrInfo handles IPv4 blocks only, received "${cidr}"`);
  const prefix = block.prefix;
  const size = 2 ** (32 - prefix);
  // Arithmetic rather than bit masks: JavaScript's & is signed 32-bit.
  const network = block.bits[0] - (block.bits[0] % size);
  const last = network + size - 1;
  const pointToPoint = prefix >= 31;
  return {
    cidr: `${formatIpv4(network)}/${prefix}`,
    network: formatIpv4(network),
    prefix,
    netmask: formatIpv4(4294967296 - size),
    wildcard: formatIpv4(size - 1),
    broadcast: pointToPoint ? null : formatIpv4(last),
    firstHost: formatIpv4(pointToPoint ? network : network + 1),
    lastHost: formatIpv4(pointToPoint ? last : last - 1),
    hostCount: pointToPoint ? size : size - 2,
    addressCount: size,
  };
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { ipv4Value } from "./net_ipv4_parse_ipv4.ts";
import { ipv6Groups } from "./net_ipv6_parse_ipv6.ts";
import { cidrBlock } from "./net_cidr_is_cidr.ts";  ← isCidr, another function of this group · built into the same file, even by a slim install

/**
 * Whether an address lies inside a block, IPv4 or IPv6. An address of the
 * other family is never inside (an IPv4-mapped IPv6 address is not treated
 * as its IPv4 address; map it yourself if you mean that).
 */
export function cidrContains(cidr: string, address: string): boolean {
  const block = cidrBlock(cidr);
  if (block === null) throw new Error(`"${String(cidr)}" is not a CIDR block`);
  const v4 = ipv4Value(address);
  const v6 = v4 === null ? ipv6Groups(address) : null;
  if (v4 === null && v6 === null) throw new Error(`"${String(address)}" is not an IP address`);
  if (block.version === 4) {
    if (v4 === null) return false;
    const size = 2 ** (32 - block.prefix);
    return Math.floor(v4 / size) === Math.floor(block.bits[0] / size);
  }
  if (v6 === null) return false;
  for (let i = 0; i < 8; i++) {
    const bits = Math.max(0, Math.min(16, block.prefix - 16 * i));
    const size = 2 ** (16 - bits);
    if (Math.floor(v6[i] / size) !== Math.floor(block.bits[i] / size)) return false;
  }
  return true;
}

import { ipv4Value } from "./net_ipv4_parse_ipv4.ts";
import { ipv6Groups } from "./net_ipv6_parse_ipv6.ts";

/** True for a well-formed IPv4 (prefix 0-32) or IPv6 (prefix 0-128) block; never throws. */
export function isCidr(text: string): boolean {
  return cidrBlock(text) !== null;
}

// Exported for the other functions of this group; not part of its contract.

/** A parsed block: version 4 with bits [address], or version 6 with the eight groups. */
export interface CidrBlock {
  version: number;
  bits: number[];
  prefix: number;
}

/** The block, or null when the text is not address/prefix with a strict decimal prefix. */
export function cidrBlock(text: unknown): CidrBlock | null {
  if (typeof text !== "string") return null;
  const slash = text.indexOf("/");
  if (slash < 0 || text.indexOf("/", slash + 1) >= 0) return null;
  const address = text.slice(0, slash);
  const digits = text.slice(slash + 1);
  if (digits.length < 1 || digits.length > 3) return null;
  for (const ch of digits) if (ch < "0" || ch > "9") return null;
  if (digits.length > 1 && digits[0] === "0") return null;
  const prefix = Number(digits);
  const v4 = ipv4Value(address);
  if (v4 !== null) return prefix <= 32 ? { version: 4, bits: [v4], prefix } : null;
  const v6 = ipv6Groups(address);
  if (v6 !== null) return prefix <= 128 ? { version: 6, bits: v6, prefix } : null;
  return null;
}

import { formatIpv4 } from "./net_ipv4_format_ipv4.ts";

/** The dotted-quad mask for a prefix length: 24 is 255.255.255.0. */
export function prefixToNetmask(prefix: number): string {
  if (typeof prefix !== "number" || !Number.isInteger(prefix) || prefix < 0 || prefix > 32) {
    throw new Error(`prefix must be an integer from 0 to 32, received ${prefix}`);
  }
  return formatIpv4(4294967296 - 2 ** (32 - prefix));
}

import { parseIpv4 } from "./net_ipv4_parse_ipv4.ts";

/** The prefix length of a dotted-quad mask; a mask with a gap in its one bits is refused. */
export function netmaskToPrefix(netmask: string): number {
  const value = parseIpv4(netmask);
  const hostPart = 4294967295 - value + 1;
  for (let prefix = 0; prefix <= 32; prefix++) {
    if (2 ** (32 - prefix) === hostPart) return prefix;
  }
  throw new Error(`"${netmask}" is not a contiguous netmask`);
}