ip-utilities 1.0.0

package/dist/internal/regex.js

@@ -0,0 +1,118 @@
+const v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)" +
+    "(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
+const v6seg = "[a-fA-F\\d]{1,4}";
+const v6core = [
+    `(?:${v6seg}:){7}(?:${v6seg}|:)`,
+    `(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)`,
+    `(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)`,
+    `(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)`,
+    `(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)`,
+    `(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)`,
+    `(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)`,
+    `(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))`,
+].join("|");
+const v6 = `(?:${v6core})(?:%[0-9a-zA-Z]+)?`;
+const v4ExactRe = new RegExp(`^${v4}$`);
+const v6ExactRe = new RegExp(`^${v6}$`);
+const v46ExactRe = new RegExp(`^(?:${v4})$|^(?:${v6})$`);
+const WB_START = "(?<=\\s|^)";
+const WB_END = "(?=\\s|$)";
+const v46ScanRe = new RegExp(`(?:${v4})|(?:${v6})`, "g");
+const v46ScanBRe = new RegExp(`(?:${WB_START}${v4}${WB_END})|(?:${WB_START}${v6}${WB_END})`, "g");
+const v4ScanRe = new RegExp(v4, "g");
+const v4ScanBRe = new RegExp(`${WB_START}${v4}${WB_END}`, "g");
+const v6ScanRe = new RegExp(v6, "g");
+const v6ScanBRe = new RegExp(`${WB_START}${v6}${WB_END}`, "g");
+const candidateRe = /[0-9a-fA-F:][0-9a-fA-F.:_%]{1,48}/g;
+const MAX_V4_LEN = 15;
+const MAX_V6_LEN = 50;
+// Whitespace character bitmap for word-boundary detection
+const WS = new Uint8Array(256);
+WS[9] = 1;
+WS[10] = 1;
+WS[12] = 1;
+WS[13] = 1;
+WS[32] = 1;
+/**
+ * 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 function testV4(s) {
+    return s.length <= MAX_V4_LEN && v4ExactRe.test(s);
+}
+/**
+ * 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 function testV6(s) {
+    return s.length <= MAX_V6_LEN && v6ExactRe.test(s);
+}
+/**
+ * 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 function testV46(s) {
+    return s.length <= MAX_V6_LEN && v46ExactRe.test(s);
+}
+function createScanner(testFn) {
+    return (input, options) => {
+        const useBoundaries = options?.includeBoundaries ?? false;
+        const results = [];
+        const inputLen = input.length;
+        candidateRe.lastIndex = 0;
+        let m;
+        while ((m = candidateRe.exec(input)) !== null) {
+            const raw = m[0];
+            const idx = m.index;
+            if (useBoundaries) {
+                if (idx > 0 && !WS[input.charCodeAt(idx - 1)])
+                    continue;
+                const afterIdx = idx + raw.length;
+                if (afterIdx < inputLen && !WS[input.charCodeAt(afterIdx)])
+                    continue;
+            }
+            if (testFn(raw)) {
+                results.push({ value: raw, index: idx });
+            }
+            else {
+                const maxTry = Math.min(raw.length - 1, MAX_V6_LEN);
+                for (let len = maxTry; len >= 2; len--) {
+                    const sub = raw.slice(0, len);
+                    if (testFn(sub)) {
+                        results.push({ value: sub, index: idx });
+                        break;
+                    }
+                }
+            }
+        }
+        return results;
+    };
+}
+const ipRegex = ((options) => {
+    if (options?.exact)
+        return v46ExactRe;
+    const re = options?.includeBoundaries ? v46ScanBRe : v46ScanRe;
+    re.lastIndex = 0;
+    return re;
+});
+ipRegex.v4 = (options) => {
+    if (options?.exact)
+        return v4ExactRe;
+    const re = options?.includeBoundaries ? v4ScanBRe : v4ScanRe;
+    re.lastIndex = 0;
+    return re;
+};
+ipRegex.v6 = (options) => {
+    if (options?.exact)
+        return v6ExactRe;
+    const re = options?.includeBoundaries ? v6ScanBRe : v6ScanRe;
+    re.lastIndex = 0;
+    return re;
+};
+ipRegex.scanAll = createScanner(testV46);
+ipRegex.scanAllV4 = createScanner(testV4);
+ipRegex.scanAllV6 = createScanner(testV6);
+export default ipRegex;

package/dist/internal/sort.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Compares two IP address or CIDR strings for sort ordering.
+ * IPv4 sorts before IPv6. Invalid strings sort last, ordered lexicographically.
+ * Results are cached across calls.
+ * @param a - First IP/CIDR string
+ * @param b - Second IP/CIDR string
+ * @returns Negative if a < b, positive if a > b, zero if equal
+ */
+export declare function compareIPs(a: string, b: string): number;
+/**
+ * Sorts an array of IP address and CIDR strings in network order.
+ * IPv4 addresses sort before IPv6. Invalid strings sort last.
+ * CIDR entries with the same network sort by prefix length.
+ * @param ips - Array of IP/CIDR strings
+ * @returns A new sorted array
+ */
+export declare function sortIPs(ips: string[]): string[];
+/**
+ * Clears the internal sort comparison cache.
+ */
+export declare function clearSortCache(): void;
+//# sourceMappingURL=sort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/internal/sort.ts"],"names":[],"mappings":"AA4HA;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAwD/C;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAIrC"}

