net.ipv6

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

/**
 * The eight 16-bit groups of an IPv6 address written as RFC 4291 section 2.2
 * allows: hex groups of one to four digits in either case, at most one "::"
 * standing for one or more zero groups, and optionally a dotted IPv4 address
 * as the last 32 bits. A zone id ("%eth0") or a prefix ("/64") is not part of
 * an address and is refused, as is anything around it (spaces, newlines).
 */
export function parseIpv6(text: string): readonly number[] {
  const groups = ipv6Groups(text);
  if (groups === null) throw new Error(`"${String(text)}" is not an IPv6 address`);
  return groups;
}

// Exported for isIpv6 and for capabilities that parse IPv6 text without
// wanting an error; not part of the group's contract.

/** The eight groups, or null when the text is not an IPv6 address. */
export function ipv6Groups(text: unknown): number[] | null {
  if (typeof text !== "string" || text.length === 0) return null;
  for (const ch of text) {
    const ok = (ch >= "0" && ch <= "9") || (ch >= "a" && ch <= "f") || (ch >= "A" && ch <= "F") || ch === ":" || ch === ".";
    if (!ok) return null;
  }
  const at = text.indexOf("::");
  if (at < 0) {
    const groups = pieces(text.split(":"), true);
    return groups !== null && groups.length === 8 ? groups : null;
  }
  const before = text.slice(0, at);
  const after = text.slice(at + 2);
  if (after.includes("::")) return null;
  const head = pieces(before === "" ? [] : before.split(":"), false);
  const tail = pieces(after === "" ? [] : after.split(":"), true);
  if (head === null || tail === null) return null;
  // "::" stands for at least one group, so at most seven are written.
  if (head.length + tail.length > 7) return null;
  const zeros = new Array<number>(8 - head.length - tail.length).fill(0);
  return [...head, ...zeros, ...tail];
}

/** Hex pieces to groups; a dotted IPv4 tail only as the very last piece. */
function pieces(parts: readonly string[], mayEndWithIpv4: boolean): number[] | null {
  const groups: number[] = [];
  for (let i = 0; i < parts.length; i++) {
    const part = parts[i];
    if (part.includes(".")) {
      if (!mayEndWithIpv4 || i !== parts.length - 1) return null;
      const v4 = ipv4Value(part);
      if (v4 === null) return null;
      groups.push(Math.floor(v4 / 65536), v4 % 65536);
      continue;
    }
    if (part.length < 1 || part.length > 4) return null;
    groups.push(parseInt(part, 16));
  }
  return groups;
}

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

/**
 * RFC 5952 canonical text for eight 16-bit groups: lower-case hex, no
 * leading zeros, the longest run of two or more zero groups written "::" (the
 * first on a tie, never a single group). An IPv4-mapped address
 * (::ffff:0:0/96) keeps its dotted-quad tail, as section 5 recommends.
 */
export function formatIpv6(groups: readonly number[]): string {
  if (!Array.isArray(groups) || groups.length !== 8) {
    throw new Error("IPv6 groups must be eight integers from 0 to 65535");
  }
  for (const g of groups) {
    if (typeof g !== "number" || !Number.isInteger(g) || g < 0 || g > 65535) {
      throw new Error("IPv6 groups must be eight integers from 0 to 65535");
    }
  }
  if (groups[0] === 0 && groups[1] === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 0xffff) {
    return "::ffff:" + formatIpv4(groups[6] * 65536 + groups[7]);
  }
  let bestStart = -1;
  let bestLength = 0;
  let i = 0;
  while (i < 8) {
    if (groups[i] !== 0) {
      i++;
      continue;
    }
    let j = i;
    while (j < 8 && groups[j] === 0) j++;
    // Strictly longer, so the first of two equal runs wins.
    if (j - i > bestLength) {
      bestStart = i;
      bestLength = j - i;
    }
    i = j;
  }
  const hex = groups.map((g) => g.toString(16));
  if (bestLength < 2) return hex.join(":");
  return hex.slice(0, bestStart).join(":") + "::" + hex.slice(bestStart + bestLength).join(":");
}

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

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

/** True exactly when parseIpv6 would accept the text; never throws. */
export function isIpv6(text: string): boolean {
  return ipv6Groups(text) !== null;
}