pmcf 1.37.1 → 1.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "1.37.1",
+  "version": "1.38.0",
   "publishConfig": {
     "access": "public"
   },

package/src/utils.mjs

@@ -57,60 +57,77 @@ export function normalizeIPAddress(address) {
   return parts.map(s => s.padStart(4, "0")).join(":");
 }
 
-function encodeIPv4(address) {
-  const octets = [0, 0, 0, 0];
-
-  let i = 0;
-  for (const a of address.split(/\./)) {
-    octets[i++] = parseInt(a);
+const ipv4 = {
+  separator: ".",
+  length: 32,
+  segmentLength: 8,
+  segmentMask: 0xffn,
+  mask: 0xffffffffn,
+  base: 10,
+  pad: 0
+};
+const ipv6 = {
+  separator: ":",
+  length: 128,
+  segmentLength: 16,
+  segmentMask: 0xffffn,
+  mask: 0xffffffffffffffffffffffffffffffffn,
+  base: 16,
+  pad: 4
+};
+
+function _decode(definition, address, length = definition.length) {
+  let words = [];
+  let shift = definition.length;
+
+  for (let i = 0; i < length / definition.segmentLength; i++) {
+    shift -= definition.segmentLength;
+    words.push(
+      ((address >> BigInt(shift)) & definition.segmentMask)
+        .toString(definition.base)
+        .padStart(definition.pad, "0")
+    );
   }
 
-  return (octets[0] << 24) + (octets[1] << 16) + (octets[2] << 8) + octets[3];
-}
-
-function decodeIPv4(address, length = 32) {
-  const octets = [
-    (address >> 24) & 0xff,
-    (address >> 16) & 0xff,
-    (address >> 8) & 0xff,
-    address & 0xff
-  ];
-
-  octets.length = Math.ceil(length / 8);
-
-  return octets.join(".");
+  return words.join(definition.separator);
 }
 
-export function encodeIPv6(address) {
-  const words = [0, 0, 0, 0, 0, 0, 0, 0];
-
-  let i = 0;
-  for (const a of normalizeIPAddress(address).split(/\:/)) {
-    words[i++] = parseInt(a,16);
-  }
-
+export function _encode(definition, address) {
   let res = 0n;
-  let shift = 128n;
+  let shift = BigInt(definition.length);
 
-  for(const word of words) {
-    shift -= 16n;
+  for (const word of normalizeIPAddress(address)
+    .split(definition.separator)
+    .map(a => parseInt(a, definition.base))) {
+    shift -= BigInt(definition.segmentLength);
     res += BigInt(word) << shift;
   }
 
   return res;
 }
 
-export function decodeIPv6(address, length = 128) {
+export function decodeIPv6(address, length) {
+  return _decode(ipv6, address, length);
+}
 
-  let words = [];
-  let shift = 128n;
+export function encodeIPv6(address) {
+  return _encode(ipv6, address);
+}
 
-  for(let i = 0; i < length / 16; i++) {
-    shift -= 16n;
-    words[i] = ((address >> shift) & 0xffffn).toString(16).padStart(4,'0');
-  }
+export function decodeIPv4(address, length) {
+  return _decode(ipv4, address, length);
+}
+
+export function encodeIPv4(address) {
+  return _encode(ipv4, address);
+}
+
+export function decodeIP(address, length) {
+  return _decode(isIPv4Address(address) ? ipv4 : ipv6, address, length);
+}
 
-  return words.join(":");
+export function encodeIP(address) {
+  return _encode(isIPv4Address(address) ? ipv4 : ipv6, address);
 }
 
 export function normalizeCIDR(address) {
@@ -121,15 +138,10 @@ export function normalizeCIDR(address) {
     prefixLength = 64;
   } else {
     if (prefixLength) {
-      if (isIPv4Address(prefix)) {
-        let n = encodeIPv4(prefix);
-        n = n & (0xffffffff << (32 - prefixLength));
-        prefix = decodeIPv4(n, prefixLength);
-      } else {
-        let n = encodeIPv6(prefix);
-        n = n & (0xffffffffffffffffffffffffffffffffn << (128n - BigInt(prefixLength)));
-        prefix = decodeIPv6(n, prefixLength);
-      }
+      const definition = isIPv4Address(prefix) ? ipv4 : ipv6;
+      let n = _encode(definition, prefix);
+      n = n & (definition.mask << BigInt(definition.length - prefixLength));
+      prefix = _decode(definition, n, prefixLength);
     } else {
       return {};
     }

package/types/utils.d.mts

@@ -6,8 +6,13 @@ export function isIPv4Address(address: any): boolean;
 export function isIPv6Address(address: any): boolean;
 export function isLinkLocal(address: any): any;
 export function normalizeIPAddress(address: any): any;
+export function _encode(definition: any, address: any): bigint;
+export function decodeIPv6(address: any, length: any): string;
 export function encodeIPv6(address: any): bigint;
-export function decodeIPv6(address: any, length?: number): string;
+export function decodeIPv4(address: any, length: any): string;
+export function encodeIPv4(address: any): bigint;
+export function decodeIP(address: any, length: any): string;
+export function encodeIP(address: any): bigint;
 export function normalizeCIDR(address: any): {
     prefix?: undefined;
     prefixLength?: undefined;