package/dist/internal/sort.js

@@ -0,0 +1,207 @@
+import { parseIPv4Raw } from "./ipv4.js";
+import { parseIPv6Raw, ipv6RawBuf } from "./ipv6.js";
+import { parsePrefixInline } from "./cidr.js";
+// Layout per entry: [kind, v4_ip, w0, w1, w2, w3, prefix]
+const STRIDE = 7;
+const K_KIND = 0;
+const K_V4 = 1;
+const K_W0 = 2;
+const K_W1 = 3;
+const K_W2 = 4;
+const K_W3 = 5;
+const K_PREFIX = 6;
+const NO_PREFIX = -1;
+// Two-generation LRU cache for parsed sort keys
+const HALF_CACHE = 5000;
+let young = new Map();
+let old = new Map();
+// Pooled buffers for sortIPs — reused across calls, shrink if 4x oversized
+const SORT_POOL_MIN = 64 * STRIDE;
+let _sortStore = new Float64Array(SORT_POOL_MIN);
+let _sortIndices = [];
+let cacheStore = new Float64Array(HALF_CACHE * 2 * STRIDE);
+let cacheIdx = 0;
+function cacheGet(s) {
+    let v = young.get(s);
+    if (v !== undefined)
+        return v;
+    v = old.get(s);
+    if (v !== undefined) {
+        young.set(s, v);
+        return v;
+    }
+    return -1;
+}
+function cachePut(s, offset) {
+    if (young.size >= HALF_CACHE) {
+        old = young;
+        young = new Map();
+    }
+    young.set(s, offset);
+}
+function ensureCacheStore(needed) {
+    if (needed <= cacheStore.length)
+        return;
+    const next = new Float64Array(needed * 2);
+    next.set(cacheStore);
+    cacheStore = next;
+}
+function _parseInto(store, offset, s, ipEnd, prefix) {
+    const ip = parseIPv4Raw(s, 0, ipEnd);
+    if (ip !== -1) {
+        store[offset + K_KIND] = 4;
+        store[offset + K_V4] = ip;
+        store[offset + K_PREFIX] = prefix;
+        return;
+    }
+    if (parseIPv6Raw(s, ipEnd)) {
+        store[offset + K_KIND] = 6;
+        store[offset + K_W0] = ipv6RawBuf[0];
+        store[offset + K_W1] = ipv6RawBuf[1];
+        store[offset + K_W2] = ipv6RawBuf[2];
+        store[offset + K_W3] = ipv6RawBuf[3];
+        store[offset + K_PREFIX] = prefix;
+        return;
+    }
+    store[offset + K_KIND] = 0;
+    store[offset + K_PREFIX] = prefix;
+}
+function parseForSortCached(s) {
+    const cached = cacheGet(s);
+    if (cached !== -1)
+        return cached;
+    const offset = cacheIdx;
+    ensureCacheStore(offset + STRIDE);
+    cacheIdx += STRIDE;
+    cacheStore[offset + K_PREFIX] = NO_PREFIX;
+    const slashIdx = s.indexOf('/');
+    if (slashIdx === -1) {
+        _parseInto(cacheStore, offset, s, s.length, NO_PREFIX);
+    }
+    else {
+        const prefix = parsePrefixInline(s, slashIdx + 1, s.length, 128);
+        if (prefix !== -1) {
+            _parseInto(cacheStore, offset, s, slashIdx, prefix);
+        }
+    }
+    cachePut(s, offset);
+    return offset;
+}
+function _compare(store, oa, ob, sa, sb) {
+    const ka = store[oa + K_KIND];
+    const kb = store[ob + K_KIND];
+    if (ka === 0 && kb === 0)
+        return sa < sb ? -1 : sa > sb ? 1 : 0;
+    if (ka === 0)
+        return 1;
+    if (kb === 0)
+        return -1;
+    if (ka !== kb)
+        return ka === 4 ? -1 : 1;
+    let cmp;
+    if (ka === 4) {
+        cmp = store[oa + K_V4] - store[ob + K_V4];
+    }
+    else {
+        cmp = store[oa + K_W0] - store[ob + K_W0];
+        if (cmp === 0)
+            cmp = store[oa + K_W1] - store[ob + K_W1];
+        if (cmp === 0)
+            cmp = store[oa + K_W2] - store[ob + K_W2];
+        if (cmp === 0)
+            cmp = store[oa + K_W3] - store[ob + K_W3];
+    }
+    if (cmp !== 0)
+        return cmp;
+    const defaultPfx = ka === 4 ? 32 : 128;
+    const pa = store[oa + K_PREFIX];
+    const pb = store[ob + K_PREFIX];
+    return (pa === NO_PREFIX ? defaultPfx : pa) - (pb === NO_PREFIX ? defaultPfx : pb);
+}
+/**
+ * Compares two IP address or CIDR strings for sort ordering.
+ * IPv4 sorts before IPv6. Invalid strings sort last, ordered lexicographically.
+ * Results are cached across calls.
+ * @param a - First IP/CIDR string
+ * @param b - Second IP/CIDR string
+ * @returns Negative if a < b, positive if a > b, zero if equal
+ */
+export function compareIPs(a, b) {
+    const oa = parseForSortCached(a);
+    const ob = parseForSortCached(b);
+    return _compare(cacheStore, oa, ob, a, b);
+}
+/**
+ * Sorts an array of IP address and CIDR strings in network order.
+ * IPv4 addresses sort before IPv6. Invalid strings sort last.
+ * CIDR entries with the same network sort by prefix length.
+ * @param ips - Array of IP/CIDR strings
+ * @returns A new sorted array
+ */
+export function sortIPs(ips) {
+    const n = ips.length;
+    if (n <= 1)
+        return n === 0 ? [] : [ips[0]];
+    const needed = n * STRIDE;
+    if (_sortStore.length < needed) {
+        _sortStore = new Float64Array(needed);
+    }
+    else if (_sortStore.length > SORT_POOL_MIN && _sortStore.length > needed * 4) {
+        _sortStore = new Float64Array(needed);
+    }
+    const store = _sortStore;
+    for (let i = 0; i < n; i++) {
+        const off = i * STRIDE;
+        store[off + K_PREFIX] = NO_PREFIX;
+        const s = ips[i];
+        const slashIdx = s.indexOf('/');
+        if (slashIdx === -1) {
+            _parseInto(store, off, s, s.length, NO_PREFIX);
+        }
+        else {
+            const prefix = parsePrefixInline(s, slashIdx + 1, s.length, 128);
+            if (prefix !== -1) {
+                _parseInto(store, off, s, slashIdx, prefix);
+            }
+        }
+    }
+    if (_sortIndices.length < n) {
+        _sortIndices = new Array(n);
+    }
+    else if (_sortIndices.length > 64 && _sortIndices.length > n * 4) {
+        _sortIndices = new Array(n);
+    }
+    const indices = _sortIndices;
+    for (let i = 0; i < n; i++)
+        indices[i] = i;
+    if (n <= 16) {
+        for (let i = 1; i < n; i++) {
+            const key = indices[i];
+            const keyOff = key * STRIDE;
+            let j = i - 1;
+            while (j >= 0) {
+                const jIdx = indices[j];
+                if (_compare(store, jIdx * STRIDE, keyOff, ips[jIdx], ips[key]) <= 0)
+                    break;
+                indices[j + 1] = jIdx;
+                j--;
+            }
+            indices[j + 1] = key;
+        }
+    }
+    else {
+        indices.sort((ai, bi) => _compare(store, ai * STRIDE, bi * STRIDE, ips[ai], ips[bi]));
+    }
+    const result = new Array(n);
+    for (let i = 0; i < n; i++)
+        result[i] = ips[indices[i]];
+    return result;
+}
+/**
+ * Clears the internal sort comparison cache.
+ */
+export function clearSortCache() {
+    young = new Map();
+    old = new Map();
+    cacheIdx = 0;
+}

