cidr-tools 11.0.8 → 11.0.10

package/dist/index.js

@@ -1,19 +1,8 @@
-import { ipVersion, parseIp, stringifyIp, normalizeIp } from "ip-bigint";
+import { parseIp, stringifyIp, normalizeIp } from "ip-bigint";
 const bits = { 4: 32, 6: 128 };
 function uniq(arr) {
-  return Array.from(new Set(arr));
-}
-function cidrVersion(cidr) {
-  return cidr.includes("/") ? ipVersion(cidr) : 0;
-}
-function compare(a, b) {
-  const { number: aNum, version: aVersion } = parseIp(a.replace(/\/.+/, ""));
-  const { number: bNum, version: bVersion } = parseIp(b.replace(/\/.+/, ""));
-  if (aVersion === bVersion) {
-    return aNum - bNum > 0n ? 1 : aNum - bNum < 0n ? -1 : 0;
-  } else {
-    return aVersion > bVersion ? 1 : 0;
-  }
+  const set = new Set(arr);
+  return set.size === arr.length ? arr : Array.from(set);
 }
 function doNormalize(cidr, { compress = true, hexify = false } = {}) {
   const { start, end, prefix, version, prefixPresent } = parseCidr(cidr);
@@ -32,51 +21,74 @@ function normalizeCidr(cidr, opts) {
   }
 }
 function parseCidr(str) {
-  const cidrVer = cidrVersion(str);
   const parsed = /* @__PURE__ */ Object.create(null);
-  let cidr;
-  if (cidrVer) {
-    cidr = str;
-    parsed.version = cidrVer;
-  } else {
-    const version2 = ipVersion(str);
-    if (version2) {
-      cidr = `${str}/${bits[version2]}`;
-      parsed.version = version2;
-    } else {
+  const slashIndex = str.indexOf("/");
+  let ipPart;
+  let prefix;
+  if (slashIndex !== -1) {
+    ipPart = str.substring(0, slashIndex);
+    prefix = str.substring(slashIndex + 1);
+    if (!/^[0-9]+$/.test(prefix)) {
       throw new Error(`Network is not a CIDR or IP: "${str}"`);
     }
+    parsed.prefixPresent = true;
+  } else {
+    ipPart = str;
+    parsed.prefixPresent = false;
+    prefix = "";
   }
-  const [ipAndMisc, prefix] = cidr.split("/");
-  if (!/^[0-9]+$/.test(prefix)) {
+  const { number, version, ipv4mapped, scopeid } = parseIp(ipPart);
+  if (!version) {
     throw new Error(`Network is not a CIDR or IP: "${str}"`);
   }
-  const { number, version, ipv4mapped, scopeid } = parseIp(ipAndMisc);
+  if (!parsed.prefixPresent) {
+    prefix = String(bits[version]);
+  }
+  parsed.version = version;
   parsed.ip = stringifyIp({ number, version, ipv4mapped, scopeid });
   parsed.cidr = `${parsed.ip}/${prefix}`;
   parsed.prefix = prefix;
-  parsed.prefixPresent = Boolean(cidrVer);
   const numBits = bits[version];
-  const hostBits = BigInt(numBits - Number(prefix));
-  const mask = hostBits > 0n ? (1n << hostBits) - 1n : 0n;
+  const hostBits = numBits - Number(prefix);
+  const mask = hostBits > 0 ? (1n << BigInt(hostBits)) - 1n : 0n;
   parsed.start = number & ~mask;
   parsed.end = number | mask;
   return parsed;
 }
-function doNetsOverlap(a, b) {
-  if (a.start > b.end) return false;
-  if (b.start > a.end) return false;
-  return true;
-}
-function netContains(a, b) {
-  if (b.start < a.start) return false;
-  if (b.end > a.end) return false;
-  return true;
+function parseCidrLean(str) {
+  const slashIndex = str.indexOf("/");
+  let ipPart;
+  let prefixNum;
+  if (slashIndex !== -1) {
+    ipPart = str.substring(0, slashIndex);
+    const prefixStr = str.substring(slashIndex + 1);
+    if (!/^[0-9]+$/.test(prefixStr)) {
+      throw new Error(`Network is not a CIDR or IP: "${str}"`);
+    }
+    prefixNum = Number(prefixStr);
+  } else {
+    ipPart = str;
+    prefixNum = -1;
+  }
+  const { number, version } = parseIp(ipPart);
+  if (!version) {
+    throw new Error(`Network is not a CIDR or IP: "${str}"`);
+  }
+  if (prefixNum === -1) {
+    prefixNum = bits[version];
+  }
+  const numBits = bits[version];
+  const hostBits = numBits - prefixNum;
+  const mask = hostBits > 0 ? (1n << BigInt(hostBits)) - 1n : 0n;
+  return {
+    start: number & ~mask,
+    end: number | mask,
+    version
+  };
 }
-function excludeNets(a, b, v) {
-  const parts = [];
+function excludeNetsParts(a, b) {
   if (a.start > b.end || a.end < b.start) {
-    return [a.cidr];
+    return [a];
   }
   if (a.start === b.start && a.end === b.end) {
     return [];
@@ -84,6 +96,7 @@ function excludeNets(a, b, v) {
   if (a.start > b.start && a.end < b.end) {
     return [];
   }
+  const parts = [];
   if (a.start < b.start && a.end <= b.end) {
     parts.push({ start: a.start, end: b.start - 1n });
   }
@@ -98,11 +111,9 @@ function excludeNets(a, b, v) {
   }
   const remaining = [];
   for (const part of parts) {
-    for (const subpart of subparts(part)) {
-      remaining.push(formatPart(subpart, v));
-    }
+    subparts(part, remaining);
   }
-  return mergeCidr(remaining);
+  return remaining;
 }
 function biggestPowerOfTwo(num) {
   if (num === 0n) return 0n;
@@ -114,26 +125,30 @@ function biggestPowerOfTwo(num) {
   }
   return 1n << b;
 }
-function subparts(part) {
+function subparts(part, output) {
+  if (!output) output = [];
   if (part.end < part.start) {
-    return [];
+    return output;
   }
   if (part.end === part.start) {
-    return [part];
+    output.push(part);
+    return output;
   }
   if (part.end - part.start === 1n) {
     if (part.end % 2n === 0n) {
-      return [{ start: part.start, end: part.start }, { start: part.end, end: part.end }];
+      output.push({ start: part.start, end: part.start }, { start: part.end, end: part.end });
     } else {
-      return [{ start: part.start, end: part.end }];
+      output.push({ start: part.start, end: part.end });
     }
+    return output;
   }
   const size = diff(part.end, part.start);
   let biggest = biggestPowerOfTwo(size);
   let start;
   let end;
-  if (size === biggest && part.start + size === part.end) {
-    return [part];
+  if (size === biggest && part.start % biggest === 0n) {
+    output.push(part);
+    return output;
   } else if (part.start % biggest === 0n) {
     start = part.start;
     end = start + biggest - 1n;
@@ -151,14 +166,14 @@ function subparts(part) {
       end = start + biggest - 1n;
     }
   }
-  let parts = [{ start, end }];
   if (start !== part.start) {
-    parts = parts.concat(subparts({ start: part.start, end: start - 1n }));
+    subparts({ start: part.start, end: start - 1n }, output);
   }
+  output.push({ start, end });
   if (end !== part.end) {
-    parts = parts.concat(subparts({ start: end + 1n, end: part.end }));
+    subparts({ start: end + 1n, end: part.end }, output);
   }
-  return parts;
+  return output;
 }
 function diff(a, b) {
   return a + 1n - b;
@@ -208,88 +223,123 @@ function doMerge(maps) {
     if (marker.end) depth -= marker.end;
     const next = numbers[index2 + 1];
     if (marker.end && depth === 0 && next !== void 0 && next - number > 1n) {
-      for (const sub of subparts({ start, end })) {
-        merged.push(sub);
-      }
+      subparts({ start, end }, merged);
       start = null;
       end = null;
     } else if (index2 === numbers.length - 1) {
-      for (const sub of subparts({ start, end })) {
-        merged.push(sub);
-      }
+      subparts({ start, end }, merged);
     }
   }
   return merged;
 }
 function mergeCidr(nets) {
-  const arr = uniq(Array.isArray(nets) ? nets : [nets]).map(parseCidr);
+  const arr = uniq(Array.isArray(nets) ? nets : [nets]).map(parseCidrLean);
   const maps = mapNets(arr);
-  const merged = { 4: [], 6: [] };
+  const merged = [];
   for (const v of [4, 6]) {
-    merged[v] = doMerge(maps[v]).map((part) => formatPart(part, v));
+    for (const part of doMerge(maps[v])) {
+      merged.push(formatPart(part, v));
+    }
   }
-  return [...merged[4].sort(compare), ...merged[6].sort(compare)];
+  return merged;
 }
 function excludeCidr(base, excl) {
-  const basenets = mergeCidr(uniq(Array.isArray(base) ? base : [base]));
-  const exclnets = mergeCidr(uniq(Array.isArray(excl) ? excl : [excl]));
+  const baseArr = uniq(Array.isArray(base) ? base : [base]).map(parseCidrLean);
+  const exclArr = uniq(Array.isArray(excl) ? excl : [excl]).map(parseCidrLean);
+  const baseMaps = mapNets(baseArr);
+  const exclMaps = mapNets(exclArr);
   const bases = { 4: [], 6: [] };
   const excls = { 4: [], 6: [] };
-  for (const basenet of basenets) {
-    const version = cidrVersion(basenet);
-    if (version) bases[version].push(basenet);
-  }
-  for (const exclnet of exclnets) {
-    const version = cidrVersion(exclnet);
-    if (version) excls[version].push(exclnet);
+  for (const v of [4, 6]) {
+    bases[v] = doMerge(baseMaps[v]);
+    excls[v] = doMerge(exclMaps[v]);
   }
   for (const v of [4, 6]) {
-    for (const exclcidr of excls[v]) {
-      const excl2 = parseCidr(exclcidr);
+    for (const exclPart of excls[v]) {
       const newBases = [];
-      for (const basecidr of bases[v]) {
-        newBases.push(...excludeNets(parseCidr(basecidr), excl2, v));
+      for (const basePart of bases[v]) {
+        for (const part of excludeNetsParts(basePart, exclPart)) {
+          newBases.push(part);
+        }
       }
       bases[v] = newBases;
     }
   }
-  return bases[4].concat(bases[6]).sort(compare);
+  const result = [];
+  for (const v of [4, 6]) {
+    for (const part of bases[v]) {
+      result.push(formatPart(part, v));
+    }
+  }
+  return result;
 }
 function* expandCidr(nets) {
   const arr = uniq(Array.isArray(nets) ? nets : [nets]);
   for (const net of mergeCidr(arr)) {
-    const { start, end, version } = parseCidr(net);
+    const { start, end, version } = parseCidrLean(net);
     for (let number = start; number <= end; number++) {
       yield normalizeIp(stringifyIp({ number, version }));
     }
   }
 }
 function overlapCidr(a, b) {
-  const aNets = uniq(Array.isArray(a) ? a : [a]).map(parseCidr);
-  const bNets = uniq(Array.isArray(b) ? b : [b]).map(parseCidr);
-  for (const aParsed of aNets) {
-    for (const bParsed of bNets) {
-      if (aParsed.version !== bParsed.version) continue;
-      if (doNetsOverlap(aParsed, bParsed)) return true;
+  const aNets = uniq(Array.isArray(a) ? a : [a]).map(parseCidrLean);
+  const bNets = uniq(Array.isArray(b) ? b : [b]).map(parseCidrLean);
+  const aByVersion = { 4: [], 6: [] };
+  const bByVersion = { 4: [], 6: [] };
+  for (const n of aNets) aByVersion[n.version].push(n);
+  for (const n of bNets) bByVersion[n.version].push(n);
+  for (const v of [4, 6]) {
+    const aVer = aByVersion[v].sort((x, y) => x.start > y.start ? 1 : x.start < y.start ? -1 : 0);
+    const bVer = bByVersion[v].sort((x, y) => x.start > y.start ? 1 : x.start < y.start ? -1 : 0);
+    let i = 0, j = 0;
+    while (i < aVer.length && j < bVer.length) {
+      const aNet = aVer[i];
+      const bNet = bVer[j];
+      if (aNet.start <= bNet.end && bNet.start <= aNet.end) return true;
+      if (aNet.end < bNet.end) i++;
+      else j++;
     }
   }
   return false;
 }
 function containsCidr(a, b) {
-  const aNets = uniq(Array.isArray(a) ? a : [a]).map(parseCidr);
-  const bNets = uniq(Array.isArray(b) ? b : [b]).map(parseCidr);
-  const numExpected = bNets.length;
-  let numFound = 0;
-  for (const aParsed of aNets) {
-    for (const bParsed of bNets) {
-      if (aParsed.version !== bParsed.version) continue;
-      if (netContains(aParsed, bParsed)) {
-        numFound++;
-        continue;
+  const aNets = uniq(Array.isArray(a) ? a : [a]).map(parseCidrLean);
+  const bNets = uniq(Array.isArray(b) ? b : [b]).map(parseCidrLean);
+  const aByVersion = { 4: [], 6: [] };
+  const bByVersion = { 4: [], 6: [] };
+  for (const n of aNets) aByVersion[n.version].push(n);
+  for (const n of bNets) bByVersion[n.version].push(n);
+  for (const v of [4, 6]) {
+    const containers = aByVersion[v].sort((x, y) => x.start > y.start ? 1 : x.start < y.start ? -1 : 0);
+    const targets = bByVersion[v];
+    if (targets.length === 0) continue;
+    if (containers.length === 0) return false;
+    const maxEnd = new Array(containers.length);
+    maxEnd[0] = containers[0].end;
+    for (let i = 1; i < containers.length; i++) {
+      if (containers[i].end > maxEnd[i - 1]) {
+        maxEnd[i] = containers[i].end;
+      } else {
+        maxEnd[i] = maxEnd[i - 1];
+      }
+    }
+    for (const target of targets) {
+      let lo = 0, hi = containers.length - 1;
+      let idx = -1;
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        if (containers[mid].start <= target.start) {
+          idx = mid;
+          lo = mid + 1;
+        } else {
+          hi = mid - 1;
+        }
       }
+      if (idx < 0 || maxEnd[idx] < target.end) return false;
     }
   }
-  return numFound === numExpected;
+  return true;
 }
 const index = {
   mergeCidr,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cidr-tools",
-  "version": "11.0.8",
+  "version": "11.0.10",
   "author": "silverwind <me@silverwind.io>",
   "description": "Tools to work with IPv4 and IPv6 CIDR",
   "repository": "silverwind/cidr-tools",
@@ -17,7 +17,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "ip-bigint": "^8.2.4"
+    "ip-bigint": "^8.2.6"
   },
   "devDependencies": {
     "@typescript/native-preview": "7.0.0-dev.20260202.1",
@@ -27,6 +27,7 @@
     "typescript": "5.9.3",
     "typescript-config-silverwind": "14.0.0",
     "updates": "17.1.0",
+    "updates-config-silverwind": "1.0.3",
     "versions": "14.1.0",
     "vite": "7.3.1",
     "vite-config-silverwind": "6.0.9",