cidr-tools 7.0.4 → 7.0.6

package/README.md

@@ -71,15 +71,14 @@ Returns a string or array (depending on input) with a normalized representation.
 
 - `network` *String*: A CIDR or IP address.
 
-Returns a `parsed` Object which is used internally by this module. It can be used to test whether the passed network is IPv4 or IPv6 or work with the BigInts directly.
+Returns a `parsed` Object which is used internally by this module. It can be used to test whether the passed network is IPv4 or IPv6 or to work with the BigInts directly.
 
 `parsed`: `Object`
   - `cidr` String: The CIDR of the network.
-  - `version` Number: Either `4` or `6`.
+  - `version` Number: IP protocol version. Either `4` or `6`.
   - `prefix` String: The network prefix, e.g. `/64`.
-  - `start` BigInt: Start of the network.
-  - `end` BigInt: Start of the network.
-  - `single` Boolean: `true` when is a single IP.
+  - `start` BigInt: Start number of the network.
+  - `end` BigInt: End number of the network.
 
 ## Related
 

package/index.d.ts

@@ -2,7 +2,6 @@ type IPv4Address = string;
 type IPv4CIDR = string;
 type IPv6Address = string;
 type IPv6CIDR = string;
-
 type Network = IPv4Address | IPv4CIDR | IPv6Address | IPv6CIDR;
 type Networks = Network | Network[];
 