package/dist/ipv4.d.ts

@@ -0,0 +1,2 @@
+export { parseIPv4, isIPv4, parseIPv4Loose, ipv4ToOctets, ipv4ToString } from './internal/ipv4.ts';
+//# sourceMappingURL=ipv4.d.ts.map

package/dist/ipv4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipv4.d.ts","sourceRoot":"","sources":["../src/ipv4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/ipv4.js

@@ -0,0 +1 @@
+export { parseIPv4, isIPv4, parseIPv4Loose, ipv4ToOctets, ipv4ToString } from "./internal/ipv4.js";

package/dist/ipv6.d.ts

@@ -0,0 +1,2 @@
+export { parseIPv6, isIPv6, isIPv4Mapped, ipv6ToWords, ipv6ToString, ipv6ToNormalizedString, ipv6ToFixedString, ipv6ToIPv4, ipv6GetZoneId } from './internal/ipv6.ts';
+//# sourceMappingURL=ipv6.d.ts.map

package/dist/ipv6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipv6.d.ts","sourceRoot":"","sources":["../src/ipv6.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/ipv6.js

@@ -0,0 +1 @@
+export { parseIPv6, isIPv6, isIPv4Mapped, ipv6ToWords, ipv6ToString, ipv6ToNormalizedString, ipv6ToFixedString, ipv6ToIPv4, ipv6GetZoneId } from "./internal/ipv6.js";

