cidr-tools 12.1.3 → 13.0.1

package/README.md

@@ -33,24 +33,27 @@ parseCidr("::/64");
 
 All functions take CIDR addresses or single IP addresses. On single addresses, a prefix of `/32` or `/128` is assumed. Function that return networks will return a merged and sorted set of networks with IPv4 sorted before IPv6.
 
-It is expected that the passed CIDRs and IPs are validated as the module's own input validation is rudimentary. You are encouraged to use modules like [is-cidr](https://github.com/silverwind/is-cidr) and [is-ip](https://github.com/sindresorhus/is-ip) to validate before passing to this module.
+Networks are validated with [cidr-regex](https://github.com/silverwind/cidr-regex) and anything that is not a CIDR or IP address throws, including out-of-family prefixes like `1.2.3.4/33` and ambiguous zero-padded octets like `010.0.0.1`.
+
+Every function takes a trailing `[opts]` *Object*:
+  - `validate`: Whether to reject networks that are not a CIDR or IP address. `false` skips the check for input already known to be valid, and then malformed input is parsed on a best-effort basis. Default: `true`.
 
 This module requires [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#browser_compatibility) support in your environment.
 
-### mergeCidr(networks)
+### mergeCidr(networks, [opts])
 
 - `networks` *String* or *Array*: One or more CIDR or IP addresses.
 
 Returns an array of merged networks.
 
-### excludeCidr(baseNetworks, excludeNetworks)
+### excludeCidr(baseNetworks, excludeNetworks, [opts])
 
 - `baseNetworks` *String* or *Array*: One or more CIDR or IP addresses.
 - `excludeNetworks` *String* or *Array*: One or more CIDR or IP addresses to exclude from `baseNetworks`.
 
 Returns an array of merged remaining networks of the subtraction of `excludeNetworks` from `baseNetworks`.
 
-### expandCidr(networks)
+### expandCidr(networks, [opts])
 
 - `networks` *String* or *Array*: One or more CIDR or IP addresses.
 
@@ -67,14 +70,14 @@ if (end - start >= 1000000n) {
 }
 ```
 
-### overlapCidr(networksA, networksB)
+### overlapCidr(networksA, networksB, [opts])
 
 - `networksA` *String* or *Array*: One or more CIDR or IP address.
 - `networksB` *String* or *Array*: One or more CIDR or IP address.
 
 Returns a boolean that indicates if `networksA` overlap (intersect) with `networksB`.
 
-### containsCidr(networksA, networksB)
+### containsCidr(networksA, networksB, [opts])
 
 - `networksA` *String* or *Array*: One or more CIDR or IP address.
 - `networksB` *String* or *Array*: One or more CIDR or IP address.
@@ -87,11 +90,11 @@ Returns a boolean that indicates whether `networksA` fully contain all `networks
 
 Returns a string or array (depending on input) with a normalized representation. Will not include a prefix on single IPs. Will set network address to the start of the network.
 
-`opts`: *Object*
+`opts`: *Object*, additionally to `validate`:
   - `compress`: Whether to compress the IP. For IPv6, this means the "best representation" all-lowercase shortest possible form. Default: `true`.
   - `hexify`: Whether to convert IPv4-Mapped IPv6 addresses to hex. Default: `false`.
 
-### parseCidr(network)
+### parseCidr(network, [opts])
 
 - `network` *String*: A CIDR or IP address.
 
@@ -109,9 +112,7 @@ Returns a `parsed` Object which is used internally by this module. It can be use
 ## Related
 
 - [ip-bigint](https://github.com/silverwind/ip-bigint) - Convert IPv4 and IPv6 addresses to native BigInt and vice-versa
-- [ip-regex](https://github.com/sindresorhus/ip-regex) - Regular expression for matching IP addresses
 - [is-cidr](https://github.com/silverwind/is-cidr) - Check if a string is an IP address in CIDR notation
-- [is-ip](https://github.com/sindresorhus/is-ip) - Check if a string is an IP address
-- [cidr-regex](https://github.com/silverwind/cidr-regex) - Check if a string is an IP address in CIDR notation
+- [cidr-regex](https://github.com/silverwind/cidr-regex) - Regular expression for matching IP addresses in CIDR notation and bare IP addresses
 
 © [silverwind](https://github.com/silverwind), distributed under BSD licence.

package/dist/index.d.ts

@@ -11,24 +11,30 @@ type ParsedCidr = {
   start: bigint;
   end: bigint;
 };
+type CidrOpts = {
+  /** Whether to reject networks that are not a CIDR or IP address. Default: `true` */
+  validate?: boolean;
+};
 type NormalizeOpts = {
+  /** Whether to reject networks that are not a CIDR or IP address. Default: `true` */
+  validate?: boolean;
   compress?: boolean;
   hexify?: boolean;
 };
 /** Returns a string or array (depending on input) with a normalized representation. Will not include a prefix on single IPs. Will set network address to the start of the network. */
 declare function normalizeCidr<T extends Networks>(cidr: T, opts?: NormalizeOpts): T;
 /** 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. */
-declare function parseCidr(str: Network): ParsedCidr;
+declare function parseCidr(str: Network, opts?: CidrOpts): ParsedCidr;
 /** Returns an array of merged networks */
-declare function mergeCidr(nets: Networks): Array<Network>;
+declare function mergeCidr(nets: Networks, opts?: CidrOpts): Array<Network>;
 /** Returns an array of merged remaining networks of the subtraction of `excludeNetworks` from `baseNetworks`. */
-declare function excludeCidr(base: Networks, excl: Networks): Array<Network>;
+declare function excludeCidr(base: Networks, excl: Networks, opts?: CidrOpts): Array<Network>;
 /** Returns a generator for individual IPs contained in the networks. */
-declare function expandCidr(nets: Networks): Generator<Network>;
+declare function expandCidr(nets: Networks, opts?: CidrOpts): Generator<Network>;
 /** Returns a boolean that indicates if `networksA` overlap (intersect) with `networksB`. */
-declare function overlapCidr(a: Networks, b: Networks): boolean;
+declare function overlapCidr(a: Networks, b: Networks, opts?: CidrOpts): boolean;
 /** Returns a boolean that indicates whether `networksA` fully contain all `networksB`. */
-declare function containsCidr(a: Networks, b: Networks): boolean;
+declare function containsCidr(a: Networks, b: Networks, opts?: CidrOpts): boolean;
 declare const _default: {
   mergeCidr: typeof mergeCidr;
   excludeCidr: typeof excludeCidr;

package/dist/index.js

@@ -1,4 +1,5 @@
-import { normalizeIp, parseIp, stringifyIp } from "ip-bigint";
+import cidrRegex from "cidr-regex";
+import { parseIp, stringifyIp } from "ip-bigint";
 
 //#region index.ts
 const bits = {
@@ -13,10 +14,30 @@ const hexStrings = Array.from({ length: 256 }, (_, i) => i.toString(16));
 const hexPadStrings = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 const hostMasks = Array.from({ length: 129 }, (_, i) => (1n << BigInt(i)) - 1n);
 const hostNotMasks = hostMasks.map((mask) => ~mask);
+const networkRe = cidrRegex({
+	exact: true,
+	prefix: "optional"
+});
+const unchecked = { validate: false };
+function invalidNetwork(net) {
+	return /* @__PURE__ */ new Error(`Network is not a CIDR or IP: "${net}"`);
+}
+function checkNetwork(net) {
+	if (!networkRe.test(net)) throw invalidNetwork(net);
+}
+function checkNetworks(nets, opts) {
+	if (opts?.validate === false) return;
+	if (typeof nets === "string") checkNetwork(nets);
+	else for (const net of nets) checkNetwork(net);
+}
 const cmpV4StartEnd = (a, b) => a.start - b.start || a.end - b.end;
 const cmpV4Start = (a, b) => a.start - b.start;
 const cmpV6StartEnd = (a, b) => a.start > b.start ? 1 : a.start < b.start ? -1 : a.end > b.end ? 1 : a.end < b.end ? -1 : 0;
 const cmpV6Start = (a, b) => a.start > b.start ? 1 : a.start < b.start ? -1 : 0;
+const hostMasks4 = Int32Array.from({ length: 33 }, (_, i) => i === 32 ? -1 : (1 << i) - 1);
+function formatIPv4Fast(n) {
+	return octetDotStrings[n >>> 24 & 255] + octetDotStrings[n >>> 16 & 255] + octetDotStrings[n >>> 8 & 255] + octetStrings[n & 255];
+}
 function parseIPv4Fast(s, end) {
 	let num = 0;
 	let octet = 0;
@@ -24,31 +45,26 @@ function parseIPv4Fast(s, end) {
 	let digits = 0;
 	for (let i = 0; i < end; i++) {
 		const c = s.charCodeAt(i);
-		if (c === 46) {
+		if (c >= 48 && c <= 57) {
+			octet = octet * 10 + (c - 48);
+			digits++;
+		} else if (c === 46) {
 			if (digits === 0 || octet > 255) return -1;
 			num = num << 8 | octet;
 			octet = 0;
 			dots++;
 			digits = 0;
-		} else if (c >= 48 && c <= 57) {
-			octet = octet * 10 + (c - 48);
-			digits++;
 		} else return -1;
 	}
 	if (dots !== 3 || digits === 0 || octet > 255) return -1;
 	return (num << 8 | octet) >>> 0;
 }
-const hostMasks4 = Int32Array.from({ length: 33 }, (_, i) => i === 32 ? -1 : (1 << i) - 1);
-function formatIPv4Fast(n) {
-	return octetDotStrings[n >>> 24 & 255] + octetDotStrings[n >>> 16 & 255] + octetDotStrings[n >>> 8 & 255] + octetStrings[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}"`);
+	if (slashIndex + 1 >= str.length) throw invalidNetwork(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}"`);
+		if (c < 48 || c > 57) throw invalidNetwork(str);
 		prefixNum = prefixNum * 10 + (c - 48);
 	}
 	return prefixNum;
@@ -58,9 +74,32 @@ let rangeV4End = 0;
 let rangeV4Prefix = 0;
 let rangeSlashIndex = -1;
 function parseIPv4Range(str) {
-	rangeSlashIndex = str.indexOf("/");
-	const v4num = parseIPv4Fast(str, rangeSlashIndex !== -1 ? rangeSlashIndex : str.length);
-	if (v4num === -1) return false;
+	const len = str.length;
+	let num = 0;
+	let octet = 0;
+	let dots = 0;
+	let digits = 0;
+	let i = 0;
+	for (; i < len; i++) {
+		const c = str.charCodeAt(i);
+		if (c >= 48 && c <= 57) {
+			octet = octet * 10 + (c - 48);
+			digits++;
+		} else if (c === 46) {
+			if (digits === 0 || octet > 255) break;
+			num = num << 8 | octet;
+			octet = 0;
+			dots++;
+			digits = 0;
+		} else break;
+	}
+	if (i < len && str.charCodeAt(i) === 47) rangeSlashIndex = i;
+	else {
+		rangeSlashIndex = str.indexOf("/", i);
+		if (i < len) return false;
+	}
+	if (dots !== 3 || digits === 0 || octet > 255) return false;
+	const v4num = (num << 8 | octet) >>> 0;
 	rangeV4Prefix = rangeSlashIndex !== -1 ? parsePrefixNum(str, rangeSlashIndex) : 32;
 	const mask = hostMasks4[Math.max(32 - rangeV4Prefix, 0)];
 	rangeV4Start = (v4num & ~mask) >>> 0;
@@ -75,7 +114,7 @@ function doNormalize(cidr, opts) {
 	const slashIndex = rangeSlashIndex;
 	const prefixPresent = slashIndex !== -1;
 	let prefixNum = prefixPresent ? parsePrefixNum(cidr, slashIndex) : -1;
-	const { number, version, ipv4mapped, scopeid } = parseIp(prefixPresent ? cidr.substring(0, slashIndex) : cidr);
+	const { number, version, ipv4mapped, scopeid } = parseIp(prefixPresent ? cidr.substring(0, slashIndex) : cidr, unchecked);
 	if (prefixNum === -1) prefixNum = bits[version];
 	if (version === 4) {
 		const hostBits = 32 - prefixNum;
@@ -83,44 +122,49 @@ function doNormalize(cidr, opts) {
 		const ip = formatIPv4Fast((Number(number) & ~mask) >>> 0);
 		return hostBits > 0 || prefixPresent ? ip + prefixStrings[prefixNum] : ip;
 	}
-	const { compress = true, hexify = false } = opts || {};
+	const compress = opts?.compress ?? true;
+	const hexify = opts?.hexify ?? false;
 	const hostBits = 128 - prefixNum;
-	if (hostBits <= 0 && !prefixPresent) return normalizeIp(cidr, {
+	if (hostBits <= 0 && !prefixPresent) return stringifyIp({
+		number,
+		version,
+		ipv4mapped,
+		scopeid
+	}, {
 		compress,
 		hexify
 	});
 	const start = hostBits > 0 ? number & hostNotMasks[hostBits] : number;
-	const ip = stringifyIp({
+	return stringifyIp({
 		number: start,
 		version,
 		ipv4mapped: ipv4mapped && start >> 32n === 65535n,
 		scopeid
-	}, { hexify });
-	return (compress ? ip : normalizeIp(ip, {
+	}, {
 		compress,
 		hexify
-	})) + prefixStrings[prefixNum];
+	}) + prefixStrings[prefixNum];
 }
 /** Returns a string or array (depending on input) with a normalized representation. Will not include a prefix on single IPs. Will set network address to the start of the network. */
 function normalizeCidr(cidr, opts) {
+	checkNetworks(cidr, opts);
 	return typeof cidr === "string" ? doNormalize(cidr, opts) : cidr.map((entry) => doNormalize(entry, opts));
 }
 /** 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. */
-function parseCidr(str) {
+function parseCidr(str, opts) {
+	if (opts?.validate !== false) checkNetwork(str);
 	const slashIndex = str.indexOf("/");
-	const ipEnd = slashIndex !== -1 ? slashIndex : str.length;
 	const prefixPresent = slashIndex !== -1;
-	const v4num = parseIPv4Fast(str, ipEnd);
+	const v4num = parseIPv4Fast(str, prefixPresent ? slashIndex : str.length);
 	if (v4num !== -1) {
 		const prefixNum = prefixPresent ? parsePrefixNum(str, slashIndex) : 32;
 		const ip = formatIPv4Fast(v4num);
-		const prefix = prefixNumStrings[prefixNum] ?? String(prefixNum);
 		const mask = hostMasks4[Math.max(32 - prefixNum, 0)];
 		return {
 			cidr: ip + prefixStrings[prefixNum],
 			ip,
 			version: 4,
-			prefix,
+			prefix: prefixNumStrings[prefixNum] ?? String(prefixNum),
 			prefixPresent,
 			start: BigInt((v4num & ~mask) >>> 0),
 			end: BigInt((v4num | mask) >>> 0)
@@ -128,8 +172,7 @@ function parseCidr(str) {
 	}
 	const ipPart = prefixPresent ? str.substring(0, slashIndex) : str;
 	let prefixNum = prefixPresent ? parsePrefixNum(str, slashIndex) : -1;
-	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(ipPart, unchecked);
 	const numBits = bits[version];
 	if (prefixNum === -1) prefixNum = numBits;
 	const prefix = prefixNumStrings[prefixNum] ?? String(prefixNum);
@@ -156,17 +199,11 @@ function parseCidr(str) {
 		end
 	};
 }
-function parseCidrLean(str) {
-	if (parseIPv4Range(str)) return {
-		start: rangeV4Start,
-		end: rangeV4End,
-		version: 4
-	};
+function parseCidrLeanSlow(str) {
 	const slashIndex = rangeSlashIndex;
 	const ipPart = slashIndex !== -1 ? str.substring(0, slashIndex) : str;
 	let prefixNum = slashIndex !== -1 ? parsePrefixNum(str, slashIndex) : -1;
-	const { number, version } = parseIp(ipPart);
-	if (!version) throw new Error(`Network is not a CIDR or IP: "${str}"`);
+	const { number, version } = parseIp(ipPart, unchecked);
 	const numBits = bits[version];
 	if (prefixNum === -1) prefixNum = numBits;
 	const hostBits = numBits - prefixNum;
@@ -190,6 +227,14 @@ function parseCidrLean(str) {
 		version: 6
 	};
 }
+function parseCidrLean(str) {
+	if (parseIPv4Range(str)) return {
+		start: rangeV4Start,
+		end: rangeV4End,
+		version: 4
+	};
+	return parseCidrLeanSlow(str);
+}
 function bigintBitLength(n) {
 	if (n === 0n) return 0;
 	let len = 0;
@@ -203,10 +248,6 @@ function bigintBitLength(n) {
 	}
 	return len + 32 - Math.clz32(Number(n));
 }
-function biggestPowerOfTwo(num) {
-	if (num === 0n) return 0n;
-	return 1n << BigInt(bigintBitLength(num) - 1);
-}
 function biggestPowerOfTwo4(num) {
 	if (num === 0) return 0;
 	if (num >= 4294967296) return 4294967296;
@@ -236,63 +277,50 @@ function subparts6(pStart, pEnd, output) {
 	while (start <= pEnd) {
 		const size = pEnd - start + 1n;
 		const lowBit = start & -start;
-		const blockSize = lowBit !== 0n && lowBit <= size ? lowBit : biggestPowerOfTwo(size);
+		const alignedFully = lowBit !== 0n && lowBit <= size;
+		const blockBits = bigintBitLength(alignedFully ? lowBit : size);
 		output.push(stringifyIp({
 			number: start,
 			version: 6
-		}) + prefixStrings[129 - bigintBitLength(blockSize)]);
-		start += blockSize;
+		}) + prefixStrings[129 - blockBits]);
+		start += alignedFully ? lowBit : 1n << BigInt(blockBits - 1);
 	}
 }
 function mergeIntervalsRaw4(nets) {
-	if (nets.length === 0) return [];
+	if (nets.length < 2) return nets;
 	nets.sort(cmpV4StartEnd);
-	const merged = [];
-	let curStart = nets[0].start;
-	let curEnd = nets[0].end;
+	let last = 0;
+	let cur = nets[0];
 	for (let i = 1; i < nets.length; i++) {
 		const { start, end } = nets[i];
-		if (start <= curEnd + 1) {
-			if (end > curEnd) curEnd = end;
+		if (start <= cur.end + 1) {
+			if (end > cur.end) cur.end = end;
 		} else {
-			merged.push({
-				start: curStart,
-				end: curEnd
-			});
-			curStart = start;
-			curEnd = end;
+			cur = nets[++last];
+			cur.start = start;
+			cur.end = end;
 		}
 	}
-	merged.push({
-		start: curStart,
-		end: curEnd
-	});
-	return merged;
+	nets.length = last + 1;
+	return nets;
 }
 function mergeIntervalsRaw6(nets) {
-	if (nets.length === 0) return [];
+	if (nets.length < 2) return nets;
 	nets.sort(cmpV6StartEnd);
-	const merged = [];
-	let curStart = nets[0].start;
-	let curEnd = nets[0].end;
+	let last = 0;
+	let cur = nets[0];
 	for (let i = 1; i < nets.length; i++) {
 		const { start, end } = nets[i];
-		if (start <= curEnd + 1n) {
-			if (end > curEnd) curEnd = end;
+		if (start <= cur.end + 1n) {
+			if (end > cur.end) cur.end = end;
 		} else {
-			merged.push({
-				start: curStart,
-				end: curEnd
-			});
-			curStart = start;
-			curEnd = end;
+			cur = nets[++last];
+			cur.start = start;
+			cur.end = end;
 		}
 	}
-	merged.push({
-		start: curStart,
-		end: curEnd
-	});
-	return merged;
+	nets.length = last + 1;
+	return nets;
 }
 function subtractSorted4(bases, excls) {
 	if (excls.length === 0) return bases;
@@ -345,7 +373,8 @@ function subtractSorted6(bases, excls) {
 	return result;
 }
 /** Returns an array of merged networks */
-function mergeCidr(nets) {
+function mergeCidr(nets, opts) {
+	checkNetworks(nets, opts);
 	const v4 = [], v6 = [];
 	for (const str of typeof nets === "string" ? [nets] : nets) {
 		const net = parseCidrLean(str);
@@ -358,7 +387,9 @@ function mergeCidr(nets) {
 	return merged;
 }
 /** Returns an array of merged remaining networks of the subtraction of `excludeNetworks` from `baseNetworks`. */
-function excludeCidr(base, excl) {
+function excludeCidr(base, excl, opts) {
+	checkNetworks(base, opts);
+	checkNetworks(excl, opts);
 	const v4base = [], v6base = [];
 	const v4excl = [], v6excl = [];
 	for (const str of typeof base === "string" ? [base] : base) {
@@ -377,7 +408,11 @@ function excludeCidr(base, excl) {
 	return result;
 }
 /** Returns a generator for individual IPs contained in the networks. */
-function* expandCidr(nets) {
+function expandCidr(nets, opts) {
+	checkNetworks(nets, opts);
+	return expandChecked(nets);
+}
+function* expandChecked(nets) {
 	const v4 = [], v6 = [];
 	for (const str of typeof nets === "string" ? [nets] : nets) {
 		const net = parseCidrLean(str);
@@ -424,16 +459,18 @@ function* expandCidr(nets) {
 	}
 }
 /** Returns a boolean that indicates if `networksA` overlap (intersect) with `networksB`. */
-function overlapCidr(a, b) {
+function overlapCidr(a, b, opts) {
+	checkNetworks(a, opts);
+	checkNetworks(b, opts);
 	if (typeof a === "string" && typeof b === "string") {
 		if (parseIPv4Range(a)) {
 			const startA = rangeV4Start, endA = rangeV4End;
 			if (parseIPv4Range(b)) return startA <= rangeV4End && rangeV4Start <= endA;
-			const pb = parseCidrLean(b);
+			const pb = parseCidrLeanSlow(b);
 			if (pb.version !== 4) return false;
 			return startA <= pb.end && pb.start <= endA;
 		}
-		const pa = parseCidrLean(a);
+		const pa = parseCidrLeanSlow(a);
 		const pb = parseCidrLean(b);
 		if (pa.version !== pb.version) return false;
 		return pa.start <= pb.end && pb.start <= pa.end;
@@ -481,16 +518,18 @@ function overlapCidr(a, b) {
 	return false;
 }
 /** Returns a boolean that indicates whether `networksA` fully contain all `networksB`. */
-function containsCidr(a, b) {
+function containsCidr(a, b, opts) {
+	checkNetworks(a, opts);
+	checkNetworks(b, opts);
 	if (typeof a === "string" && typeof b === "string") {
 		if (parseIPv4Range(a)) {
 			const startA = rangeV4Start, endA = rangeV4End;
 			if (parseIPv4Range(b)) return startA <= rangeV4Start && endA >= rangeV4End;
-			const pb = parseCidrLean(b);
+			const pb = parseCidrLeanSlow(b);
 			if (pb.version !== 4) return false;
 			return startA <= pb.start && endA >= pb.end;
 		}
-		const pa = parseCidrLean(a);
+		const pa = parseCidrLeanSlow(a);
 		const pb = parseCidrLean(b);
 		if (pa.version !== pb.version) return false;
 		return pa.start <= pb.start && pa.end >= pb.end;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cidr-tools",
-  "version": "12.1.3",
+  "version": "13.0.1",
   "author": "silverwind <me@silverwind.io>",
   "description": "Tools to work with IPv4 and IPv6 CIDR",
   "keywords": [
@@ -29,7 +29,8 @@
     "bun": "*"
   },
   "dependencies": {
-    "ip-bigint": "^9.0.7"
+    "cidr-regex": "^7.1.0",
+    "ip-bigint": "^10.0.1"
   },
   "devDependencies": {
     "@types/node": "26.1.2",