ip-utilities 1.0.0

package/dist/internal/ipv6-ranges.js

@@ -0,0 +1,159 @@
+const _V6_W0 = [0x00000000, 0x00000000, 0x0064FF9B, 0x00000000, 0x00000000, 0x01000000, 0x20010004, 0x2620004F, 0x20010002, 0x20010DB8, 0x20010003, 0x20010000, 0x20010010, 0x20010020, 0x20010030, 0x20010000, 0x20020000, 0xFE800000, 0xFF000000, 0xFC000000];
+const _V6_W1 = [0, 0, 0, 0, 0, 0, 0x01120000, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+const _V6_W2 = [0, 0, 0, 0x0000FFFF, 0xFFFF0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+const _V6_W3 = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+const _V6_PREFIX = [128, 128, 96, 96, 96, 64, 48, 48, 48, 32, 32, 32, 28, 28, 28, 23, 16, 10, 8, 7];
+const _V6_NAMES = [
+    'loopback', 'unspecified', 'rfc6052', 'ipv4Mapped', 'rfc6145',
+    'discard', 'as112v6', 'as112v6', 'benchmarking', 'reserved',
+    'amt', 'teredo', 'deprecated', 'orchid2', 'droneRemoteIdProtocolEntityTags',
+    'reserved', '6to4', 'linkLocal', 'multicast', 'uniqueLocal',
+];
+// Pre-masked range tables: masks and expected values for each of the 4 uint32 words
+const V6_COUNT = _V6_W0.length;
+const V6R_MW0 = new Uint32Array(V6_COUNT);
+const V6R_MW1 = new Uint32Array(V6_COUNT);
+const V6R_MW2 = new Uint32Array(V6_COUNT);
+const V6R_MW3 = new Uint32Array(V6_COUNT);
+const V6R_KM0 = new Uint32Array(V6_COUNT);
+const V6R_KM1 = new Uint32Array(V6_COUNT);
+const V6R_KM2 = new Uint32Array(V6_COUNT);
+const V6R_KM3 = new Uint32Array(V6_COUNT);
+const V6R_NAMES = new Array(V6_COUNT);
+for (let i = 0; i < V6_COUNT; i++) {
+    const p = _V6_PREFIX[i];
+    const m0 = prefixMaskV6(p, 0);
+    const m1 = prefixMaskV6(p, 1);
+    const m2 = prefixMaskV6(p, 2);
+    const m3 = prefixMaskV6(p, 3);
+    V6R_MW0[i] = (_V6_W0[i] & m0) >>> 0;
+    V6R_MW1[i] = (_V6_W1[i] & m1) >>> 0;
+    V6R_MW2[i] = (_V6_W2[i] & m2) >>> 0;
+    V6R_MW3[i] = (_V6_W3[i] & m3) >>> 0;
+    V6R_KM0[i] = m0;
+    V6R_KM1[i] = m1;
+    V6R_KM2[i] = m2;
+    V6R_KM3[i] = m3;
+    V6R_NAMES[i] = _V6_NAMES[i];
+}
+/**
+ * Tests whether an IPv6 address matches a CIDR prefix using raw uint32 words.
+ * @param aw0 - Address word 0 (bits 0-31)
+ * @param aw1 - Address word 1 (bits 32-63)
+ * @param aw2 - Address word 2 (bits 64-95)
+ * @param aw3 - Address word 3 (bits 96-127)
+ * @param nw0 - Network word 0
+ * @param nw1 - Network word 1
+ * @param nw2 - Network word 2
+ * @param nw3 - Network word 3
+ * @param prefix - Prefix length (0-128)
+ * @returns True if the address is within the network prefix
+ */
+export function matchesCidr(aw0, aw1, aw2, aw3, nw0, nw1, nw2, nw3, prefix) {
+    if (prefix === 0)
+        return true;
+    if (prefix <= 32) {
+        const mask = (0xFFFFFFFF << (32 - prefix)) >>> 0;
+        return (aw0 & mask) === (nw0 & mask);
+    }
+    if (aw0 !== nw0)
+        return false;
+    if (prefix <= 64) {
+        if (prefix === 32)
+            return true;
+        const mask = (0xFFFFFFFF << (64 - prefix)) >>> 0;
+        return (aw1 & mask) === (nw1 & mask);
+    }
+    if (aw1 !== nw1)
+        return false;
+    if (prefix <= 96) {
+        if (prefix === 64)
+            return true;
+        const mask = (0xFFFFFFFF << (96 - prefix)) >>> 0;
+        return (aw2 & mask) === (nw2 & mask);
+    }
+    if (aw2 !== nw2)
+        return false;
+    if (prefix === 128)
+        return aw3 === nw3;
+    const mask = (0xFFFFFFFF << (128 - prefix)) >>> 0;
+    return (aw3 & mask) === (nw3 & mask);
+}
+/**
+ * Computes the bitmask for a specific 32-bit word of an IPv6 prefix.
+ * @param prefix - Prefix length (0-128)
+ * @param wordOffset - Which 32-bit word (0-3)
+ * @returns The uint32 mask for that word
+ */
+export function prefixMaskV6(prefix, wordOffset) {
+    const lo = wordOffset * 32;
+    const hi = lo + 32;
+    if (prefix >= hi)
+        return 0xFFFFFFFF;
+    if (prefix <= lo)
+        return 0;
+    return (0xFFFFFFFF << (hi - prefix)) >>> 0;
+}
+/**
+ * Classifies an IPv6 address into its IANA-assigned range.
+ * @param addr - The IPv6 address
+ * @returns The range name (e.g. "uniqueLocal", "loopback", "unicast")
+ */
+export function ipv6Range(addr) {
+    const w0 = addr.w0;
+    const top3 = w0 >>> 29;
+    if (top3 === 1) {
+        const top16 = w0 >>> 16;
+        if (top16 !== 0x2001 && top16 !== 0x2002 && top16 !== 0x2620)
+            return 'unicast';
+    }
+    else if ((top3 - 2) >>> 0 <= 3) {
+        return 'unicast';
+    }
+    const w1 = addr.w1, w2 = addr.w2, w3 = addr.w3;
+    for (let i = 0; i < V6_COUNT; i++) {
+        if (((w0 & V6R_KM0[i]) >>> 0) !== V6R_MW0[i])
+            continue;
+        if (((w1 & V6R_KM1[i]) >>> 0) !== V6R_MW1[i])
+            continue;
+        if (((w2 & V6R_KM2[i]) >>> 0) !== V6R_MW2[i])
+            continue;
+        if (((w3 & V6R_KM3[i]) >>> 0) !== V6R_MW3[i])
+            continue;
+        return V6R_NAMES[i];
+    }
+    return 'unicast';
+}
+/**
+ * Checks whether an IPv6 address is private (unique-local, multicast, link-local, or loopback).
+ * @param addr - The IPv6 address
+ * @returns True if the address is non-globally-routable
+ */
+export function isPrivateIPv6(addr) {
+    const w0 = addr.w0;
+    if ((w0 >>> 25) === 0x7E)
+        return true;
+    if ((w0 >>> 24) === 0xFF)
+        return true;
+    if ((w0 >>> 22) === 0x3FA)
+        return true;
+    if (w0 === 0 && addr.w1 === 0 && addr.w2 === 0 && addr.w3 === 1)
+        return true;
+    return false;
+}
+/**
+ * Checks whether an IPv6 address is the loopback address (::1).
+ * @param addr - The IPv6 address
+ * @returns True if the address is ::1
+ */
+export function isLoopbackIPv6(addr) {
+    return addr.w0 === 0 && addr.w1 === 0 && addr.w2 === 0 && addr.w3 === 1;
+}
+/**
+ * Checks whether an IPv6 address is link-local (fe80::/10).
+ * @param addr - The IPv6 address
+ * @returns True if the address is in the link-local range
+ */
+export function isLinkLocalIPv6(addr) {
+    return (addr.w0 >>> 22) === 0x3FA;
+}

package/dist/internal/ipv6.d.ts

@@ -0,0 +1,67 @@
+import type { IPv6Addr } from '../types.ts';
+export declare const ipv6RawBuf: Uint32Array<ArrayBuffer>;
+/**
+ * Retrieves the zone ID (e.g. "eth0") associated with a parsed IPv6 address.
+ * @param addr - The IPv6 address
+ * @returns The zone ID string, or empty string if none
+ */
+export declare function ipv6GetZoneId(addr: IPv6Addr): string;
+/**
+ * Parses an IPv6 string into raw uint32 words written to {@link ipv6RawBuf}.
+ * @param s - Source string
+ * @param end - End index (exclusive) within the string
+ * @returns True if valid, with results in ipv6RawBuf[0..3]
+ */
+export declare function parseIPv6Raw(s: string, end: number): boolean;
+/**
+ * Parses an IPv6 string into an IPv6Addr. Supports :: compression,
+ * embedded IPv4 suffixes, and zone IDs (e.g. "fe80::1%eth0").
+ * @param s - The IPv6 string
+ * @param end - Optional end index for parsing a substring
+ * @returns The parsed address, or null if invalid
+ */
+export declare function parseIPv6(s: string, end?: number): IPv6Addr | null;
+/**
+ * Checks whether a string is a valid IPv6 address.
+ * @param s - The string to validate
+ * @returns True if the string is a valid IPv6 address
+ */
+export declare function isIPv6(s: string): boolean;
+/**
+ * Checks whether an IPv6 address is an IPv4-mapped address (::ffff:0:0/96).
+ * @param addr - The IPv6 address
+ * @returns True if the address is IPv4-mapped
+ */
+export declare function isIPv4Mapped(addr: IPv6Addr): boolean;
+/**
+ * Expands an IPv6 address into eight 16-bit words.
+ * @param addr - The IPv6 address
+ * @returns Tuple of eight 16-bit group values
+ */
+export declare function ipv6ToWords(addr: IPv6Addr): [number, number, number, number, number, number, number, number];
+/**
+ * Converts an IPv6 address to zero-padded colon notation (e.g. "0000:0000:...:0001").
+ * @param addr - The IPv6 address
+ * @returns The zero-padded string representation
+ */
+export declare function ipv6ToFixedString(addr: IPv6Addr): string;
+/**
+ * Converts an IPv6 address to uncompressed colon notation without zero-padding (e.g. "0:0:...:1").
+ * @param addr - The IPv6 address
+ * @returns The uncompressed string representation
+ */
+export declare function ipv6ToNormalizedString(addr: IPv6Addr): string;
+/**
+ * Converts an IPv6 address to its shortest RFC 5952 representation
+ * with :: compression for the longest zero-group run.
+ * @param addr - The IPv6 address
+ * @returns The compressed string (e.g. "::1", "fe80::1%eth0")
+ */
+export declare function ipv6ToString(addr: IPv6Addr): string;
+/**
+ * Extracts the embedded IPv4 address from the lower 32 bits of an IPv6 address.
+ * @param addr - The IPv6 address (typically an IPv4-mapped or IPv4-compatible address)
+ * @returns The packed uint32 IPv4 address
+ */
+export declare function ipv6ToIPv4(addr: IPv6Addr): number;
+//# sourceMappingURL=ipv6.d.ts.map

package/dist/internal/ipv6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipv6.d.ts","sourceRoot":"","sources":["../../src/internal/ipv6.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAoC3C,eAAO,MAAM,UAAU,0BAAqB,CAAA;AAgC5C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAuG5D;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAElE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAO5G;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAExD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CA4CnD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAEjD"}

package/dist/internal/ipv6.js

@@ -0,0 +1,385 @@
+import { parseIPv4Raw } from "./ipv4.js";
+// --- Constants & lookup tables ---
+// Hex digit lookup: maps charCode to nibble value (0-15), or 0xFF for non-hex
+const HEX = new Uint8Array(256);
+HEX.fill(0xFF);
+for (let i = 0; i < 10; i++)
+    HEX[0x30 + i] = i;
+for (let i = 0; i < 6; i++) {
+    HEX[0x41 + i] = 10 + i;
+    HEX[0x61 + i] = 10 + i;
+}
+// Hex string tables for all 16-bit values, used by toString functions
+const HEX4_CACHE = new Array(65536);
+for (let i = 0; i < 65536; i++)
+    HEX4_CACHE[i] = i.toString(16);
+const HEX4_COLON = new Array(65536);
+for (let i = 0; i < 65536; i++)
+    HEX4_COLON[i] = HEX4_CACHE[i] + ':';
+const HEX4PAD_CACHE = new Array(65536);
+for (let i = 0; i < 65536; i++)
+    HEX4PAD_CACHE[i] = i.toString(16).padStart(4, '0');
+const HEX4PAD_COLON = new Array(65536);
+for (let i = 0; i < 65536; i++)
+    HEX4PAD_COLON[i] = HEX4PAD_CACHE[i] + ':';
+// --- Mutable state ---
+// Zone IDs stored separately to keep IPv6Addr object property count minimal
+const _zoneIds = new WeakMap();
+// Scratch buffer for group accumulation during parsing
+const _parts = new Uint16Array(8);
+// Scratch buffer for toString compression path
+const _toStrParts = new Uint16Array(8);
+// Shared parse result buffer written by parseIPv6Raw: [w0, w1, w2, w3]
+export const ipv6RawBuf = new Uint32Array(4);
+let _rawZS = -1;
+let _rawEnd = 0;
+// --- Non-exported helpers ---
+function _parseIPv6(s, end) {
+    if (!parseIPv6Raw(s, end))
+        return null;
+    const addr = {
+        w0: ipv6RawBuf[0],
+        w1: ipv6RawBuf[1],
+        w2: ipv6RawBuf[2],
+        w3: ipv6RawBuf[3],
+        kind: 6,
+    };
+    if (_rawZS !== -1)
+        _zoneIds.set(addr, s.slice(_rawZS, _rawEnd));
+    return addr;
+}
+function _ipv6FullStr(addr, colonLut, lastLut) {
+    const w0 = addr.w0, w1 = addr.w1, w2 = addr.w2, w3 = addr.w3;
+    let s = colonLut[(w0 >>> 16) & 0xFFFF] + colonLut[w0 & 0xFFFF] +
+        colonLut[(w1 >>> 16) & 0xFFFF] + colonLut[w1 & 0xFFFF] +
+        colonLut[(w2 >>> 16) & 0xFFFF] + colonLut[w2 & 0xFFFF] +
+        colonLut[(w3 >>> 16) & 0xFFFF] + lastLut[w3 & 0xFFFF];
+    const z = _zoneIds.get(addr);
+    if (z)
+        s += '%' + z;
+    return s;
+}
+// --- Exports ---
+/**
+ * Retrieves the zone ID (e.g. "eth0") associated with a parsed IPv6 address.
+ * @param addr - The IPv6 address
+ * @returns The zone ID string, or empty string if none
+ */
+export function ipv6GetZoneId(addr) {
+    return _zoneIds.get(addr) ?? '';
+}
+/**
+ * Parses an IPv6 string into raw uint32 words written to {@link ipv6RawBuf}.
+ * @param s - Source string
+ * @param end - End index (exclusive) within the string
+ * @returns True if valid, with results in ipv6RawBuf[0..3]
+ */
+export function parseIPv6Raw(s, end) {
+    if (end < 2 || end > 70)
+        return false;
+    let zoneStart = -1;
+    let bodyEnd = end;
+    for (let i = end - 1; i >= 0; i--) {
+        const ch = s.charCodeAt(i);
+        if (ch === 37) {
+            if (i === end - 1)
+                return false;
+            zoneStart = i + 1;
+            bodyEnd = i;
+            break;
+        }
+        if (ch === 58)
+            break;
+    }
+    const c0 = s.charCodeAt(0);
+    if (c0 === 58) {
+        if (bodyEnd < 2 || s.charCodeAt(1) !== 58)
+            return false;
+    }
+    const parts = _parts;
+    let pIdx = 0;
+    let dcPart = -1;
+    let pos = 0;
+    if (c0 === 58) {
+        pos = 2;
+        dcPart = 0;
+    }
+    let gVal = 0;
+    let gLen = 0;
+    while (pos < bodyEnd) {
+        const ch = s.charCodeAt(pos);
+        if (ch === 58) {
+            if (gLen > 0) {
+                if (pIdx >= 8)
+                    return false;
+                parts[pIdx++] = gVal;
+                gVal = 0;
+                gLen = 0;
+                if (pos + 1 < bodyEnd && s.charCodeAt(pos + 1) === 58) {
+                    if (dcPart !== -1)
+                        return false;
+                    dcPart = pIdx;
+                    pos += 2;
+                    continue;
+                }
+            }
+            else {
+                return false;
+            }
+            pos++;
+            continue;
+        }
+        if (ch === 46) {
+            const v4Start = pos - gLen;
+            const packed = parseIPv4Raw(s, v4Start, bodyEnd);
+            if (packed === -1)
+                return false;
+            if (pIdx >= 7)
+                return false;
+            parts[pIdx++] = (packed >>> 16) & 0xFFFF;
+            parts[pIdx++] = packed & 0xFFFF;
+            gVal = 0;
+            gLen = 0;
+            pos = bodyEnd;
+            continue;
+        }
+        if (ch >= 128)
+            return false;
+        const nibble = HEX[ch];
+        if (nibble === 0xFF)
+            return false;
+        gVal = (gVal << 4) | nibble;
+        if (++gLen > 4)
+            return false;
+        pos++;
+    }
+    if (gLen > 0) {
+        if (pIdx >= 8)
+            return false;
+        parts[pIdx++] = gVal;
+    }
+    else if (bodyEnd > 0 && s.charCodeAt(bodyEnd - 1) === 58 && !(bodyEnd >= 2 && s.charCodeAt(bodyEnd - 2) === 58)) {
+        return false;
+    }
+    if (dcPart !== -1) {
+        if (pIdx > 7)
+            return false;
+        const zeros = 8 - pIdx;
+        if (zeros <= 0)
+            return false;
+        for (let j = pIdx - 1; j >= dcPart; j--)
+            parts[j + zeros] = parts[j];
+        for (let j = dcPart; j < dcPart + zeros; j++)
+            parts[j] = 0;
+        pIdx = 8;
+    }
+    if (pIdx !== 8)
+        return false;
+    ipv6RawBuf[0] = ((parts[0] << 16) | parts[1]) >>> 0;
+    ipv6RawBuf[1] = ((parts[2] << 16) | parts[3]) >>> 0;
+    ipv6RawBuf[2] = ((parts[4] << 16) | parts[5]) >>> 0;
+    ipv6RawBuf[3] = ((parts[6] << 16) | parts[7]) >>> 0;
+    _rawZS = zoneStart;
+    _rawEnd = end;
+    return true;
+}
+/**
+ * Parses an IPv6 string into an IPv6Addr. Supports :: compression,
+ * embedded IPv4 suffixes, and zone IDs (e.g. "fe80::1%eth0").
+ * @param s - The IPv6 string
+ * @param end - Optional end index for parsing a substring
+ * @returns The parsed address, or null if invalid
+ */
+export function parseIPv6(s, end) {
+    return _parseIPv6(s, end !== undefined ? end : s.length);
+}
+/**
+ * Checks whether a string is a valid IPv6 address.
+ * @param s - The string to validate
+ * @returns True if the string is a valid IPv6 address
+ */
+export function isIPv6(s) {
+    return parseIPv6Raw(s, s.length);
+}
+/**
+ * Checks whether an IPv6 address is an IPv4-mapped address (::ffff:0:0/96).
+ * @param addr - The IPv6 address
+ * @returns True if the address is IPv4-mapped
+ */
+export function isIPv4Mapped(addr) {
+    return addr.w0 === 0 && addr.w1 === 0 && addr.w2 === 0x0000FFFF;
+}
+/**
+ * Expands an IPv6 address into eight 16-bit words.
+ * @param addr - The IPv6 address
+ * @returns Tuple of eight 16-bit group values
+ */
+export function ipv6ToWords(addr) {
+    return [
+        (addr.w0 >>> 16) & 0xFFFF, addr.w0 & 0xFFFF,
+        (addr.w1 >>> 16) & 0xFFFF, addr.w1 & 0xFFFF,
+        (addr.w2 >>> 16) & 0xFFFF, addr.w2 & 0xFFFF,
+        (addr.w3 >>> 16) & 0xFFFF, addr.w3 & 0xFFFF,
+    ];
+}
+/**
+ * Converts an IPv6 address to zero-padded colon notation (e.g. "0000:0000:...:0001").
+ * @param addr - The IPv6 address
+ * @returns The zero-padded string representation
+ */
+export function ipv6ToFixedString(addr) {
+    return _ipv6FullStr(addr, HEX4PAD_COLON, HEX4PAD_CACHE);
+}
+/**
+ * Converts an IPv6 address to uncompressed colon notation without zero-padding (e.g. "0:0:...:1").
+ * @param addr - The IPv6 address
+ * @returns The uncompressed string representation
+ */
+export function ipv6ToNormalizedString(addr) {
+    return _ipv6FullStr(addr, HEX4_COLON, HEX4_CACHE);
+}
+/**
+ * Converts an IPv6 address to its shortest RFC 5952 representation
+ * with :: compression for the longest zero-group run.
+ * @param addr - The IPv6 address
+ * @returns The compressed string (e.g. "::1", "fe80::1%eth0")
+ */
+export function ipv6ToString(addr) {
+    const w0 = addr.w0, w1 = addr.w1, w2 = addr.w2, w3 = addr.w3;
+    const p0 = (w0 >>> 16) & 0xFFFF, p1 = w0 & 0xFFFF;
+    const p2 = (w1 >>> 16) & 0xFFFF, p3 = w1 & 0xFFFF;
+    const p4 = (w2 >>> 16) & 0xFFFF, p5 = w2 & 0xFFFF;
+    const p6 = (w3 >>> 16) & 0xFFFF, p7 = w3 & 0xFFFF;
+    // Find longest run of consecutive zero groups (minimum length 2)
+    let bestStart = -1, bestLen = 0, curStart = -1, curLen = 0;
+    if (p0 === 0) {
+        curStart = 0;
+        curLen = 1;
+    }
+    if (p1 === 0) {
+        if (curStart === -1)
+            curStart = 1;
+        curLen++;
+        if (curLen > bestLen && curLen >= 2) {
+            bestStart = curStart;
+            bestLen = curLen;
+        }
+    }
+    else {
+        curStart = -1;
+        curLen = 0;
+    }
+    if (p2 === 0) {
+        if (curStart === -1)
+            curStart = 2;
+        curLen++;
+        if (curLen > bestLen && curLen >= 2) {
+            bestStart = curStart;
+            bestLen = curLen;
+        }
+    }
+    else {
+        curStart = -1;
+        curLen = 0;
+    }
+    if (p3 === 0) {
+        if (curStart === -1)
+            curStart = 3;
+        curLen++;
+        if (curLen > bestLen && curLen >= 2) {
+            bestStart = curStart;
+            bestLen = curLen;
+        }
+    }
+    else {
+        curStart = -1;
+        curLen = 0;
+    }
+    if (p4 === 0) {
+        if (curStart === -1)
+            curStart = 4;
+        curLen++;
+        if (curLen > bestLen && curLen >= 2) {
+            bestStart = curStart;
+            bestLen = curLen;
+        }
+    }
+    else {
+        curStart = -1;
+        curLen = 0;
+    }
+    if (p5 === 0) {
+        if (curStart === -1)
+            curStart = 5;
+        curLen++;
+        if (curLen > bestLen && curLen >= 2) {
+            bestStart = curStart;
+            bestLen = curLen;
+        }
+    }
+    else {
+        curStart = -1;
+        curLen = 0;
+    }
+    if (p6 === 0) {
+        if (curStart === -1)
+            curStart = 6;
+        curLen++;
+        if (curLen > bestLen && curLen >= 2) {
+            bestStart = curStart;
+            bestLen = curLen;
+        }
+    }
+    else {
+        curStart = -1;
+        curLen = 0;
+    }
+    if (p7 === 0) {
+        if (curStart === -1)
+            curStart = 7;
+        curLen++;
+        if (curLen > bestLen && curLen >= 2) {
+            bestStart = curStart;
+            bestLen = curLen;
+        }
+    }
+    if (bestLen === 0)
+        return _ipv6FullStr(addr, HEX4_COLON, HEX4_CACHE);
+    const z = _zoneIds.get(addr);
+    _toStrParts[0] = p0;
+    _toStrParts[1] = p1;
+    _toStrParts[2] = p2;
+    _toStrParts[3] = p3;
+    _toStrParts[4] = p4;
+    _toStrParts[5] = p5;
+    _toStrParts[6] = p6;
+    _toStrParts[7] = p7;
+    let s = '';
+    if (bestStart === 0) {
+        s = '::';
+    }
+    else {
+        for (let i = 0; i < bestStart - 1; i++) {
+            s += HEX4_COLON[_toStrParts[i]];
+        }
+        s += HEX4_CACHE[_toStrParts[bestStart - 1]];
+        s += '::';
+    }
+    const afterIdx = bestStart + bestLen;
+    for (let i = afterIdx; i < 8; i++) {
+        if (i > afterIdx)
+            s += ':';
+        s += HEX4_CACHE[_toStrParts[i]];
+    }
+    if (z)
+        s += '%' + z;
+    return s;
+}
+/**
+ * Extracts the embedded IPv4 address from the lower 32 bits of an IPv6 address.
+ * @param addr - The IPv6 address (typically an IPv4-mapped or IPv4-compatible address)
+ * @returns The packed uint32 IPv4 address
+ */
+export function ipv6ToIPv4(addr) {
+    return addr.w3;
+}

package/dist/internal/regex.d.ts

@@ -0,0 +1,37 @@
+export interface Options {
+    readonly exact?: boolean;
+    readonly includeBoundaries?: boolean;
+}
+export interface ScanResult {
+    readonly value: string;
+    readonly index: number;
+}
+export interface IpRegex {
+    (options?: Options): RegExp;
+    v4(options?: Options): RegExp;
+    v6(options?: Options): RegExp;
+    scanAll(input: string, options?: Options): ScanResult[];
+    scanAllV4(input: string, options?: Options): ScanResult[];
+    scanAllV6(input: string, options?: Options): ScanResult[];
+}
+/**
+ * Tests whether a string is a valid IPv4 address using regex.
+ * @param s - The string to test
+ * @returns True if the string matches IPv4 format
+ */
+export declare function testV4(s: string): boolean;
+/**
+ * Tests whether a string is a valid IPv6 address using regex.
+ * @param s - The string to test
+ * @returns True if the string matches IPv6 format
+ */
+export declare function testV6(s: string): boolean;
+/**
+ * Tests whether a string is a valid IPv4 or IPv6 address using regex.
+ * @param s - The string to test
+ * @returns True if the string matches either format
+ */
+export declare function testV46(s: string): boolean;
+declare const ipRegex: IpRegex;
+export default ipRegex;
+//# sourceMappingURL=regex.d.ts.map

package/dist/internal/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/internal/regex.ts"],"names":[],"mappings":"AA6CA,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;CACrC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,OAAO;IACtB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC3B,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC7B,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC7B,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,UAAU,EAAE,CAAA;IACvD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,UAAU,EAAE,CAAA;IACzD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,UAAU,EAAE,CAAA;CAC1D;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAE1C;AAwCD,QAAA,MAAM,OAAO,EAKP,OAAO,CAAA;AAoBb,eAAe,OAAO,CAAA"}