package/dist/ranges.d.ts

@@ -0,0 +1,3 @@
+export { ipv4Range, isPrivateIPv4, isLoopbackIPv4, isLinkLocalIPv4 } from './internal/ipv4-ranges.ts';
+export { ipv6Range, isPrivateIPv6, isLoopbackIPv6, isLinkLocalIPv6 } from './internal/ipv6-ranges.ts';
+//# sourceMappingURL=ranges.d.ts.map

package/dist/ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranges.d.ts","sourceRoot":"","sources":["../src/ranges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AACrG,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/ranges.js

@@ -0,0 +1,2 @@
+export { ipv4Range, isPrivateIPv4, isLoopbackIPv4, isLinkLocalIPv4 } from "./internal/ipv4-ranges.js";
+export { ipv6Range, isPrivateIPv6, isLoopbackIPv6, isLinkLocalIPv6 } from "./internal/ipv6-ranges.js";

package/dist/regex.d.ts

@@ -0,0 +1,3 @@
+export { default, testV4, testV6, testV46 } from './internal/regex.ts';
+export type { Options, ScanResult, IpRegex } from './internal/regex.ts';
+//# sourceMappingURL=regex.d.ts.map

package/dist/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../src/regex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AACtE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/regex.js

@@ -0,0 +1 @@
+export { default, testV4, testV6, testV46 } from "./internal/regex.js";

package/dist/sort.d.ts

@@ -0,0 +1,2 @@
+export { compareIPs, sortIPs, clearSortCache } from './internal/sort.ts';
+//# sourceMappingURL=sort.d.ts.map

