cidr-tools 11.0.6 → 11.0.9

package/dist/index.js

@@ -6,15 +6,6 @@ function uniq(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;
-  }
-}
 function doNormalize(cidr, { compress = true, hexify = false } = {}) {
   const { start, end, prefix, version, prefixPresent } = parseCidr(cidr);
   if (start !== end || prefixPresent) {
@@ -63,20 +54,39 @@ function parseCidr(str) {
   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 cidrVer = cidrVersion(str);
+  let version;
+  let cidr;
+  if (cidrVer) {
+    cidr = str;
+    version = cidrVer;
+  } else {
+    const v = ipVersion(str);
+    if (v) {
+      version = v;
+      cidr = `${str}/${bits[version]}`;
+    } else {
+      throw new Error(`Network is not a CIDR or IP: "${str}"`);
+    }
+  }
+  const [ipAndMisc, prefix] = cidr.split("/");
+  if (!/^[0-9]+$/.test(prefix)) {
+    throw new Error(`Network is not a CIDR or IP: "${str}"`);
+  }
+  const { number, version: parsedVersion } = parseIp(ipAndMisc);
+  const numBits = bits[parsedVersion];
+  const hostBits = BigInt(numBits - Number(prefix));
+  const mask = hostBits > 0n ? (1n << 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 +94,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 +109,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 +123,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];
+    output.push(part);
+    return output;
   } else if (part.start % biggest === 0n) {
     start = part.start;
     end = start + biggest - 1n;
@@ -151,14 +164,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 +221,111 @@ 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: [] };
   for (const v of [4, 6]) {
     merged[v] = doMerge(maps[v]).map((part) => formatPart(part, v));
   }
-  return [...merged[4].sort(compare), ...merged[6].sort(compare)];
+  return [...merged[4], ...merged[6]];
 }
 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]) {
+        newBases.push(...excludeNetsParts(basePart, exclPart));
       }
       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);
+  for (const v of [4, 6]) {
+    const aVer = aNets.filter((n) => n.version === v).sort((x, y) => x.start > y.start ? 1 : x.start < y.start ? -1 : 0);
+    const bVer = bNets.filter((n) => n.version === 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);
+  for (const v of [4, 6]) {
+    const containers = aNets.filter((n) => n.version === v).sort((x, y) => x.start > y.start ? 1 : x.start < y.start ? -1 : 0);
+    const targets = bNets.filter((n) => n.version === 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.6",
+  "version": "11.0.9",
   "author": "silverwind <me@silverwind.io>",
   "description": "Tools to work with IPv4 and IPv6 CIDR",
   "repository": "silverwind/cidr-tools",
@@ -17,19 +17,21 @@
     "node": ">=18"
   },
   "dependencies": {
-    "ip-bigint": "^8.2.4"
+    "ip-bigint": "^8.2.6"
   },
   "devDependencies": {
     "@typescript/native-preview": "7.0.0-dev.20260202.1",
     "eslint": "9.39.2",
-    "eslint-config-silverwind": "120.0.0",
+    "eslint-config-silverwind": "120.1.2",
+    "jest-extended": "7.0.0",
     "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",
     "vitest": "4.0.18",
     "vitest-config-silverwind": "10.6.1"
   }
-}
+}