@@ -12,7 +11,6 @@ type Parsed = {
   prefix: string;
   start: bigint;
   end: bigint;
-  single: boolean;
 };
 
 type NormalizeOpts = {

package/index.js

@@ -1,10 +1,6 @@
 import {parseIp, stringifyIp, normalizeIp, ipVersion} from "ip-bigint";
 
-const bits = {
-  4: 32,
-  6: 128,
-};
-
+const bits = {4: 32, 6: 128};
 const uniq = arr => Array.from(new Set(arr));
 const cidrVersion = cidr => cidr.includes("/") ? ipVersion(cidr) : 0;
 
@@ -20,8 +16,8 @@ function compare(a, b) {
 }
 
 function doNormalize(cidr, {compress = true, hexify = false} = {}) {
-  const {start, prefix, single, version} = parse(cidr);
-  if (!single) { // cidr
+  const {start, end, prefix, version} = parse(cidr);
+  if (start !== end) { // cidr
     // set network address to first address
     const ip = normalizeIp(stringifyIp({number: start, version}), {compress, hexify});
     return `${ip}/${prefix}`;
@@ -41,7 +37,6 @@ export function normalize(cidr, {compress = true, hexify = false} = {}) {
 export function parse(str) {
   const cidrVer = cidrVersion(str);
   const parsed = Object.create(null);
-  parsed.single = false;
 
   if (cidrVer) {
     parsed.cidr = str;
@@ -51,13 +46,17 @@ export function parse(str) {
     if (version) {
       parsed.cidr = `${str}/${bits[version]}`;
       parsed.version = version;
-      parsed.single = true;
     } else {
       throw new Error(`Network is not a CIDR or IP: ${str}`);
     }
   }
 
   const [ip, prefix] = parsed.cidr.split("/");
+
+  if (!/^[0-9]+$/.test(prefix)) {
+    throw new Error(`Network is not a CIDR or IP: ${str}`);
+  }
+
   parsed.prefix = prefix;
   const {number, version} = parseIp(ip);
   const numBits = bits[version];
@@ -223,75 +222,80 @@ function diff(a, b) {
   return a - b;
 }
 
-function formatPart(part, v) {
-  const ip = normalize(stringifyIp({
-    number: BigInt(part.start.toString()),
-    version: v,
-  }));
+function formatPart(part, version) {
+  const ip = normalize(stringifyIp({number: BigInt(part.start.toString()), version}));
   const zeroes = diff(part.end, part.start).toString(2);
-  const prefix = bits[v] - (zeroes.match(/0/g) || []).length;
+  const prefix = bits[version] - (zeroes.match(/0/g) || []).length;
   return `${ip}/${prefix}`;
 }
 
 function mapNets(nets) {
-  const maps = {4: {}, 6: {}};
-  for (const {start, end, version: v} of nets) {
-    if (!maps[v][start]) maps[v][start] = {};
-    if (!maps[v][end]) maps[v][end] = {};
+  const maps = {4: {}, 6: {}}; // TODO: use Map with BigInt key
+  for (const {start, end, version} of nets) {
+    if (!maps[version][start]) maps[version][start] = {};
+    if (!maps[version][end]) maps[version][end] = {};
 
-    if (maps[v][start].start) {
-      maps[v][start].start += 1;
+    if (maps[version][start].start) {
+      maps[version][start].start += 1;
     } else {
-      maps[v][start].start = 1;
+      maps[version][start].start = 1;
     }
 
-    if (maps[v][end].end) {
-      maps[v][end].end += 1;
+    if (maps[version][end].end) {
+      maps[version][end].end += 1;
     } else {
-      maps[v][end].end = 1;
+      maps[version][end].end = 1;
     }
   }
   return maps;
 }
 
-export function merge(nets) {
-  // sort to workaround https://github.com/silverwind/cidr-tools/issues/17
-  nets = uniq((Array.isArray(nets) ? nets : [nets]).sort(compare).map(parse));
-  const maps = mapNets(nets);
+function doMerge(maps, v) {
+  let start = null;
+  let end = null;
+  const numbers = Object.keys(maps);
+  let depth = 0;
+  const merged = [];
 
-  const merged = {4: [], 6: []};
-  const start = {4: null, 6: null};
-  const end = {4: null, 6: null};
+  for (const [index, number] of numbers.entries()) {
+    const marker = maps[number];
 
-  for (const v of [4, 6]) {
-    const numbers = Object.keys(maps[v]);
-    let depth = 0;
+    if (start === null && marker.start) {
+      start = BigInt(number);
+    }
+    if (marker.end) {
+      end = BigInt(number);
+    }
 
-    for (const [index, number] of numbers.entries()) {
-      const marker = maps[v][number];
+    if (marker.start) depth += marker.start;
+    if (marker.end) depth -= marker.end;
 
-      if (start[v] === null && marker.start) {
-        start[v] = BigInt(number);
+    const next = numbers[index + 1];
+    if (marker.end && depth === 0 && next && ((BigInt(next) - BigInt(number)) > 1)) {
+      // when there is a end and the next part is more than one number away, we cut a part
+      for (const sub of subparts({start, end})) {
+        merged.push(formatPart(sub, v));
       }
-      if (marker.end) {
-        end[v] = BigInt(number);
+      start = null;
+      end = null;
+    } else if (index === (numbers.length - 1)) {
+      // cut the final part
+      for (const sub of subparts({start, end})) {
+        merged.push(formatPart(sub, v));
       }
+    }
+  }
+  return merged;
+}
 
-      if (marker.start) depth += marker.start;
-      if (marker.end) depth -= marker.end;
+export function merge(nets) {
+  // sort to workaround https://github.com/silverwind/cidr-tools/issues/17
+  nets = uniq((Array.isArray(nets) ? nets : [nets]).sort(compare).map(parse));
+  const maps = mapNets(nets);
 
-      if (marker.end && depth === 0 && ((numbers[index + 1] - numbers[index]) > 1)) {
-        for (const sub of subparts({start: start[v], end: end[v]})) {
-          merged[v].push(formatPart(sub, v));
-        }
-        start[v] = null;
-        end[v] = null;
-      } else if (index === (numbers.length - 1)) {
-        for (const sub of subparts({start: start[v], end: end[v]})) {
-          merged[v].push(formatPart(sub, v));
-        }
-      }
-    }
+  const merged = {4: [], 6: []};
+  for (const v of [4, 6]) {
+    merged[v] = doMerge(maps[v], v);
   }
 
   return [...merged[4].sort(compare), ...merged[6].sort(compare)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cidr-tools",
-  "version": "7.0.4",
+  "version": "7.0.6",
   "author": "silverwind <me@silverwind.io>",
   "description": "Tools to work with IPv4 and IPv6 CIDR",
   "repository": "silverwind/cidr-tools",
@@ -18,15 +18,15 @@
     "./index.d.ts"
   ],
   "dependencies": {
-    "ip-bigint": "^8.0.1"
+    "ip-bigint": "^8.0.2"
   },
   "devDependencies": {
-    "eslint": "8.54.0",
-    "eslint-config-silverwind": "79.3.5",
-    "tsd": "0.29.0",
-    "updates": "15.0.4",
-    "versions": "12.0.0",
-    "vitest": "0.34.6",
-    "vitest-config-silverwind": "3.0.0"
+    "eslint": "8.56.0",
+    "eslint-config-silverwind": "80.0.3",
+    "tsd": "0.30.5",
+    "updates": "15.1.2",
+    "versions": "12.0.1",
+    "vitest": "1.3.1",
+    "vitest-config-silverwind": "5.1.1"
   }
 }