pmcf 2.15.1 → 2.16.0

package/package.json

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

package/src/cli.mjs

@@ -1,8 +1,9 @@
 import { parseArgs } from "node:util";
+import { resolve } from "node:path";
 import { argv, cwd, env } from "node:process";
 import { Root } from "./module.mjs";
 
-export async function prepare(options={}) {  
+export async function prepare(options = {}) {
   const { values, positionals } = parseArgs({
     args: argv.slice(2),
     options: {
@@ -17,7 +18,7 @@ export async function prepare(options={}) {
         default: false
       },
       publish: {
-        type: "string",
+        type: "string"
       },
       root: {
         type: "string",
@@ -32,9 +33,13 @@ export async function prepare(options={}) {
     allowPositionals: true
   });
 
+  if (values.output) {
+    values.output = resolve(cwd(), values.output);
+  }
+
   const root = new Root(values.root);
 
   await root.loadAll();
-  
+
   return { root, options: values, args: positionals };
 }

package/src/dns-utils.mjs

@@ -1,10 +1,5 @@
-import {
-  asIterator,
-  decodeIPv6,
-  encodeIPv6,
-  isIPv6Address,
-  normalizeIPAddress
-} from "./utils.mjs";
+import { asIterator } from "./utils.mjs";
+import { decodeIPv4, decodeIPv6 } from "./ip.mjs";
 
 export function dnsFullName(name) {
   return name.endsWith(".") ? name : name + ".";
@@ -19,10 +14,10 @@ export function DNSRecord(key, type, ...values) {
       break;
 
     case "A":
-      values[0] = normalizeIPAddress(values[0]);
+      values[0] = decodeIPv4(values[0]);
       break;
     case "AAAA":
-      values[0] = decodeIPv6(encodeIPv6(values[0]));
+      values[0] = decodeIPv6(values[0]);
       break;
   }
 
@@ -59,22 +54,3 @@ export function dnsMergeParameters(a, b) {
     ])
   );
 }
-
-export function reverseAddress(address) {
-  if (isIPv6Address(address)) {
-    return normalizeIPAddress(address)
-      .replaceAll(":", "")
-      .split("")
-      .reverse()
-      .join(".");
-  }
-
-  return address.split(".").reverse().join(".");
-}
-
-export function reverseArpaAddress(address) {
-  return (
-    reverseAddress(address) +
-    (isIPv6Address(address) ? ".ip6.arpa" : ".in-addr.arpa")
-  );
-}

package/src/host-utils.mjs

@@ -1,13 +1,5 @@
-import {
-  writeFile,
-  mkdir,
-  copyFile,
-  glob,
-  chmod,
-  stat
-} from "node:fs/promises";
+import { writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { FileContentProvider } from "npm-pkgbuild";
 import { writeLines, sectionLines } from "../src/utils.mjs";
 import { addHook } from "./hooks.mjs";
 

package/src/host.mjs

@@ -6,16 +6,14 @@ import {
   networkProperties,
   networkAddressProperties
 } from "./network-support.mjs";
+import { asArray, domainFromDominName, domainName } from "./utils.mjs";
 import {
-  asArray,
-  isIPv4Address,
-  isIPv6Address,
-  normalizeIPAddress,
+  isIPv4,
+  isIPv6,
   formatCIDR,
   hasWellKnownSubnet,
-  domainFromDominName,
-  domainName
-} from "./utils.mjs";
+  normalizeIP
+} from "./ip.mjs";
 import { objectFilter } from "./filter.mjs";
 import { addType, types } from "./types.mjs";
 import { loadHooks } from "./hooks.mjs";
@@ -582,7 +580,7 @@ export class NetworkInterface extends Base {
   set ipAddresses(value) {
     for (const address of asArray(value)) {
       this._ipAddresses.set(
-        normalizeIPAddress(address),
+        normalizeIP(address),
         this.addSubnet(address)
       );
     }
@@ -593,11 +591,11 @@ export class NetworkInterface extends Base {
   }
 
   get rawIPv4Address() {
-    return this.rawAddresses.filter(a => isIPv4Address(a))[0];
+    return this.rawAddresses.filter(a => isIPv4(a))[0];
   }
 
   get rawIPv6Address() {
-    return this.rawAddresses.filter(a => isIPv6Address(a))[0];
+    return this.rawAddresses.filter(a => isIPv6(a))[0];
   }
 
   get rawAddresses() {
@@ -616,13 +614,13 @@ export class NetworkInterface extends Base {
 
   get rawIPv4Addresses() {
     return [...this.ipAddresses]
-      .filter(([address]) => isIPv4Address(address))
+      .filter(([address]) => isIPv4(address))
       .map(([address]) => address);
   }
 
   get rawIPv6Addresses() {
     return [...this.ipAddresses]
-      .filter(([address]) => isIPv6Address(address))
+      .filter(([address]) => isIPv6(address))
       .map(([address]) => address);
   }
 

package/src/ip.mjs

@@ -0,0 +1,298 @@
+const ipv4 = {
+  factory: Uint8Array,
+  normalize(address) {
+    return address;
+  },
+  separator: ".",
+  bitLength: 32,
+  byteLength: 4,
+  segments: 4,
+  segmentLength: 8,
+  segmentMask: 0xffn,
+  mask: 0xffffffffn,
+  base: 10
+};
+
+const ipv6 = {
+  factory: Uint16Array,
+  normalize(address) {
+    const parts = address.split(":");
+    const i = parts.indexOf("");
+    if (i >= 0) {
+      parts.splice(i, 1, ..."0".repeat(9 - parts.length));
+    }
+    return parts /*.map(s => s.padStart(4, "0"))*/
+      .join(":");
+  },
+  separator: ":",
+  compressor: "::",
+  bitLength: 128,
+  byteLength: 8,
+  segments: 8,
+  segmentLength: 16,
+  segmentMask: 0xffffn,
+  mask: 0xffffffffffffffffffffffffffffffffn,
+  base: 16
+};
+
+export function IPV4(...args) {
+  return _create(ipv4, ...args);
+}
+
+export function IPV6(...args) {
+  return _create(ipv6, ...args);
+}
+
+function _create(definition, ...args) {
+  if (args.length === 1) {
+    return _encode(definition, args[0]);
+  }
+  return new definition.factory(args);
+}
+
+export function encodeIP(address) {
+  return _encode(isIPv4(address) ? ipv4 : ipv6, address);
+}
+
+export function encodeIPv6(address) {
+  return _encode(ipv6, address);
+}
+
+export function encodeIPv4(address) {
+  return _encode(ipv4, address);
+}
+
+export function _encode(definition, address) {
+  switch (typeof address) {
+    case "string":
+      const res = new definition.factory(definition.segments);
+
+      let i = 0;
+      for (const segment of definition
+        .normalize(address)
+        .split(definition.separator)) {
+        res[i++] = parseInt(segment, definition.base);
+      }
+
+      return res;
+
+    case "object":
+      if (
+        address instanceof definition.factory &&
+        address.length === definition.byteLength
+      ) {
+        return address;
+      }
+  }
+}
+
+function _decode(definition, address, length) {
+  switch (typeof address) {
+    case "string":
+      if (length === undefined) {
+        return address;
+      }
+      address = _encode(definition, address);
+      break;
+    case "bigint":
+      address = _encodeBigInt(definition, address);
+  }
+
+  let result = "";
+  let compressed = 0;
+  let word;
+  let last = address?.length;
+
+  if (length !== undefined) {
+    length /= definition.segmentLength;
+
+    if (length < last) {
+      last = length;
+    }
+  }
+  for (let i = 0, j = 0; i < last; j = j + 1, i = j) {
+    for (; j < last; j++) {
+      word = address[j];
+
+      if (word !== 0 || !definition.compressor || compressed > 0) {
+        break;
+      }
+    }
+
+    if (j > i + 1) {
+      compressed++;
+      result += definition.compressor;
+    } else {
+      if (result.length > 0) {
+        result += definition.separator;
+      }
+    }
+
+    if (j < last) {
+      result += word.toString(definition.base);
+    }
+  }
+
+  return result;
+}
+
+export function decodeIPv6(address, length) {
+  return _decode(ipv6, address, length);
+}
+
+export function decodeIPv4(address, length) {
+  return _decode(ipv4, address, length);
+}
+
+export function decodeIP(address, length) {
+  return _decode(isIPv4(address) ? ipv4 : ipv6, address, length);
+}
+
+export function isIPv4(address) {
+  return _is(ipv4, address);
+}
+
+export function isIPv6(address) {
+  return _is(ipv6, address);
+}
+
+export function _is(definition, address) {
+  switch (typeof address) {
+    case "string":
+      return address.indexOf(definition.separator) >= 0;
+
+    case "object":
+      return (
+        address instanceof definition.factory &&
+        address.length === definition.byteLength
+      );
+  }
+
+  return false;
+}
+
+export function asBigInt(address) {
+  return _asBigInt(isIPv4(address) ? ipv4 : ipv6, address);
+}
+
+function _asBigInt(definition, address) {
+  if (typeof address === "bigint") {
+    return address;
+  }
+
+  const ea = _encode(definition, address);
+
+  let result = 0n;
+
+  for (let i = 0; i < ea.length; i++) {
+    result = result << BigInt(definition.segmentLength);
+    result += BigInt(ea[i]);
+  }
+
+  return result;
+}
+
+function _encodeBigInt(definition, address) {
+  const segments = [];
+
+  for (let i = 0; i < definition.segments; i++) {
+    segments.push(Number(address & definition.segmentMask));
+    address >>= BigInt(definition.segmentLength);
+  }
+
+  return new definition.factory(segments.reverse());
+}
+
+export function prefixIP(address, length) {
+  const definition = isIPv4(address) ? ipv4 : ipv6;
+  return _decode(definition, _prefix(definition, address, length));
+}
+
+export function _prefix(definition, address, length) {
+  return (
+    _asBigInt(definition, address) &
+    (definition.mask << BigInt(definition.bitLength - length))
+  );
+}
+
+export function normalizeCIDR(address) {
+  let [prefix, prefixLength] = address.split(/\//);
+  let longPrefix;
+
+  if (!prefixLength && isLinkLocal(address)) {
+    prefix = "fe80::";
+    longPrefix = prefix;
+    prefixLength = 64;
+  } else {
+    prefixLength = parseInt(prefixLength);
+
+    const definition = isIPv6(prefix) ? ipv6 : ipv4;
+    let n;
+
+    if (prefixLength) {
+      n = _prefix(definition, prefix, prefixLength);
+    } else {
+      n = _encode(definition, prefix);
+
+      if (isLocalhost(n)) {
+        prefixLength = definition === ipv6 ? 128 : 8;
+      } else {
+        return {};
+      }
+    }
+    prefix = _decode(definition, n, prefixLength);
+    longPrefix = _decode(definition, n);
+  }
+
+  return { longPrefix, prefix, prefixLength, cidr: `${prefix}/${prefixLength}` };
+}
+
+export function formatCIDR(address, subnet) {
+  return subnet ? `${address}/${subnet.prefixLength}` : address;
+}
+
+export function normalizeIP(address) {
+  return decodeIP(encodeIP(address));
+}
+
+export function reverseArpa(address) {
+  if (isIPv6(address)) {
+    const ea = encodeIPv6(address);
+    let result = [];
+    for (let i = 0; i < ea.length; i++) {
+      const v = ea[i];
+      for (let i = 0; i < 4; i++) {
+        result.push(((v >> (12 - 4 * i)) & 0x000f).toString(16));
+      }
+    }
+    return result.reverse().join(".") + ".ip6.arpa";
+  }
+
+  return address.split(".").reverse().join(".") + ".in-addr.arpa";
+}
+
+export function isLocalhost(address) {
+  const eaddr = encodeIP(address);
+
+  if (!eaddr) {
+    return false;
+  }
+
+  const str = eaddr.toString();
+
+  return str === IPV4_LOCALHOST.toString() || str === IPV6_LOCALHOST.toString();
+}
+
+export function isLinkLocal(address) {
+  const eaddr = encodeIP(address);
+  return eaddr[0] === 0xfe80;
+}
+
+export function hasWellKnownSubnet(address) {
+  return isLocalhost(address) || isLinkLocal(address);
+}
+
+export const IPV6_LINK_LOCAL_BROADCAST = _encode(ipv6, "ff02::1");
+export const IPV6_ROUTER_BROADCAST = _encode(ipv6, "ff02::2");
+export const IPV4_LOCALHOST = _encode(ipv4, "127.0.0.1");
+export const IPV6_LOCALHOST = _encode(ipv6, "::1");

package/src/owner.mjs

@@ -1,8 +1,8 @@
-import { asIterator, normalizeCIDR } from "./utils.mjs";
+import { asIterator } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { Subnet } from "./subnet.mjs";
 import { addType, types } from "./types.mjs";
-
+import { normalizeCIDR } from "./ip.mjs";
 const OwnerTypeDefinition = {
   name: "owner",
   owners: ["location", "owner", "root"],

package/src/service.mjs

@@ -1,8 +1,9 @@
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
 import { objectFilter } from "./filter.mjs";
-import { asArray, isLocalhost } from "./utils.mjs";
+import { asArray } from "./utils.mjs";
 import { networkAddressProperties } from "./network-support.mjs";
+import { isLocalhost } from "./ip.mjs";
 import {
   DNSRecord,
   dnsFullName,

package/src/services/dhcp.mjs

@@ -7,7 +7,8 @@ import {
   serviceEndpoints
 } from "../service.mjs";
 import { addType } from "../types.mjs";
-import { writeLines, isIPv4Address, isIPv6Address } from "../utils.mjs";
+import { writeLines } from "../utils.mjs";
+import { isIPv4, isIPv6 } from "../ip.mjs";
 
 const DHCPServiceTypeDefinition = {
   name: "dhcp",
@@ -145,7 +146,7 @@ export class DHCPService extends Service {
         return {
           name: domain,
           "dns-servers": dnsServerEndpoints
-            .filter(endpoint => isIPv4Address(endpoint.rawAddress))
+            .filter(endpoint => isIPv4(endpoint.rawAddress))
             .map(endpoint => {
               return { "ip-address": endpoint.rawAddress };
             })
@@ -229,7 +230,7 @@ export class DHCPService extends Service {
       Dhcp4: {
         ...commonConfig,
         "interfaces-config": {
-          interfaces: listenInterfaces(isIPv4Address)
+          interfaces: listenInterfaces(isIPv4)
         },
         "multi-threading": {
           "enable-multi-threading": false
@@ -242,7 +243,7 @@ export class DHCPService extends Service {
           {
             name: "domain-name-servers",
             data: dnsServerEndpoints
-              .filter(endpoint => isIPv4Address(endpoint.rawAddress))
+              .filter(endpoint => isIPv4(endpoint.rawAddress))
               .map(endpoint => endpoint.rawAddress)
               .join(",")
           },
@@ -275,7 +276,7 @@ export class DHCPService extends Service {
       Dhcp6: {
         ...commonConfig,
         "interfaces-config": {
-          interfaces: listenInterfaces(isIPv6Address)
+          interfaces: listenInterfaces(isIPv6)
         },
         "control-socket": {
           "socket-type": "unix",
@@ -286,7 +287,7 @@ export class DHCPService extends Service {
           {
             name: "dns-servers",
             data: dnsServerEndpoints
-              .filter(endpoint => isIPv6Address(endpoint.rawAddress))
+              .filter(endpoint => isIPv6(endpoint.rawAddress))
               .map(endpoint => endpoint.rawAddress)
               .join(",")
           }

package/src/services/dns.mjs

@@ -1,13 +1,9 @@
 import { join } from "node:path";
 import { createHmac } from "node:crypto";
 import { FileContentProvider } from "npm-pkgbuild";
-import {
-  writeLines,
-  isIPv6Address,
-  isLinkLocal,
-  isLocalhost
-} from "../utils.mjs";
-import { DNSRecord, dnsFullName, reverseArpaAddress } from "../dns-utils.mjs";
+import { writeLines } from "../utils.mjs";
+import { isIPv6, isLinkLocal, isLocalhost, reverseArpa } from "../ip.mjs";
+import { DNSRecord, dnsFullName } from "../dns-utils.mjs";
 import { addType } from "../types.mjs";
 import { ServiceTypeDefinition, serviceAddresses } from "../service.mjs";
 import {
@@ -211,9 +207,10 @@ export class DNSService extends ExtraSourceService {
       yield packageData;
     }
 
-    const p2 = (packageData.dir = join(dir, "p2"));
+    const p2 = join(dir, "p2");
 
     packageData.properties = {
+      dir: p2,
       name: `named-zones-${name}`,
       description: `zone definitions for ${location.fullName}`,
       dependencies: ["mf-named"],
@@ -292,7 +289,7 @@ async function generateZoneDefs(dns, location, packageData) {
       for (const address of host.rawAddresses) {
         if (!isLocalhost(address)) {
           zone.records.add(
-            DNSRecord("@", isIPv6Address(address) ? "AAAA" : "A", address)
+            DNSRecord("@", isIPv6(address) ? "AAAA" : "A", address)
           );
         }
       }
@@ -366,7 +363,7 @@ async function generateZoneDefs(dns, location, packageData) {
             zone.records.add(
               DNSRecord(
                 dnsFullName(domainName),
-                isIPv6Address(address) ? "AAAA" : "A",
+                isIPv6(address) ? "AAAA" : "A",
                 address
               )
             );
@@ -375,11 +372,11 @@ async function generateZoneDefs(dns, location, packageData) {
             let reverseZone = reverseZones.get(subnet.address);
 
             if (!reverseZone) {
-              const reverseArpa = reverseArpaAddress(subnet.prefix);
+              const id = reverseArpa(subnet.prefix);
               reverseZone = {
-                id: reverseArpa,
+                id,
                 type: "plain",
-                file: `${locationName}/${reverseArpa}.zone`,
+                file: `${locationName}/${id}.zone`,
                 records: new Set([SOARecord, NSRecord])
               };
               config.zones.push(reverseZone);
@@ -389,7 +386,7 @@ async function generateZoneDefs(dns, location, packageData) {
             for (const domainName of host.domainNames) {
               reverseZone.records.add(
                 DNSRecord(
-                  dnsFullName(reverseArpaAddress(address)),
+                  dnsFullName(reverseArpa(address)),
                   "PTR",
                   dnsFullName(domainName)
                 )

package/src/subnet.mjs

@@ -1,10 +1,4 @@
-import {
-  normalizeCIDR,
-  isLinkLocal,
-  isIPv4Address,
-  isIPv6Address,
-  addressWithPrefixLength
-} from "./utils.mjs";
+import { normalizeCIDR, isLinkLocal, isIPv4, isIPv6, prefixIP } from "./ip.mjs";
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
 
@@ -37,9 +31,13 @@ export class Subnet extends Base {
   }
 
   constructor(owner, address) {
-    const { cidr } = normalizeCIDR(address);
+    const { longPrefix, prefix, prefixLength, cidr } = normalizeCIDR(address);
     super(owner, cidr);
     owner.addObject(this);
+
+    this.prefix = prefix;
+    this.prefixLength = prefixLength;
+    this.longPrefix = longPrefix;
   }
 
   get fullName() {
@@ -55,36 +53,20 @@ export class Subnet extends Base {
   }
 
   get isIPv4() {
-    return isIPv4Address(this.address);
+    return isIPv4(this.address);
   }
 
   get isIPv6() {
-    return isIPv6Address(this.address);
+    return isIPv6(this.address);
   }
 
   get addressRange() {
     return [
-      addressWithPrefixLength(this.prefix, this.prefixLength),
+      prefixIP(this.prefix, this.prefixLength),
       this.prefix + ".255".repeat((32 - this.prefixLength) / 8)
     ];
   }
 
-  get longPrefix() {
-    return addressWithPrefixLength(this.prefix, this.prefixLength);
-  }
-
-  get prefix() {
-    const [prefix] = this.name.split("/");
-    return prefix;
-  }
-
-  get prefixLength() {
-    const m = this.name.match(/\/(\d+)$/);
-    if (m) {
-      return parseInt(m[1]);
-    }
-  }
-
   get address() {
     return this.name;
   }

package/src/utils.mjs

@@ -77,205 +77,3 @@ export function asIterator(value) {
 
   return asArray(value);
 }
-
-export function isIPv4Address(address) {
-  switch (typeof address) {
-    case "string":
-      return address.indexOf(".") >= 0;
-  }
-
-  return false;
-}
-
-export function isIPv6Address(address) {
-  switch (typeof address) {
-    case "string":
-      return address.indexOf(":") >= 0;
-  }
-
-  return false;
-}
-
-export function isLinkLocal(address) {
-  switch (typeof address) {
-    case "string":
-      return address.startsWith("fe80");
-
-    case "bigint":
-      return ((address >> 112n) & 0xffffn) === 0xfe80n;
-  }
-
-  return false;
-}
-
-export function generateEU64(mac) {
-  //TODO
-}
-
-export function isLocalhost(address) {
-  const eaddr = encodeIP(address);
-  return eaddr === IPV4_LOCALHOST || eaddr === IPV6_LOCALHOST;
-}
-
-export function normalizeIPAddress(address) {
-  address = address.replace(/\/\d+$/, "");
-  if (isIPv4Address(address)) {
-    return address;
-  }
-  const parts = address.split(":");
-  const i = parts.indexOf("");
-  if (i >= 0) {
-    parts.splice(i, 1, ..."0".repeat(9 - parts.length));
-  }
-  return parts.map(s => s.padStart(4, "0")).join(":");
-}
-
-const ipv4 = {
-  separator: ".",
-  length: 32,
-  segmentLength: 8,
-  segmentMask: 0xffn,
-  mask: 0xffffffffn,
-  base: 10
-};
-const ipv6 = {
-  separator: ":",
-  compressor: "::",
-  length: 128,
-  segmentLength: 16,
-  segmentMask: 0xffffn,
-  mask: 0xffffffffffffffffffffffffffffffffn,
-  base: 16
-};
-
-export function addressWithPrefixLength(address, prefixLength) {
-  const definition = ipv4;
-
-  return (
-    address +
-    ".0".repeat((definition.length - prefixLength) / definition.segmentLength)
-  );
-}
-
-function _decode(definition, address, length = definition.length) {
-  if (typeof address === "string") {
-    return address;
-  }
-
-  let result = "";
-  let compressed = 0;
-  let shift = definition.length;
-  let word;
-  const last = length / definition.segmentLength;
-
-  for (let i = 0, j = 0; i < last; j = j + 1, i = j) {
-    for (; j < last; j++) {
-      shift -= definition.segmentLength;
-      word = (address >> BigInt(shift)) & definition.segmentMask;
-
-      if (word !== 0n || !definition.compressor || compressed > 0) {
-        break;
-      }
-    }
-
-    if (j > i + 1) {
-      compressed++;
-      result += definition.compressor;
-    } else {
-      if (result.length > 0) {
-        result += definition.separator;
-      }
-    }
-
-    if (j < last) {
-      result += word.toString(definition.base);
-    }
-  }
-
-  return result;
-}
-
-export function _encode(definition, address) {
-  if (typeof address !== "string") {
-    return address;
-  }
-
-  let res = 0n;
-  let shift = BigInt(definition.length);
-
-  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) {
-  return _decode(ipv6, address, length);
-}
-
-export function encodeIPv6(address) {
-  return _encode(ipv6, address);
-}
-
-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);
-}
-
-export function encodeIP(address) {
-  return _encode(isIPv4Address(address) ? ipv4 : ipv6, address);
-}
-
-export function formatCIDR(address, subnet) {
-  return subnet ? `${address}/${subnet.prefixLength}` : address;
-}
-
-export function normalizeCIDR(address) {
-  let [prefix, prefixLength] = address.split(/\//);
-
-  if (!prefixLength && isLinkLocal(address)) {
-    prefix = "fe80::";
-    prefixLength = 64;
-  } else {
-    const definition = isIPv6Address(prefix) ? ipv6 : ipv4;
-    let n = _encode(definition, prefix);
-
-    if (prefixLength) {
-      n = n & (definition.mask << BigInt(definition.length - prefixLength));
-      prefix = _decode(definition, n, prefixLength);
-    } else {
-      if (n === IPV4_LOCALHOST) {
-        prefixLength = 8;
-        prefix = _decode(definition, n, prefixLength);
-      } else if (n === IPV6_LOCALHOST) {
-        prefixLength = 128;
-        prefix = _decode(definition, n, prefixLength);
-      } else {
-        return {};
-      }
-    }
-  }
-
-  return { prefix, prefixLength, cidr: `${prefix}/${prefixLength}` };
-}
-
-export function hasWellKnownSubnet(address) {
-  const n = encodeIP(address);
-  return n === IPV4_LOCALHOST || n === IPV6_LOCALHOST || isLinkLocal(address);
-}
-
-export const IPV4_LOCALHOST = _encode(ipv4, "127.0.0.1");
-export const IPV6_LOCALHOST = _encode(ipv6, "::1");
-export const IPV6_LINK_LOCAL_BROADCAST = _encode(ipv6, "ff02::1");
-export const IPV6_ROUTER_BROADCAST = _encode(ipv6, "ff02::2");

package/types/dns-utils.d.mts

@@ -7,5 +7,3 @@ export function dnsFormatParameters(parameters: any): string;
 export function dnsMergeParameters(a: any, b: any): {
     [k: string]: Set<any>;
 };
-export function reverseAddress(address: any): any;
-export function reverseArpaAddress(address: any): string;

package/types/ip.d.mts

@@ -0,0 +1,36 @@
+export function IPV4(...args: any[]): any;
+export function IPV6(...args: any[]): any;
+export function encodeIP(address: any): any;
+export function encodeIPv6(address: any): any;
+export function encodeIPv4(address: any): any;
+export function _encode(definition: any, address: any): any;
+export function decodeIPv6(address: any, length: any): string;
+export function decodeIPv4(address: any, length: any): string;
+export function decodeIP(address: any, length: any): string;
+export function isIPv4(address: any): boolean;
+export function isIPv6(address: any): boolean;
+export function _is(definition: any, address: any): boolean;
+export function asBigInt(address: any): bigint;
+export function prefixIP(address: any, length: any): string;
+export function _prefix(definition: any, address: any, length: any): bigint;
+export function normalizeCIDR(address: any): {
+    longPrefix?: undefined;
+    prefix?: undefined;
+    prefixLength?: undefined;
+    cidr?: undefined;
+} | {
+    longPrefix: any;
+    prefix: any;
+    prefixLength: any;
+    cidr: string;
+};
+export function formatCIDR(address: any, subnet: any): any;
+export function normalizeIP(address: any): string;
+export function reverseArpa(address: any): string;
+export function isLocalhost(address: any): boolean;
+export function isLinkLocal(address: any): boolean;
+export function hasWellKnownSubnet(address: any): boolean;
+export const IPV6_LINK_LOCAL_BROADCAST: any;
+export const IPV6_ROUTER_BROADCAST: any;
+export const IPV4_LOCALHOST: any;
+export const IPV6_LOCALHOST: any;

package/types/subnet.d.mts

@@ -25,15 +25,15 @@ export class Subnet extends Base {
         };
     };
     networks: Set<any>;
+    prefix: any;
+    prefixLength: any;
+    longPrefix: any;
     get fullName(): string;
     matchesAddress(address: any): any;
     get isLinkLocal(): boolean;
     get isIPv4(): boolean;
     get isIPv6(): boolean;
     get addressRange(): string[];
-    get longPrefix(): string;
-    get prefix(): string;
-    get prefixLength(): number;
     get address(): string;
     get longAddress(): string;
     _traverse(...args: any[]): boolean;

package/types/utils.d.mts

@@ -5,32 +5,3 @@ export function sectionLines(sectionName: any, values: any): string[];
 export function bridgeToJSON(bridge: any): any[];
 export function asArray(value: any): any[];
 export function asIterator(value: any): any;
-export function isIPv4Address(address: any): boolean;
-export function isIPv6Address(address: any): boolean;
-export function isLinkLocal(address: any): boolean;
-export function generateEU64(mac: any): void;
-export function isLocalhost(address: any): boolean;
-export function normalizeIPAddress(address: any): any;
-export function addressWithPrefixLength(address: any, prefixLength: any): string;
-export function _encode(definition: any, address: any): any;
-export function decodeIPv6(address: any, length: any): string;
-export function encodeIPv6(address: any): any;
-export function decodeIPv4(address: any, length: any): string;
-export function encodeIPv4(address: any): any;
-export function decodeIP(address: any, length: any): string;
-export function encodeIP(address: any): any;
-export function formatCIDR(address: any, subnet: any): any;
-export function normalizeCIDR(address: any): {
-    prefix?: undefined;
-    prefixLength?: undefined;
-    cidr?: undefined;
-} | {
-    prefix: any;
-    prefixLength: any;
-    cidr: string;
-};
-export function hasWellKnownSubnet(address: any): boolean;
-export const IPV4_LOCALHOST: any;
-export const IPV6_LOCALHOST: any;
-export const IPV6_LINK_LOCAL_BROADCAST: any;
-export const IPV6_ROUTER_BROADCAST: any;