cidr-tools 9.1.1 → 10.0.1

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+type IPv4Address = string;
+type IPv6Address = string;
+type IPv4CIDR = string;
+type IPv6CIDR = string;
+type Network = IPv4Address | IPv4CIDR | IPv6Address | IPv6CIDR;
+type Networks = Network | Network[];
+type ValidIpVersion = 4 | 6;
+type ParsedCidr = {
+    cidr: string;
+    ip: string;
+    version: ValidIpVersion;
+    prefix: string;
+    start: bigint;
+    end: bigint;
+};
+type NormalizeOpts = {
+    compress?: boolean;
+    hexify?: boolean;
+};
+export declare function normalizeCidr(cidr: Network, opts?: NormalizeOpts): Network;
+export declare function normalizeCidr(cidr: Network[], opts?: NormalizeOpts): Network[];
+export declare function parseCidr(str: Network): ParsedCidr;
+export declare function mergeCidr(nets: Networks): Network[];
+export declare function excludeCidr(base: Networks, excl: Networks): string[];
+export declare function expandCidr(nets: Networks): string[];
+export declare function overlapCidr(a: Networks, b: Networks): boolean;
+export declare function containsCidr(a: Networks, b: Networks): boolean;
+declare const _default: {
+    mergeCidr: typeof mergeCidr;
+    excludeCidr: typeof excludeCidr;
+    expandCidr: typeof expandCidr;
+    overlapCidr: typeof overlapCidr;
+    containsCidr: typeof containsCidr;
+    normalizeCidr: typeof normalizeCidr;
+    parseCidr: typeof parseCidr;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,317 @@
+import { ipVersion, 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;
+  }
+}
+function doNormalize(cidr, { compress = true, hexify = false } = {}) {
+  const { start, end, prefix, version } = parseCidr(cidr);
+  if (start !== end) {
+    const ip = normalizeIp(stringifyIp({ number: start, version }), { compress, hexify });
+    return `${ip}/${prefix}`;
+  } else {
+    return normalizeIp(cidr, { compress, hexify });
+  }
+}
+function normalizeCidr(cidr, opts) {
+  if (Array.isArray(cidr)) {
+    return cidr.map((entry) => normalizeCidr(entry, opts));
+  } else {
+    return doNormalize(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 {
+      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, ipv4mapped, scopeid } = parseIp(ipAndMisc);
+  parsed.ip = stringifyIp({ number, version, ipv4mapped, scopeid });
+  parsed.cidr = `${parsed.ip}/${prefix}`;
+  parsed.prefix = prefix;
+  const numBits = bits[version];
+  const ipBits = number.toString(2).padStart(numBits, "0");
+  const prefixLen = Number(numBits - Number(prefix));
+  const startBits = ipBits.substring(0, numBits - prefixLen);
+  parsed.start = BigInt(`0b${startBits}${"0".repeat(prefixLen)}`);
+  parsed.end = BigInt(`0b${startBits}${"1".repeat(prefixLen)}`);
+  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 excludeNets(a, b, v) {
+  const parts = [];
+  if (a.start > b.end || a.end < b.start) {
+    return [a.cidr];
+  }
+  if (a.start === b.start && a.end === b.end) {
+    return [];
+  }
+  if (a.start > b.start && a.end < b.end) {
+    return [];
+  }
+  if (a.start < b.start && a.end <= b.end) {
+    parts.push({ start: a.start, end: b.start - 1n });
+  }
+  if (a.start >= b.start && a.end > b.end) {
+    parts.push({ start: b.end + 1n, end: a.end });
+  }
+  if (a.start < b.start && a.end > b.end) {
+    parts.push(
+      { start: a.start, end: b.start - 1n },
+      { start: b.end + 1n, end: a.end }
+    );
+  }
+  const remaining = [];
+  for (const part of parts) {
+    for (const subpart of subparts(part)) {
+      remaining.push(formatPart(subpart, v));
+    }
+  }
+  return mergeCidr(remaining);
+}
+function biggestPowerOfTwo(num) {
+  if (num === 0n)
+    return 0n;
+  return 2n ** BigInt(String(num.toString(2).length - 1));
+}
+function subparts(part) {
+  if (part.end - part.start === 1n) {
+    if (part.end % 2n === 0n) {
+      return [{ start: part.start, end: part.start }, { start: part.end, end: part.end }];
+    } else {
+      return [{ start: part.start, end: part.end }];
+    }
+  }
+  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];
+  } else if (part.start % biggest === 0n) {
+    start = part.start;
+    end = start + biggest - 1n;
+  } else {
+    start = part.end / biggest * biggest;
+    if (start + biggest - 1n > part.end) {
+      start = (part.end / biggest - 1n) * biggest;
+      while (start < part.start) {
+        biggest /= 2n;
+        start = (part.end / biggest - 1n) * biggest;
+      }
+      end = start + biggest - 1n;
+    } else {
+      start = part.end / biggest * biggest;
+      end = start + biggest - 1n;
+    }
+  }
+  let parts = [{ start, end }];
+  if (start !== part.start) {
+    parts = parts.concat(subparts({ start: part.start, end: start - 1n }));
+  }
+  if (end !== part.end) {
+    parts = parts.concat(subparts({ start: end + 1n, end: part.end }));
+  }
+  return parts;
+}
+function diff(a, b) {
+  a += 1n;
+  return a - b;
+}
+function formatPart(part, version) {
+  const ip = normalizeCidr(stringifyIp({ number: BigInt(part.start.toString()), version }));
+  const zeroes = diff(part.end, part.start).toString(2);
+  const prefix = bits[version] - (zeroes.match(/0/g) || []).length;
+  return `${ip}/${prefix}`;
+}
+function mapNets(nets) {
+  const maps = { 4: {}, 6: {} };
+  for (const { start, end, version } of nets) {
+    if (!maps[version][String(start)])
+      maps[version][String(start)] = {};
+    if (!maps[version][String(end)])
+      maps[version][String(end)] = {};
+    if (maps[version][String(start)].start) {
+      maps[version][String(start)].start += 1;
+    } else {
+      maps[version][String(start)].start = 1;
+    }
+    if (maps[version][String(end)].end) {
+      maps[version][String(end)].end += 1;
+    } else {
+      maps[version][String(end)].end = 1;
+    }
+  }
+  return maps;
+}
+function doMerge(maps) {
+  let start = null;
+  let end = null;
+  const numbers = Object.keys(maps);
+  let depth = 0;
+  const merged = [];
+  for (const [index, number] of numbers.entries()) {
+    const marker = maps[String(number)];
+    if (start === null && marker.start) {
+      start = BigInt(number);
+    }
+    if (marker.end) {
+      end = BigInt(number);
+    }
+    if (marker.start)
+      depth += marker.start;
+    if (marker.end)
+      depth -= marker.end;
+    const next = numbers[index + 1];
+    if (marker.end && depth === 0 && next && BigInt(next) - BigInt(number) > 1) {
+      for (const sub of subparts({ start, end })) {
+        merged.push(sub);
+      }
+      start = null;
+      end = null;
+    } else if (index === numbers.length - 1) {
+      for (const sub of subparts({ start, end })) {
+        merged.push(sub);
+      }
+    }
+  }
+  return merged;
+}
+function mergeCidr(nets) {
+  const arr = uniq((Array.isArray(nets) ? nets : [nets]).sort(compare).map(parseCidr));
+  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)];
+}
+function excludeCidr(base, excl) {
+  const basenets = mergeCidr(uniq(Array.isArray(base) ? base : [base]));
+  const exclnets = mergeCidr(uniq(Array.isArray(excl) ? excl : [excl]));
+  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]) {
+    for (const exclcidr of excls[v]) {
+      for (const [index, basecidr] of bases[v].entries()) {
+        const base2 = parseCidr(basecidr);
+        const excl2 = parseCidr(exclcidr);
+        const remainders = excludeNets(base2, excl2, v);
+        if (base2.cidr !== remainders.toString()) {
+          bases[v] = bases[v].concat(remainders);
+          bases[v].splice(index, 1);
+        }
+      }
+    }
+  }
+  return bases[4].concat(bases[6]).sort(compare);
+}
+function expandCidr(nets) {
+  const arr = uniq(Array.isArray(nets) ? nets : [nets]);
+  const ips = [];
+  for (const net of mergeCidr(arr)) {
+    const { start, end, version } = parseCidr(net);
+    for (let number = start; number <= end; number++) {
+      ips.push(stringifyIp({ number, version }));
+    }
+  }
+  return ips.map((ip) => normalizeCidr(ip));
+}
+function overlapCidr(a, b) {
+  const aNets = uniq(Array.isArray(a) ? a : [a]);
+  const bNets = uniq(Array.isArray(b) ? b : [b]);
+  for (const a2 of aNets) {
+    const aParsed = parseCidr(a2);
+    for (const b2 of bNets) {
+      const bParsed = parseCidr(b2);
+      if (aParsed.version !== bParsed.version) {
+        continue;
+      }
+      if (doNetsOverlap(aParsed, bParsed)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function containsCidr(a, b) {
+  const aNets = uniq(Array.isArray(a) ? a : [a]);
+  const bNets = uniq(Array.isArray(b) ? b : [b]);
+  const numExpected = bNets.length;
+  let numFound = 0;
+  for (const a2 of aNets) {
+    const aParsed = parseCidr(a2);
+    for (const b2 of bNets) {
+      const bParsed = parseCidr(b2);
+      if (aParsed.version !== bParsed.version) {
+        continue;
+      }
+      if (netContains(aParsed, bParsed)) {
+        numFound++;
+        continue;
+      }
+    }
+  }
+  return numFound === numExpected;
+}
+const index = {
+  mergeCidr,
+  excludeCidr,
+  expandCidr,
+  overlapCidr,
+  containsCidr,
+  normalizeCidr,
+  parseCidr
+};
+
+export { containsCidr, index as default, excludeCidr, expandCidr, mergeCidr, normalizeCidr, overlapCidr, parseCidr };

package/package.json

@@ -1,31 +1,35 @@
 {
   "name": "cidr-tools",
-  "version": "9.1.1",
+  "version": "10.0.1",
   "author": "silverwind <me@silverwind.io>",
   "description": "Tools to work with IPv4 and IPv6 CIDR",
   "repository": "silverwind/cidr-tools",
   "license": "BSD-2-Clause",
   "type": "module",
-  "exports": "./index.js",
-  "types": "index.d.ts",
   "sideEffects": false,
+  "main": "./dist/index.js",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "engines": {
     "node": ">=18"
   },
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ],
   "dependencies": {
-    "ip-bigint": "^8.0.2"
+    "ip-bigint": "^8.1.0"
   },
   "devDependencies": {
-    "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"
+    "@types/node": "20.12.12",
+    "eslint": "8.57.0",
+    "eslint-config-silverwind": "85.1.5",
+    "eslint-config-silverwind-typescript": "3.2.8",
+    "typescript-config-silverwind": "4.4.0",
+    "updates": "16.1.1",
+    "versions": "12.1.2",
+    "vite": "5.2.12",
+    "vite-config-silverwind": "2.1.4",
+    "vitest": "1.6.0",
+    "vitest-config-silverwind": "9.0.6"
   }
 }

package/index.d.ts

@@ -1,39 +0,0 @@
-type IPv4Address = string;
-type IPv4CIDR = string;
-type IPv6Address = string;
-type IPv6CIDR = string;
-type Network = IPv4Address | IPv4CIDR | IPv6Address | IPv6CIDR;
-type Networks = Network | Network[];
-
-type Parsed = {
-  cidr: string;
-  ip: string;
-  version: number;
-  prefix: string;
-  start: bigint;
-  end: bigint;
-};
-
-type NormalizeOpts = {
-  compress?: boolean;
-  hexify?: boolean;
-};
-
-export function mergeCidr(networks: Networks): Network[];
-export function excludeCidr(baseNetworks: Networks, excludeNetworks: Networks): Network[];
-export function expandCidr(networks: Networks): Network[];
-export function overlapCidr(networksA: Networks, networksB: Networks): boolean;
-export function normalizeCidr(cidr: Networks, opts?: NormalizeOpts): Networks;
-export function containsCidr(networksA: Networks, networksB: Networks): boolean;
-export function parseCidr(network: Network): Parsed;
-
-declare const _default: {
-  mergeCidr: typeof mergeCidr;
-  excludeCidr: typeof excludeCidr;
-  expandCidr: typeof expandCidr;
-  overlapCidr: typeof overlapCidr;
-  normalizeCidr: typeof normalizeCidr;
-  containsCidr: typeof containsCidr;
-  parseCidr: typeof parseCidr;
-};
-export default _default;

package/index.js

@@ -1,413 +0,0 @@
-import {parseIp, stringifyIp, normalizeIp, ipVersion} from "ip-bigint";
-
-const bits = {4: 32, 6: 128};
-const uniq = arr => Array.from(new Set(arr));
-const cidrVersion = cidr => cidr.includes("/") ? ipVersion(cidr) : 0;
-
-// TODO: pass parsed objects in here
-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;
-  }
-}
-
-function doNormalize(cidr, {compress = true, hexify = false} = {}) {
-  const {start, end, prefix, version} = parseCidr(cidr);
-  if (start !== end) { // cidr
-    // set network address to first address
-    const ip = normalizeIp(stringifyIp({number: start, version}), {compress, hexify});
-    return `${ip}/${prefix}`;
-  } else { // single ip
-    return normalizeIp(cidr, {compress, hexify});
-  }
-}
-
-export function normalizeCidr(cidr, {compress = true, hexify = false} = {}) {
-  if (Array.isArray(cidr)) {
-    return cidr.map(entry => normalizeCidr(entry, {compress, hexify}));
-  } else {
-    return doNormalize(cidr, {compress, hexify});
-  }
-}
-
-export function parseCidr(str) {
-  const cidrVer = cidrVersion(str);
-  const parsed = Object.create(null);
-
-  let cidr;
-  if (cidrVer) {
-    cidr = str;
-    parsed.version = cidrVer;
-  } else {
-    const version = ipVersion(str);
-    if (version) {
-      cidr = `${str}/${bits[version]}`;
-      parsed.version = 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, ipv4mapped, scopeid} = parseIp(ipAndMisc);
-  parsed.ip = stringifyIp({number, version, ipv4mapped, scopeid});
-  parsed.cidr = `${parsed.ip}/${prefix}`;
-  parsed.prefix = prefix;
-
-  const numBits = bits[version];
-  const ipBits = number.toString(2).padStart(numBits, "0");
-  const prefixLen = Number(numBits - prefix);
-  const startBits = ipBits.substring(0, numBits - prefixLen);
-  parsed.start = BigInt(`0b${startBits}${"0".repeat(prefixLen)}`);
-  parsed.end = BigInt(`0b${startBits}${"1".repeat(prefixLen)}`);
-  return parsed;
-}
-
-// returns whether networks fully or partially overlap
-function doNetsOverlap(a, b) {
-  //    aaa
-  // bbb
-  if (a.start > b.end) return false; // a starts after b
-
-  // aaa
-  //    bbb
-  if (b.start > a.end) return false; // b starts after a
-
-  return true;
-}
-
-// returns whether network a fully contains network b;
-function netContains(a, b) {
-  //  aaa
-  // bbbb
-  if (b.start < a.start) return false; // a starts after b
-
-  // aaa
-  // bbbb
-  if (b.end > a.end) return false; // b starts after a
-
-  return true;
-}
-
-// exclude b from a and return remainder cidrs
-function excludeNets(a, b, v) {
-  const parts = [];
-
-  // compareTo returns negative if left is less than right
-
-  //       aaa
-  //   bbb
-  //   aaa
-  //       bbb
-  if (a.start > b.end || a.end < b.start) {
-    return [a.cidr];
-  }
-
-  //   aaa
-  //   bbb
-  if (a.start === b.start && a.end === b.end) {
-    return [];
-  }
-
-  //   aa
-  //  bbbb
-  if (a.start > b.start && a.end < b.end) {
-    return [];
-  }
-
-  // aaaa
-  //   bbbb
-  // aaaa
-  //   bb
-  if (a.start < b.start && a.end <= b.end) {
-    parts.push({start: a.start, end: b.start - 1n});
-  }
-
-  //    aaa
-  //   bbb
-  //   aaaa
-  //   bbb
-  if (a.start >= b.start && a.end > b.end) {
-    parts.push({start: b.end + 1n, end: a.end});
-  }
-
-  //  aaaa
-  //   bb
-  if (a.start < b.start && a.end > b.end) {
-    parts.push(
-      {start: a.start, end: b.start - 1n},
-      {start: b.end + 1n, end: a.end},
-    );
-  }
-
-  const remaining = [];
-  for (const part of parts) {
-    for (const subpart of subparts(part)) {
-      remaining.push(formatPart(subpart, v));
-    }
-  }
-
-  return mergeCidr(remaining);
-}
-
-function biggestPowerOfTwo(num) {
-  if (num === 0n) return 0n;
-  return 2n ** BigInt(String(num.toString(2).length - 1));
-}
-
-function subparts(part) {
-  // special case for when part is length 1
-  if ((part.end - part.start) === 1n) {
-    if (part.end % 2n === 0n) {
-      return [{start: part.start, end: part.start}, {start: part.end, end: part.end}];
-    } else {
-      return [{start: part.start, end: part.end}];
-    }
-  }
-
-  const size = diff(part.end, part.start);
-  let biggest = biggestPowerOfTwo(size);
-
-  let start, end;
-  if (size === biggest && part.start + size === part.end) {
-    return [part];
-  } else if (part.start % biggest === 0n) {
-    // start is matching on the size-defined boundary - ex: 0-12, use 0-8
-    start = part.start;
-    end = start + biggest - 1n;
-  } else {
-    start = (part.end / biggest) * biggest;
-
-    // start is not matching on the size-defined boundary - 4-16, use 8-16
-    if ((start + biggest - 1n) > part.end) {
-      // divide will floor to nearest integer
-      start = ((part.end / biggest) - 1n) * biggest;
-
-      while (start < part.start) {
-        biggest /= 2n;
-        start = ((part.end / biggest) - 1n) * biggest;
-      }
-
-      end = start + biggest - 1n;
-    } else {
-      start = (part.end / biggest) * biggest;
-      end = start + biggest - 1n;
-    }
-  }
-
-  let parts = [{start, end}];
-
-  // additional subnets on left side
-  if (start !== part.start) {
-    parts = parts.concat(subparts({start: part.start, end: start - 1n}));
-  }
-
-  // additional subnets on right side
-  if (end !== part.end) {
-    parts = parts.concat(subparts({start: end + 1n, end: part.end}));
-  }
-
-  return parts;
-}
-
-function diff(a, b) {
-  if (typeof a !== "bigint") a = BigInt(a);
-  if (typeof b !== "bigint") b = BigInt(b);
-  a += 1n;
-  return a - b;
-}
-
-function formatPart(part, version) {
-  const ip = normalizeCidr(stringifyIp({number: BigInt(part.start.toString()), version}));
-  const zeroes = diff(part.end, part.start).toString(2);
-  const prefix = bits[version] - (zeroes.match(/0/g) || []).length;
-  return `${ip}/${prefix}`;
-}
-
-function mapNets(nets) {
-  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[version][start].start) {
-      maps[version][start].start += 1;
-    } else {
-      maps[version][start].start = 1;
-    }
-
-    if (maps[version][end].end) {
-      maps[version][end].end += 1;
-    } else {
-      maps[version][end].end = 1;
-    }
-  }
-  return maps;
-}
-
-function doMerge(maps) {
-  let start = null;
-  let end = null;
-  const numbers = Object.keys(maps);
-  let depth = 0;
-  const merged = [];
-
-  for (const [index, number] of numbers.entries()) {
-    const marker = maps[number];
-
-    if (start === null && marker.start) {
-      start = BigInt(number);
-    }
-    if (marker.end) {
-      end = BigInt(number);
-    }
-
-    if (marker.start) depth += marker.start;
-    if (marker.end) depth -= marker.end;
-
-    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(sub);
-      }
-      start = null;
-      end = null;
-    } else if (index === (numbers.length - 1)) {
-      // cut the final part
-      for (const sub of subparts({start, end})) {
-        merged.push(sub);
-      }
-    }
-  }
-  return merged;
-}
-
-export function mergeCidr(nets) {
-  // sort to workaround https://github.com/silverwind/cidr-tools/issues/17
-  nets = uniq((Array.isArray(nets) ? nets : [nets]).sort(compare).map(parseCidr));
-  const maps = mapNets(nets);
-
-  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)];
-}
-
-export function excludeCidr(basenets, exclnets) {
-  basenets = uniq(Array.isArray(basenets) ? basenets : [basenets]);
-  exclnets = uniq(Array.isArray(exclnets) ? exclnets : [exclnets]);
-
-  basenets = mergeCidr(basenets);
-  exclnets = mergeCidr(exclnets);
-
-  const bases = {4: [], 6: []};
-  const excls = {4: [], 6: []};
-
-  for (const basenet of basenets) {
-    bases[cidrVersion(basenet)].push(basenet);
-  }
-
-  for (const exclnet of exclnets) {
-    excls[cidrVersion(exclnet)].push(exclnet);
-  }
-
-  for (const v of [4, 6]) {
-    for (const exclcidr of excls[v]) {
-      for (const [index, basecidr] of bases[v].entries()) {
-        const base = parseCidr(basecidr);
-        const excl = parseCidr(exclcidr);
-        const remainders = excludeNets(base, excl, v);
-        if (base.cidr !== remainders.toString()) {
-          bases[v] = bases[v].concat(remainders);
-          bases[v].splice(index, 1);
-        }
-      }
-    }
-  }
-
-  return bases[4].concat(bases[6]).sort(compare);
-}
-
-export function expandCidr(nets) {
-  nets = uniq(Array.isArray(nets) ? nets : [nets]);
-
-  const ips = [];
-  for (const net of mergeCidr(nets)) {
-    const {start, end, version} = parseCidr(net);
-    for (let number = start; number <= end; number++) {
-      ips.push(stringifyIp({number, version}));
-    }
-  }
-  return ips.map(normalizeCidr);
-}
-
-export function overlapCidr(a, b) {
-  const aNets = uniq(Array.isArray(a) ? a : [a]);
-  const bNets = uniq(Array.isArray(b) ? b : [b]);
-
-  for (const a of aNets) {
-    const aParsed = parseCidr(a);
-    for (const b of bNets) {
-      const bParsed = parseCidr(b);
-
-      // version mismatch
-      if (aParsed.version !== bParsed.version) {
-        continue;
-      }
-
-      if (doNetsOverlap(aParsed, bParsed)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-export function containsCidr(a, b) {
-  const aNets = uniq(Array.isArray(a) ? a : [a]);
-  const bNets = uniq(Array.isArray(b) ? b : [b]);
-
-  const numExpected = bNets.length;
-  let numFound = 0;
-  for (const a of aNets) {
-    const aParsed = parseCidr(a);
-    for (const b of bNets) {
-      const bParsed = parseCidr(b);
-
-      // version mismatch
-      if (aParsed.version !== bParsed.version) {
-        continue;
-      }
-
-      if (netContains(aParsed, bParsed)) {
-        numFound++;
-        continue;
-      }
-    }
-  }
-
-  return numFound === numExpected;
-}
-
-export default {
-  mergeCidr,
-  excludeCidr,
-  expandCidr,
-  overlapCidr,
-  containsCidr,
-  normalizeCidr,
-  parseCidr,
-};