net.ip-classify

export function classifyIp(address: string): IpClassification

/** Which special-purpose block an address falls in, the most specific one. */
export interface IpClassification {
  /** canonical text */
  readonly address: string;
  /** 4 or 6 */
  readonly version: number;
  readonly category: IpCategory;
  /** the IANA registry's name for the block, or Global unicast */
  readonly name: string;
  /** the matching block, null for global */
  readonly block: string | null;
  /** the document that assigned it */
  readonly rfc: string | null;
  /** as the IANA registry says; null where it says N/A */
  readonly globallyReachable: boolean | null;
}

export type IpCategory = "unspecified" | "this-network" | "loopback" | "private" | "shared" | "link-local" | "multicast" | "documentation" | "benchmarking" | "reserved" | "broadcast" | "protocol" | "translation" | "ipv4-mapped" | "discard" | "global";

import { classifyIp } from "#fune/net.ip-classify@^1";

import { cidrContains } from "./net_cidr.ts";  ← from net.cidr ^1.0.0 · built alongside by fune
import { isIpv4 } from "./net_ipv4.ts";  ← from net.ipv4 ^1.0.0 · built alongside by fune
import { formatIpv6, isIpv6, parseIpv6 } from "./net_ipv6.ts";  ← from net.ipv6 ^1.0.0 · built alongside by fune
import { SPECIAL_BLOCKS } from "./net_ip_classify_data.ts";  ← this capability’s own data, compiled from data/special-purpose.json into the same file by fune build
import { type IpCategory, type IpClassification } from "./net_ip_classify_types.ts";

/**
 * Which special-purpose block an address is in, from the IANA IPv4 and IPv6
 * Special-Purpose Address Registries (RFC 6890) plus the multicast ranges.
 * The most specific block wins: 192.0.0.9 is Port Control Protocol Anycast
 * (globally reachable), not the /24 of IETF assignments around it (not).
 * An address in no block is "global".
 */
export function classifyIp(address: string): IpClassification {
  let version: number;
  let canonical: string;
  if (isIpv4(address)) {
    version = 4;
    canonical = address;
  } else if (isIpv6(address)) {
    version = 6;
    canonical = formatIpv6(parseIpv6(address));
  } else {
    throw new Error(`"${String(address)}" is not an IPv4 or IPv6 address`);
  }
  let best: (typeof SPECIAL_BLOCKS)[number] | null = null;
  let bestPrefix = -1;
  for (const row of SPECIAL_BLOCKS) {
    if (row.block.includes(":") !== (version === 6)) continue;
    if (!cidrContains(row.block, canonical)) continue;
    const prefix = Number(row.block.slice(row.block.indexOf("/") + 1));
    if (prefix > bestPrefix) {
      best = row;
      bestPrefix = prefix;
    }
  }
  if (best === null) {
    return { address: canonical, version, category: "global", name: "Global unicast", block: null, rfc: null, globallyReachable: true };
  }
  return {
    address: canonical,
    version,
    category: best.category as IpCategory,
    name: best.name,
    block: best.block,
    rfc: best.rfc,
    globallyReachable: best.globallyReachable,
  };
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and its 3 dependencies, pins them in fune.lock, downloads only the TypeScript package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add net.ip-classify

The manifest, vectors and README with only the TypeScript implementation. Install it without the registry with fune add ./net.ip-classify-1.0.0-typescript.fune, or fetch it from a terminal with fune pull net.ip-classify@1.0.0:typescript.

The whole function, every language, is one file too: net.ip-classify-1.0.0.fune, 28,917 bytes, sha256 597f539abc40a7ef8f254dd3c14b52974a0a93ad2d1d5931dc716c99f023dd92. It installs into a project of any language.

// fune: before net.ip-classify

// fune: after net.ip-classify

// fune: replace net.cidr in net.ip-classify
// fune: replace net.ipv4 in net.ip-classify
// fune: replace net.ipv6 in net.ip-classify

// fune: step net.ip-classify after <n|label>

More from the author

The rules are data (`data/special-purpose.json`), one row per block of the IANA special-purpose registries, with the registry's own name, RFC and "Globally Reachable" column. An address is matched against every block of its family and **the most specific (longest prefix) wins**, as the registry intends: `192.0.0.9` is Port Control Protocol Anycast (globally reachable), not the surrounding `192.0.0.0/24` IETF assignments (not reachable). An address in no block is `global`, name `Global unicast`, reachable.

`category` is this capability's grouping of the registry's names, so callers can branch on a closed set; `name`, `block` and `rfc` say exactly which row matched. `globallyReachable` is the registry's column, null where it says N/A (Teredo, 6to4, deprecated blocks) and for the multicast ranges, which the special-purpose registries do not list.

## Edge cases

- IPv6 is returned in RFC 5952 canonical form (`FE80::0001` gives `fe80::1`). - An IPv4-mapped address (`::ffff:192.168.1.1`) is `ipv4-mapped`; it is not classified as the IPv4 address inside it. Classify the IPv4 part yourself if that is what you mean. - `global` for IPv6 means "in no special-purpose block", which includes space IANA has not allocated yet. - Text follows `net.ipv4` / `net.ipv6` strictly: no leading zeros, zone ids or prefixes.

## Sources (checked 2026-09-26 against the registries' CSV exports)

- IANA IPv4 Special-Purpose Address Registry, https://www.iana.org/assignments/iana-ipv4-special-registry/ (RFC 6890, RFC 8190). All 25 rows, including 192.88.99.2/32 (6a44 relay) and the two NAT64/DNS64 discovery /32s listed as one row there. - IANA IPv6 Special-Purpose Address Registry, https://www.iana.org/assignments/iana-ipv6-special-registry/. All 26 rows, including 100:0:0:1::/64 (RFC 9780), 3fff::/20 (RFC 9637) and 5f00::/16 (RFC 9602). - IPv4 multicast 224.0.0.0/4: RFC 5771 (IANA Guidelines for IPv4 Multicast Address Assignments). IPv6 multicast ff00::/8: RFC 4291 section 2.7.

When the registry changes, publish a new version with the new rows.

Files