package/dist/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/sort.js

@@ -0,0 +1 @@
+export { compareIPs, sortIPs, clearSortCache } from "./internal/sort.js";

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export interface IPv4Addr {
+    readonly ip: number;
+    readonly kind: 4;
+}
+export interface IPv6Addr {
+    readonly w0: number;
+    readonly w1: number;
+    readonly w2: number;
+    readonly w3: number;
+    readonly kind: 6;
+}
+export type IPAddr = IPv4Addr | IPv6Addr;
+export interface CIDRv4 {
+    readonly addr: IPv4Addr;
+    readonly prefix: number;
+    readonly kind: 4;
+}
+export interface CIDRv6 {
+    readonly addr: IPv6Addr;
+    readonly prefix: number;
+    readonly kind: 6;
+}
+export type CIDR = CIDRv4 | CIDRv6;
+export type IPv4RangeName = 'unspecified' | 'broadcast' | 'multicast' | 'linkLocal' | 'loopback' | 'carrierGradeNat' | 'private' | 'reserved' | 'as112' | 'amt' | 'benchmarking' | 'unicast';
+export type IPv6RangeName = 'unspecified' | 'linkLocal' | 'multicast' | 'loopback' | 'uniqueLocal' | 'ipv4Mapped' | 'discard' | 'rfc6145' | 'rfc6052' | '6to4' | 'teredo' | 'benchmarking' | 'amt' | 'as112v6' | 'deprecated' | 'orchid2' | 'droneRemoteIdProtocolEntityTags' | 'reserved' | 'unicast';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CACjB;AAED,MAAM,MAAM,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAExC,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CACjB;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CACjB;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;AAElC,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,WAAW,GACX,WAAW,GACX,WAAW,GACX,UAAU,GACV,iBAAiB,GACjB,SAAS,GACT,UAAU,GACV,OAAO,GACP,KAAK,GACL,cAAc,GACd,SAAS,CAAA;AAEb,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,WAAW,GACX,WAAW,GACX,UAAU,GACV,aAAa,GACb,YAAY,GACZ,SAAS,GACT,SAAS,GACT,SAAS,GACT,MAAM,GACN,QAAQ,GACR,cAAc,GACd,KAAK,GACL,SAAS,GACT,YAAY,GACZ,SAAS,GACT,iCAAiC,GACjC,UAAU,GACV,SAAS,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "ip-utilities",
+  "version": "1.0.0",
+  "description": "IP address parsing, validation, and CIDR operations for TypeScript",
+  "license": "MIT",
+  "author": "DrSkillIssue",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DrSkillIssue/ip-utilities.git"
+  },
+  "homepage": "https://github.com/DrSkillIssue/ip-utilities",
+  "bugs": "https://github.com/DrSkillIssue/ip-utilities/issues",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./ipv4": {
+      "types": "./dist/ipv4.d.ts",
+      "import": "./dist/ipv4.js"
+    },
+    "./ipv6": {
+      "types": "./dist/ipv6.d.ts",
+      "import": "./dist/ipv6.js"
+    },
+    "./cidr": {
+      "types": "./dist/cidr.d.ts",
+      "import": "./dist/cidr.js"
+    },
+    "./sort": {
+      "types": "./dist/sort.d.ts",
+      "import": "./dist/sort.js"
+    },
+    "./regex": {
+      "types": "./dist/regex.d.ts",
+      "import": "./dist/regex.js"
+    },
+    "./ranges": {
+      "types": "./dist/ranges.d.ts",
+      "import": "./dist/ranges.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "bench": "bun run test/bench/ip.bench.ts"
+  },
+  "keywords": [
+    "ip",
+    "ipv4",
+    "ipv6",
+    "cidr",
+    "subnet",
+    "network",
+    "address",
+    "validate",
+    "parse",
+    "regex",
+    "private",
+    "range",
+    "sort"
+  ],
+  "sideEffects": false,
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "ipaddr.js": "^2.3.0",
+    "mitata": "^1.0.34",
+    "typescript": "^6.0.2"
+  }
+}