cidr-tools 11.1.0 → 11.2.1

package/dist/index.js

@@ -29,8 +29,23 @@ function parseIPv4Fast(s) {
 function formatIPv4Fast(n) {
 	return `${n >>> 24 & 255}.${n >>> 16 & 255}.${n >>> 8 & 255}.${n & 255}`;
 }
+function parsePrefixNum(str, slashIndex) {
+	if (slashIndex === -1) return -1;
+	if (slashIndex + 1 >= str.length) throw new Error(`Network is not a CIDR or IP: "${str}"`);
+	let prefixNum = 0;
+	for (let i = slashIndex + 1; i < str.length; i++) {
+		const c = str.charCodeAt(i);
+		if (c < 48 || c > 57) throw new Error(`Network is not a CIDR or IP: "${str}"`);
+		prefixNum = prefixNum * 10 + (c - 48);
+	}
+	return prefixNum;
+}
 function doNormalize(cidr, { compress = true, hexify = false } = {}) {
 	const { start, end, prefix, version, prefixPresent } = parseCidr(cidr);
+	if (version === 4) {
+		const ip = formatIPv4Fast(Number(start));
+		return start !== end || prefixPresent ? `${ip}/${prefix}` : ip;
+	}
 	if (start !== end || prefixPresent) return `${normalizeIp(stringifyIp({
 		number: start,
 		version
@@ -52,28 +67,55 @@ function normalizeCidr(cidr, opts) {
 function parseCidr(str) {
 	const slashIndex = str.indexOf("/");
 	let ipPart;
-	let prefix;
+	let prefixNum;
 	let prefixPresent;
 	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}"`);
+		prefixNum = parsePrefixNum(str, slashIndex);
 		prefixPresent = true;
 	} else {
 		ipPart = str;
+		prefixNum = -1;
 		prefixPresent = false;
-		prefix = "";
+	}
+	if (!ipPart.includes(":")) {
+		const v4num = parseIPv4Fast(ipPart);
+		if (v4num !== -1) {
+			if (prefixNum === -1) prefixNum = 32;
+			const ip = formatIPv4Fast(v4num);
+			const prefix = String(prefixNum);
+			const hostBits = 32 - prefixNum;
+			let startNum, endNum;
+			if (hostBits >= 32) {
+				startNum = 0;
+				endNum = 4294967295;
+			} else {
+				const mask = hostBits > 0 ? (1 << hostBits >>> 0) - 1 : 0;
+				startNum = (v4num & ~mask) >>> 0;
+				endNum = (v4num | mask) >>> 0;
+			}
+			return {
+				cidr: `${ip}/${prefix}`,
+				ip,
+				version: 4,
+				prefix,
+				prefixPresent,
+				start: BigInt(startNum),
+				end: BigInt(endNum)
+			};
+		}
 	}
 	const { number, version, ipv4mapped, scopeid } = parseIp(ipPart);
 	if (!version) throw new Error(`Network is not a CIDR or IP: "${str}"`);
-	if (!prefixPresent) prefix = String(bits[version]);
+	if (prefixNum === -1) prefixNum = bits[version];
+	const prefix = String(prefixNum);
 	const ip = stringifyIp({
 		number,
 		version,
 		ipv4mapped,
 		scopeid
 	});
-	const hostBits = bits[version] - Number(prefix);
+	const hostBits = bits[version] - prefixNum;
 	const mask = hostBits > 0 ? (1n << BigInt(hostBits)) - 1n : 0n;
 	return {
 		cidr: `${ip}/${prefix}`,
@@ -91,13 +133,7 @@ function parseCidrLean(str) {
 	let prefixNum;
 	if (slashIndex !== -1) {
 		ipPart = str.substring(0, slashIndex);
-		if (slashIndex + 1 >= str.length) throw new Error(`Network is not a CIDR or IP: "${str}"`);
-		prefixNum = 0;
-		for (let i = slashIndex + 1; i < str.length; i++) {
-			const c = str.charCodeAt(i);
-			if (c < 48 || c > 57) throw new Error(`Network is not a CIDR or IP: "${str}"`);
-			prefixNum = prefixNum * 10 + (c - 48);
-		}
+		prefixNum = parsePrefixNum(str, slashIndex);
 	} else {
 		ipPart = str;
 		prefixNum = -1;
@@ -108,14 +144,14 @@ function parseCidrLean(str) {
 			if (prefixNum === -1) prefixNum = 32;
 			const hostBits = 32 - prefixNum;
 			if (hostBits >= 32) return {
-				start: 0n,
-				end: 4294967295n,
+				start: 0,
+				end: 4294967295,
 				version: 4
 			};
 			const mask = hostBits > 0 ? (1 << hostBits >>> 0) - 1 : 0;
 			return {
-				start: BigInt((v4num & ~mask) >>> 0),
-				end: BigInt((v4num | mask) >>> 0),
+				start: (v4num & ~mask) >>> 0,
+				end: (v4num | mask) >>> 0,
 				version: 4
 			};
 		}
@@ -124,18 +160,114 @@ function parseCidrLean(str) {
 	if (!version) throw new Error(`Network is not a CIDR or IP: "${str}"`);
 	if (prefixNum === -1) prefixNum = bits[version];
 	const hostBits = bits[version] - prefixNum;
+	if (version === 4) {
+		const num = Number(number);
+		if (hostBits >= 32) return {
+			start: 0,
+			end: 4294967295,
+			version: 4
+		};
+		const mask = hostBits > 0 ? (1 << hostBits >>> 0) - 1 : 0;
+		return {
+			start: (num & ~mask) >>> 0,
+			end: (num | mask) >>> 0,
+			version: 4
+		};
+	}
 	const mask = hostBits > 0 ? (1n << BigInt(hostBits)) - 1n : 0n;
 	return {
 		start: number & ~mask,
 		end: number | mask,
-		version
+		version: 6
 	};
 }
+function bigintBitLength(n) {
+	if (n === 0n) return 0;
+	let len = 0;
+	if (n >= 18446744073709551616n) {
+		n >>= 64n;
+		len = 64;
+	}
+	while (n >= 4294967296n) {
+		n >>= 32n;
+		len += 32;
+	}
+	return len + 32 - Math.clz32(Number(n));
+}
 function biggestPowerOfTwo(num) {
 	if (num === 0n) return 0n;
-	return 1n << BigInt(num.toString(2).length - 1);
+	return 1n << BigInt(bigintBitLength(num) - 1);
+}
+function biggestPowerOfTwo4(num) {
+	if (num === 0) return 0;
+	if (num >= 4294967296) return 4294967296;
+	return 1 << 31 - Math.clz32(num) >>> 0;
+}
+function subparts4(pStart, pEnd, output) {
+	if (pEnd < pStart) return;
+	if (pEnd === pStart) {
+		output.push({
+			start: pStart,
+			end: pEnd
+		});
+		return;
+	}
+	if (pEnd - pStart === 1) {
+		if (pEnd % 2 === 0) output.push({
+			start: pStart,
+			end: pStart
+		}, {
+			start: pEnd,
+			end: pEnd
+		});
+		else output.push({
+			start: pStart,
+			end: pEnd
+		});
+		return;
+	}
+	const size = pEnd - pStart + 1;
+	if ((size & size - 1) === 0 && pStart % size === 0) {
+		output.push({
+			start: pStart,
+			end: pEnd
+		});
+		return;
+	}
+	let biggest = biggestPowerOfTwo4(size);
+	let start;
+	let end;
+	if (size === biggest && pStart % biggest === 0) {
+		output.push({
+			start: pStart,
+			end: pEnd
+		});
+		return;
+	} else if (pStart % biggest === 0) {
+		start = pStart;
+		end = start + biggest - 1;
+	} else {
+		start = Math.floor(pEnd / biggest) * biggest;
+		if (start + biggest - 1 > pEnd) {
+			start = (Math.floor(pEnd / biggest) - 1) * biggest;
+			while (start < pStart) {
+				biggest /= 2;
+				start = (Math.floor(pEnd / biggest) - 1) * biggest;
+			}
+			end = start + biggest - 1;
+		} else {
+			start = Math.floor(pEnd / biggest) * biggest;
+			end = start + biggest - 1;
+		}
+	}
+	if (start !== pStart) subparts4(pStart, start - 1, output);
+	output.push({
+		start,
+		end
+	});
+	if (end !== pEnd) subparts4(end + 1, pEnd, output);
 }
-function subparts(pStart, pEnd, output) {
+function subparts6(pStart, pEnd, output) {
 	if (pEnd < pStart) return;
 	if (pEnd === pStart) {
 		output.push({
@@ -158,58 +290,86 @@ function subparts(pStart, pEnd, output) {
 		});
 		return;
 	}
-	const size = diff(pEnd, pStart);
+	const size = pEnd - pStart + 1n;
+	if ((size & size - 1n) === 0n && (pStart & size - 1n) === 0n) {
+		output.push({
+			start: pStart,
+			end: pEnd
+		});
+		return;
+	}
 	let biggest = biggestPowerOfTwo(size);
 	let start;
 	let end;
-	if (size === biggest && pStart % biggest === 0n) {
+	if (size === biggest && (pStart & biggest - 1n) === 0n) {
 		output.push({
 			start: pStart,
 			end: pEnd
 		});
 		return;
-	} else if (pStart % biggest === 0n) {
+	} else if ((pStart & biggest - 1n) === 0n) {
 		start = pStart;
 		end = start + biggest - 1n;
 	} else {
-		start = pEnd / biggest * biggest;
+		start = pEnd & -biggest;
 		if (start + biggest - 1n > pEnd) {
-			start = (pEnd / biggest - 1n) * biggest;
+			start = (pEnd & -biggest) - biggest;
 			while (start < pStart) {
-				biggest /= 2n;
-				start = (pEnd / biggest - 1n) * biggest;
+				biggest >>= 1n;
+				start = (pEnd & -biggest) - biggest;
 			}
 			end = start + biggest - 1n;
 		} else {
-			start = pEnd / biggest * biggest;
+			start = pEnd & -biggest;
 			end = start + biggest - 1n;
 		}
 	}
-	if (start !== pStart) subparts(pStart, start - 1n, output);
+	if (start !== pStart) subparts6(pStart, start - 1n, output);
 	output.push({
 		start,
 		end
 	});
-	if (end !== pEnd) subparts(end + 1n, pEnd, output);
+	if (end !== pEnd) subparts6(end + 1n, pEnd, output);
 }
-function diff(a, b) {
-	return a + 1n - b;
+function formatPart4(part) {
+	const ip = formatIPv4Fast(part.start);
+	const size = part.end - part.start + 1;
+	return `${ip}/${32 - (size <= 1 ? 0 : size >= 4294967296 ? 32 : 31 - Math.clz32(size))}`;
 }
-function formatPart(part, version) {
-	if (version === 4) {
-		const ip = formatIPv4Fast(Number(part.start));
-		const sizeNum = Number(part.end - part.start) + 1;
-		return `${ip}/${32 - (sizeNum <= 1 ? 0 : sizeNum >= 4294967296 ? 32 : 31 - Math.clz32(sizeNum))}`;
-	}
+function formatPart6(part) {
 	const ip = stringifyIp({
 		number: part.start,
-		version
+		version: 6
 	});
-	const size = diff(part.end, part.start);
-	const hostBits = size <= 1n ? 0 : size.toString(2).length - 1;
-	return `${ip}/${bits[version] - hostBits}`;
+	const size = part.end - part.start + 1n;
+	return `${ip}/${128 - (size <= 1n ? 0 : bigintBitLength(size) - 1)}`;
 }
-function mergeIntervalsRaw(nets) {
+function mergeIntervalsRaw4(nets) {
+	if (nets.length === 0) return [];
+	nets.sort((a, b) => a.start - b.start || a.end - b.end);
+	const merged = [];
+	let curStart = nets[0].start;
+	let curEnd = nets[0].end;
+	for (let i = 1; i < nets.length; i++) {
+		const { start, end } = nets[i];
+		if (start <= curEnd + 1) {
+			if (end > curEnd) curEnd = end;
+		} else {
+			merged.push({
+				start: curStart,
+				end: curEnd
+			});
+			curStart = start;
+			curEnd = end;
+		}
+	}
+	merged.push({
+		start: curStart,
+		end: curEnd
+	});
+	return merged;
+}
+function mergeIntervalsRaw6(nets) {
 	if (nets.length === 0) return [];
 	nets.sort((a, b) => a.start > b.start ? 1 : a.start < b.start ? -1 : a.end > b.end ? 1 : a.end < b.end ? -1 : 0);
 	const merged = [];
@@ -234,12 +394,42 @@ function mergeIntervalsRaw(nets) {
 	});
 	return merged;
 }
-function mergeIntervals(nets) {
+function mergeIntervals4(nets) {
 	const merged = [];
-	for (const part of mergeIntervalsRaw(nets)) subparts(part.start, part.end, merged);
+	for (const part of mergeIntervalsRaw4(nets)) subparts4(part.start, part.end, merged);
 	return merged;
 }
-function subtractSorted(bases, excls) {
+function mergeIntervals6(nets) {
+	const merged = [];
+	for (const part of mergeIntervalsRaw6(nets)) subparts6(part.start, part.end, merged);
+	return merged;
+}
+function subtractSorted4(bases, excls) {
+	if (excls.length === 0) return bases;
+	if (bases.length === 0) return [];
+	const result = [];
+	let j = 0;
+	for (const base of bases) {
+		let start = base.start;
+		const end = base.end;
+		while (j < excls.length && excls[j].end < start) j++;
+		let k = j;
+		while (k < excls.length && excls[k].start <= end && start <= end) {
+			if (excls[k].start > start) result.push({
+				start,
+				end: excls[k].start - 1
+			});
+			start = excls[k].end + 1;
+			k++;
+		}
+		if (start <= end) result.push({
+			start,
+			end
+		});
+	}
+	return result;
+}
+function subtractSorted6(bases, excls) {
 	if (excls.length === 0) return bases;
 	if (bases.length === 0) return [];
 	const result = [];
@@ -266,83 +456,104 @@ function subtractSorted(bases, excls) {
 }
 /** Returns an array of merged networks */
 function mergeCidr(nets) {
-	const arr = (Array.isArray(nets) ? nets : [nets]).map(parseCidrLean);
-	const byVersion = {
-		4: [],
-		6: []
-	};
-	for (const n of arr) byVersion[n.version].push(n);
+	const arr = Array.isArray(nets) ? nets : [nets];
+	const v4 = [];
+	const v6 = [];
+	for (const s of arr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4.push(n);
+		else v6.push(n);
+	}
 	const merged = [];
-	for (const v of [4, 6]) for (const part of mergeIntervals(byVersion[v])) merged.push(formatPart(part, v));
+	for (const part of mergeIntervals4(v4)) merged.push(formatPart4(part));
+	for (const part of mergeIntervals6(v6)) merged.push(formatPart6(part));
 	return merged;
 }
 /** Returns an array of merged remaining networks of the subtraction of `excludeNetworks` from `baseNetworks`. */
 function excludeCidr(base, excl) {
-	const baseArr = (Array.isArray(base) ? base : [base]).map(parseCidrLean);
-	const exclArr = (Array.isArray(excl) ? excl : [excl]).map(parseCidrLean);
-	const baseByVersion = {
-		4: [],
-		6: []
-	};
-	const exclByVersion = {
-		4: [],
-		6: []
-	};
-	for (const n of baseArr) baseByVersion[n.version].push(n);
-	for (const n of exclArr) exclByVersion[n.version].push(n);
+	const baseArr = Array.isArray(base) ? base : [base];
+	const exclArr = Array.isArray(excl) ? excl : [excl];
+	const v4base = [], v6base = [];
+	const v4excl = [], v6excl = [];
+	for (const s of baseArr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4base.push(n);
+		else v6base.push(n);
+	}
+	for (const s of exclArr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4excl.push(n);
+		else v6excl.push(n);
+	}
 	const result = [];
-	for (const v of [4, 6]) {
-		const remaining = subtractSorted(mergeIntervalsRaw(baseByVersion[v]), mergeIntervalsRaw(exclByVersion[v]));
+	{
+		const remaining = subtractSorted4(mergeIntervalsRaw4(v4base), mergeIntervalsRaw4(v4excl));
 		const aligned = [];
-		for (const part of remaining) subparts(part.start, part.end, aligned);
-		for (const p of aligned) result.push(formatPart(p, v));
+		for (const part of remaining) subparts4(part.start, part.end, aligned);
+		for (const p of aligned) result.push(formatPart4(p));
+	}
+	{
+		const remaining = subtractSorted6(mergeIntervalsRaw6(v6base), mergeIntervalsRaw6(v6excl));
+		const aligned = [];
+		for (const part of remaining) subparts6(part.start, part.end, aligned);
+		for (const p of aligned) result.push(formatPart6(p));
 	}
 	return result;
 }
 function* expandCidr(nets) {
-	const parsed = (Array.isArray(nets) ? nets : [nets]).map(parseCidrLean);
-	const byVersion = {
-		4: [],
-		6: []
-	};
-	for (const n of parsed) byVersion[n.version].push(n);
-	for (const v of [4, 6]) {
-		if (byVersion[v].length === 0) continue;
-		const intervals = mergeIntervalsRaw(byVersion[v]);
-		if (v === 4) for (const part of intervals) {
-			const startNum = Number(part.start);
-			const endNum = Number(part.end);
-			for (let n = startNum; n <= endNum; n++) yield formatIPv4Fast(n);
-		}
-		else for (const part of intervals) for (let num = part.start; num <= part.end; num++) yield stringifyIp({
-			number: num,
-			version: 6
-		});
+	const arr = Array.isArray(nets) ? nets : [nets];
+	const v4 = [];
+	const v6 = [];
+	for (const s of arr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4.push(n);
+		else v6.push(n);
 	}
+	if (v4.length > 0) for (const part of mergeIntervalsRaw4(v4)) for (let n = part.start; n <= part.end; n++) yield formatIPv4Fast(n);
+	if (v6.length > 0) for (const part of mergeIntervalsRaw6(v6)) for (let num = part.start; num <= part.end; num++) yield stringifyIp({
+		number: num,
+		version: 6
+	});
 }
 /** Returns a boolean that indicates if `networksA` overlap (intersect) with `networksB`. */
 function overlapCidr(a, b) {
-	const aNets = (Array.isArray(a) ? a : [a]).map(parseCidrLean);
-	const bNets = (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);
+	if (!Array.isArray(a) && !Array.isArray(b)) {
+		const pa = parseCidrLean(a);
+		const pb = parseCidrLean(b);
+		if (pa.version !== pb.version) return false;
+		return pa.start <= pb.end && pb.start <= pa.end;
+	}
+	const aArr = Array.isArray(a) ? a : [a];
+	const bArr = Array.isArray(b) ? b : [b];
+	const v4a = [], v6a = [];
+	const v4b = [], v6b = [];
+	for (const s of aArr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4a.push(n);
+		else v6a.push(n);
+	}
+	for (const s of bArr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4b.push(n);
+		else v6b.push(n);
+	}
+	if (v4a.length > 0 && v4b.length > 0) {
+		v4a.sort((x, y) => x.start - y.start);
+		v4b.sort((x, y) => x.start - y.start);
+		let i = 0, j = 0;
+		while (i < v4a.length && j < v4b.length) {
+			if (v4a[i].start <= v4b[j].end && v4b[j].start <= v4a[i].end) return true;
+			if (v4a[i].end < v4b[j].end) i++;
+			else j++;
+		}
+	}
+	if (v6a.length > 0 && v6b.length > 0) {
+		v6a.sort((x, y) => x.start > y.start ? 1 : x.start < y.start ? -1 : 0);
+		v6b.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++;
+		while (i < v6a.length && j < v6b.length) {
+			if (v6a[i].start <= v6b[j].end && v6b[j].start <= v6a[i].end) return true;
+			if (v6a[i].end < v6b[j].end) i++;
 			else j++;
 		}
 	}
@@ -350,33 +561,57 @@ function overlapCidr(a, b) {
 }
 /** Returns a boolean that indicates whether `networksA` fully contain all `networksB`. */
 function containsCidr(a, b) {
-	const aNets = (Array.isArray(a) ? a : [a]).map(parseCidrLean);
-	const bNets = (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;
+	if (!Array.isArray(a) && !Array.isArray(b)) {
+		const pa = parseCidrLean(a);
+		const pb = parseCidrLean(b);
+		if (pa.version !== pb.version) return false;
+		return pa.start <= pb.start && pa.end >= pb.end;
+	}
+	const aArr = Array.isArray(a) ? a : [a];
+	const bArr = Array.isArray(b) ? b : [b];
+	const v4a = [], v6a = [];
+	const v4b = [], v6b = [];
+	for (const s of aArr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4a.push(n);
+		else v6a.push(n);
+	}
+	for (const s of bArr) {
+		const n = parseCidrLean(s);
+		if (n.version === 4) v4b.push(n);
+		else v6b.push(n);
+	}
+	if (v4b.length > 0) {
+		if (v4a.length === 0) return false;
+		v4a.sort((x, y) => x.start - y.start);
+		const maxEnd = new Array(v4a.length);
+		maxEnd[0] = v4a[0].end;
+		for (let i = 1; i < v4a.length; i++) maxEnd[i] = Math.max(v4a[i].end, maxEnd[i - 1]);
+		for (const target of v4b) {
+			let lo = 0, hi = v4a.length - 1;
+			let idx = -1;
+			while (lo <= hi) {
+				const mid = lo + hi >> 1;
+				if (v4a[mid].start <= target.start) {
+					idx = mid;
+					lo = mid + 1;
+				} else hi = mid - 1;
+			}
+			if (idx < 0 || maxEnd[idx] < target.end) return false;
+		}
+	}
+	if (v6b.length > 0) {
+		if (v6a.length === 0) return false;
+		v6a.sort((x, y) => x.start > y.start ? 1 : x.start < y.start ? -1 : 0);
+		const maxEnd = new Array(v6a.length);
+		maxEnd[0] = v6a[0].end;
+		for (let i = 1; i < v6a.length; i++) maxEnd[i] = v6a[i].end > maxEnd[i - 1] ? v6a[i].end : maxEnd[i - 1];
+		for (const target of v6b) {
+			let lo = 0, hi = v6a.length - 1;
 			let idx = -1;
 			while (lo <= hi) {
 				const mid = lo + hi >> 1;
-				if (containers[mid].start <= target.start) {
+				if (v6a[mid].start <= target.start) {
 					idx = mid;
 					lo = mid + 1;
 				} else hi = mid - 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cidr-tools",
-  "version": "11.1.0",
+  "version": "11.2.1",
   "author": "silverwind <me@silverwind.io>",
   "description": "Tools to work with IPv4 and IPv6 CIDR",
   "repository": "silverwind/cidr-tools",
@@ -17,19 +17,19 @@
     "node": ">=18"
   },
   "dependencies": {
-    "ip-bigint": "^8.2.9"
+    "ip-bigint": "^8.2.12"
   },
   "devDependencies": {
-    "@types/node": "25.3.3",
-    "@typescript/native-preview": "7.0.0-dev.20260305.1",
-    "eslint": "9.39.3",
-    "eslint-config-silverwind": "121.2.0",
+    "@types/node": "25.4.0",
+    "@typescript/native-preview": "7.0.0-dev.20260311.1",
+    "eslint": "9.39.4",
+    "eslint-config-silverwind": "124.0.7",
     "jest-extended": "7.0.0",
-    "tsdown": "0.21.0",
-    "tsdown-config-silverwind": "2.0.0",
+    "tsdown": "0.21.2",
+    "tsdown-config-silverwind": "2.0.1",
     "typescript": "5.9.3",
     "typescript-config-silverwind": "15.0.0",
-    "updates": "17.8.1",
+    "updates": "17.9.0",
     "updates-config-silverwind": "1.0.3",
     "versions": "14.2.1",
     "vitest": "4.0.18",