pmcf 2.18.2 → 2.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "2.18.2",
+  "version": "2.19.0",
   "publishConfig": {
     "access": "public"
   },
@@ -38,6 +38,7 @@
     "lint:typescript": "tsc --allowJs --checkJs --noEmit --resolveJsonModule --target es2024 --lib esnext -m esnext --module nodenext --moduleResolution nodenext ./src**/*.mjs"
   },
   "dependencies": {
+    "ip-utilties": "^1.0.0",
     "npm-pkgbuild": "^18.0.1",
     "pacc": "^3.3.0",
     "pkg-dir": "^8.0.0"

package/src/dns-utils.mjs

@@ -1,5 +1,5 @@
+import { decodeIPv4, decodeIPv6 } from "ip-utilties";
 import { asIterator } from "./utils.mjs";
-import { decodeIPv4, decodeIPv6 } from "./ip.mjs";
 
 export function dnsFullName(name) {
   return name.endsWith(".") ? name : name + ".";

package/src/host.install

@@ -3,7 +3,6 @@ post_install()
     ls -l /etc/resolv.conf | grep -q /run/systemd/resolve/resolv.conf
     if [ $? = 1 ]
     then
-        mv /etc/resolv.conf /etc/resolv.conf.pre
         ln -s /run/systemd/resolve/resolv.conf /etc/resolv.conf
     fi
 }
@@ -13,7 +12,6 @@ post_upgrade()
     ls -l /etc/resolv.conf | grep -q /run/systemd/resolve/resolv.conf
     if [ $? = 1 ]
     then
-        mv /etc/resolv.conf /etc/resolv.conf.pre
         ln -s /run/systemd/resolve/resolv.conf /etc/resolv.conf
     fi
 }

package/src/host.mjs

@@ -1,19 +1,19 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { FileContentProvider } from "npm-pkgbuild";
-import { Base } from "./base.mjs";
-import {
-  networkProperties,
-  networkAddressProperties
-} from "./network-support.mjs";
-import { asArray, domainFromDominName, domainName } from "./utils.mjs";
 import {
   isIPv4,
   isIPv6,
   formatCIDR,
   hasWellKnownSubnet,
   normalizeIP
-} from "./ip.mjs";
+} from "ip-utilties";
+import { Base } from "./base.mjs";
+import {
+  networkProperties,
+  networkAddressProperties
+} from "./network-support.mjs";
+import { asArray, domainFromDominName, domainName } from "./utils.mjs";
 import { objectFilter } from "./filter.mjs";
 import { addType, types } from "./types.mjs";
 import { loadHooks } from "./hooks.mjs";
@@ -406,7 +406,7 @@ export class Host extends Base {
       filter
     );
   }
-  
+
   findNetworkInterface(filter) {
     for (const ni of objectFilter(
       types.network_interface,
@@ -505,11 +505,85 @@ export class Host extends Base {
   }
 }
 
+class SkeletonNetworkInterface extends Base {
+  _extends = [];
+  _network;
+
+  set extends(value) {
+    this._extends.push(value);
+  }
+
+  get extends() {
+    return this._extends;
+  }
+
+  get isTemplate() {
+    return this.name.indexOf("*") >= 0;
+  }
+
+  get host() {
+    return this.owner;
+  }
+
+  get network_interface() {
+    return this;
+  }
+
+  get domainNames() {
+    return new Set();
+  }
+
+  matches(other) {
+    if (this.isTemplate) {
+      const name = this.name.replace("*", "");
+      return name.length === 0 || other.name.indexOf(name) >= 0;
+    }
+
+    return false;
+  }
+
+  get network() {
+    return this.extendedProperty("_network") ?? this.host.network;
+  }
+
+  set network(network) {
+    this._network = network;
+  }
+
+  get rawAddress() {
+    return this.rawAddresses[0];
+  }
+
+  get rawIPv4Address() {
+    return this.rawAddresses.filter(a => isIPv4(a))[0];
+  }
+
+  get rawIPv6Address() {
+    return this.rawAddresses.filter(a => isIPv6(a))[0];
+  }
+
+  get cidrAddress() {
+    return this.cidrAddresses[0];
+  }
+}
+
 const NetworkInterfaceTypeDefinition = {
   name: "network_interface",
   priority: 0.4,
   owners: ["host"],
   extends: Base.typeDefinition,
+  specializations: {},
+  factoryFor(value) {
+    const kind = value.kind;
+    const t = NetworkInterfaceTypeDefinition.specializations[kind];
+
+    if (t) {
+      delete value.type;
+      return t.clazz;
+    }
+
+    return NetworkInterface;
+  },
   properties: {
     ...networkProperties,
     ...networkAddressProperties,
@@ -523,7 +597,7 @@ const NetworkInterfaceTypeDefinition = {
   }
 };
 
-export class NetworkInterface extends Base {
+export class NetworkInterface extends SkeletonNetworkInterface {
   static {
     addType(this);
   }
@@ -537,12 +611,10 @@ export class NetworkInterface extends Base {
   _metric;
   _ssid;
   _psk;
-  _network;
   _kind;
   _hostName;
   _hwaddr;
   _class;
-  _extends = [];
   arpbridge;
 
   constructor(owner, data) {
@@ -550,19 +622,6 @@ export class NetworkInterface extends Base {
     this.read(data, NetworkInterfaceTypeDefinition);
   }
 
-  get isTemplate() {
-    return this.name.indexOf("*") >= 0;
-  }
-
-  matches(other) {
-    if (this.isTemplate) {
-      const name = this.name.replace("*", "");
-      return name.length === 0 || other.name.indexOf(name) >= 0;
-    }
-
-    return false;
-  }
-
   addSubnet(address) {
     if (!this.network) {
       if (!hasWellKnownSubnet(address)) {
@@ -579,33 +638,14 @@ export class NetworkInterface extends Base {
 
   set ipAddresses(value) {
     for (const address of asArray(value)) {
-      this._ipAddresses.set(
-        normalizeIP(address),
-        this.addSubnet(address)
-      );
+      this._ipAddresses.set(normalizeIP(address), this.addSubnet(address));
     }
   }
 
-  get rawAddress() {
-    return this.rawAddresses[0];
-  }
-
-  get rawIPv4Address() {
-    return this.rawAddresses.filter(a => isIPv4(a))[0];
-  }
-
-  get rawIPv6Address() {
-    return this.rawAddresses.filter(a => isIPv6(a))[0];
-  }
-
   get rawAddresses() {
     return [...this._ipAddresses].map(([address]) => address);
   }
 
-  get cidrAddress() {
-    return this.cidrAddresses[0];
-  }
-
   get cidrAddresses() {
     return [...this._ipAddresses].map(([address, subnet]) =>
       formatCIDR(address, subnet)
@@ -657,30 +697,6 @@ export class NetworkInterface extends Base {
       : this.host.directDomainNames;
   }
 
-  get host() {
-    return this.owner;
-  }
-
-  get network_interface() {
-    return this;
-  }
-
-  set extends(value) {
-    this._extends.push(value);
-  }
-
-  get extends() {
-    return this._extends;
-  }
-
-  get network() {
-    return this.extendedProperty("_network") ?? this.host.network;
-  }
-
-  set network(network) {
-    this._network = network;
-  }
-
   set scope(value) {
     this._scope = value;
   }
@@ -753,3 +769,47 @@ export class NetworkInterface extends Base {
     return this.extendedProperty("_kind") ?? this.network?.kind;
   }
 }
+
+const LoopbackNetworkInterfaceTypeDefinition = {
+  name: "loopback",
+  specializationOf: NetworkInterfaceTypeDefinition,
+  owners: NetworkInterfaceTypeDefinition.owners,
+  extends: NetworkInterfaceTypeDefinition,
+  priority: 0.1,
+  properties: {}
+};
+
+const _localAddresses = new Map([
+  ["127.0.0.1", { prefix: "127.0.0", prefixLength: 8 }], // TODO
+  ["::1", { prefix: "", prefixLength: 128 }]
+]);
+
+export class LoopbackNetworkInterface extends SkeletonNetworkInterface {
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return LoopbackNetworkInterfaceTypeDefinition;
+  }
+
+  get kind() {
+    return "loopback";
+  }
+
+  get scope() {
+    return "host";
+  }
+
+  get hostName() {
+    return "localhost";
+  }
+
+  get ipAddresses() {
+    return _localAddresses;
+  }
+
+  get cidrAddresses() {
+    return ["127.0.0.1/8", "::1/128"];
+  }
+}

package/src/owner.mjs

@@ -1,8 +1,8 @@
+import { normalizeCIDR } from "ip-utilties";
 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,9 +1,9 @@
+import { isLocalhost } from "ip-utilties";
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
 import { objectFilter } from "./filter.mjs";
 import { asArray } from "./utils.mjs";
 import { networkAddressProperties } from "./network-support.mjs";
-import { isLocalhost } from "./ip.mjs";
 import {
   DNSRecord,
   dnsFullName,
@@ -22,6 +22,7 @@ const ServiceTypes = {
     dnsRecord: { type: "HTTPS", parameters: { alpn: "h2" } }
   },
   http3: {
+    extends: ["https"],
     type: "https",
     endpoints: [{ protocol: "tcp", port: 443, tls: true }],
     dnsRecord: {
@@ -48,6 +49,7 @@ const ServiceTypes = {
   smb: { endpoints: [{ protocol: "tcp", port: 445, tls: false }] },
   timemachine: {
     type: "adisk",
+    extends: ["smb"],
     endpoints: [{ protocol: "tcp", port: 445, tls: false }],
     dnsRecord: {
       type: "TXT",

package/src/services/dhcp.mjs

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { FileContentProvider } from "npm-pkgbuild";
+import { isIPv4, isIPv6 } from "ip-utilties";
 import {
   Service,
   ServiceTypeDefinition,
@@ -8,7 +9,6 @@ import {
 } from "../service.mjs";
 import { addType } from "../types.mjs";
 import { writeLines } from "../utils.mjs";
-import { isIPv4, isIPv6 } from "../ip.mjs";
 
 const DHCPServiceTypeDefinition = {
   name: "dhcp",
@@ -20,6 +20,7 @@ const DHCPServiceTypeDefinition = {
 };
 
 const controlAgentEndpoint = {
+ // extends: ["http"],
   type: "kea-control-agent",
   port: 8000,
   protocol: "tcp",

package/src/services/dns.mjs

@@ -1,8 +1,8 @@
 import { join } from "node:path";
 import { createHmac } from "node:crypto";
 import { FileContentProvider } from "npm-pkgbuild";
+import { isIPv6, isLinkLocal, isLocalhost, reverseArpa } from "ip-utilties";
 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";
@@ -41,6 +41,12 @@ const DNSServiceTypeDefinition = {
       writeable: true,
       default: false
     },
+    excludeInterfaceKinds: {
+      type: "string",
+      collection: true,
+      writeable: true
+    },
+
     exclude: { type: "network", collection: true, writeable: true },
     notify: {
       type: "boolean",
@@ -87,6 +93,7 @@ export class DNSService extends ExtraSourceService {
   _protected = [];
   _open = [];
   _exclude = new Set([]);
+  _excludeInterfaceKinds = new Set();
 
   serial = Math.ceil(Date.now() / 1000);
   refresh = 36000;
@@ -147,6 +154,14 @@ export class DNSService extends ExtraSourceService {
     return this._exclude;
   }
 
+  set excludeInterfaceKinds(value) {
+    this._excludeInterfaceKinds.add(value);
+  }
+
+  get excludeInterfaceKinds() {
+    return this._excludeInterfaceKinds;
+  }
+
   get systemdConfig() {
     return [
       "Resolve",
@@ -351,7 +366,7 @@ async function generateZoneDefs(dns, location, packageData) {
       networkInterface,
       domainNames
     } of location.networkAddresses()) {
-      if (!dns.exclude.has(networkInterface.network)) {
+      if (!dns.exclude.has(networkInterface.network) && !dns.excludeInterfaceKinds.has(networkInterface.kind)) {
         const host = networkInterface.host;
         if (
           !addresses.has(address) &&

package/src/subnet.mjs

@@ -5,7 +5,7 @@ import {
   isIPv6,
   rangeIP,
   decodeIP
-} from "./ip.mjs";
+} from "ip-utilties";
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
 

package/types/host.d.mts

@@ -259,7 +259,7 @@ export class Host extends Base {
         };
     }, void, unknown>;
 }
-export class NetworkInterface extends Base {
+export class NetworkInterface extends SkeletonNetworkInterface {
     static get typeDefinition(): {
         name: string;
         priority: number;
@@ -311,6 +311,8 @@ export class NetworkInterface extends Base {
                 };
             };
         };
+        specializations: {};
+        factoryFor(value: any): any;
         properties: {
             hostName: {
                 type: string;
@@ -421,22 +423,15 @@ export class NetworkInterface extends Base {
     _metric: any;
     _ssid: any;
     _psk: any;
-    _network: any;
     _kind: any;
     _hostName: any;
     _hwaddr: any;
     _class: any;
-    _extends: any[];
     arpbridge: any;
-    matches(other: any): boolean;
     addSubnet(address: any): any;
     set ipAddresses(value: Map<any, any>);
     get ipAddresses(): Map<any, any>;
-    get rawAddress(): any;
-    get rawIPv4Address(): any;
-    get rawIPv6Address(): any;
     get rawAddresses(): any[];
-    get cidrAddress(): any;
     get cidrAddresses(): any[];
     get rawIPv4Addresses(): any[];
     get rawIPv6Addresses(): any[];
@@ -446,11 +441,6 @@ export class NetworkInterface extends Base {
     set hostName(value: any);
     get hostName(): any;
     get domainNames(): any;
-    get network_interface(): this;
-    set extends(value: any[]);
-    get extends(): any[];
-    set network(network: any);
-    get network(): any;
     set scope(value: any);
     get scope(): any;
     set hwaddr(value: any);
@@ -469,5 +459,353 @@ export class NetworkInterface extends Base {
     set kind(value: any);
     get kind(): any;
 }
+export class LoopbackNetworkInterface extends SkeletonNetworkInterface {
+    static get typeDefinition(): {
+        name: string;
+        specializationOf: {
+            name: string;
+            priority: number;
+            owners: string[];
+            extends: {
+                name: string;
+                owners: any[];
+                properties: {
+                    owner: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    type: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    name: {
+                        type: string;
+                        collection: boolean;
+                        identifier: boolean;
+                        writeable: boolean;
+                    };
+                    description: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    priority: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    directory: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    packaging: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    tags: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                };
+            };
+            specializations: {};
+            factoryFor(value: any): any;
+            properties: {
+                hostName: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                ipAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                hwaddr: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                network: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                destination: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                arpbridge: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                rawAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                rawAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                scope: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                    default: string;
+                };
+                class: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                kind: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                ssid: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                psk: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                metric: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                MTU: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                gateway: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                multicastDNS: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: boolean;
+                };
+            };
+        };
+        owners: string[];
+        extends: {
+            name: string;
+            priority: number;
+            owners: string[];
+            extends: {
+                name: string;
+                owners: any[];
+                properties: {
+                    owner: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    type: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    name: {
+                        type: string;
+                        collection: boolean;
+                        identifier: boolean;
+                        writeable: boolean;
+                    };
+                    description: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    priority: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    directory: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    packaging: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    tags: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                };
+            };
+            specializations: {};
+            factoryFor(value: any): any;
+            properties: {
+                hostName: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                ipAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                hwaddr: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                network: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                destination: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                arpbridge: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                rawAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                rawAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                scope: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                    default: string;
+                };
+                class: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                kind: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                ssid: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                psk: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                metric: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                MTU: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                gateway: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                multicastDNS: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: boolean;
+                };
+            };
+        };
+        priority: number;
+        properties: {};
+    };
+    get kind(): string;
+    get scope(): string;
+    get hostName(): string;
+    get ipAddresses(): Map<string, {
+        prefix: string;
+        prefixLength: number;
+    }>;
+    get cidrAddresses(): string[];
+}
 import { Base } from "./base.mjs";
 import { FileContentProvider } from "npm-pkgbuild";
+declare class SkeletonNetworkInterface extends Base {
+    _extends: any[];
+    _network: any;
+    set extends(value: any[]);
+    get extends(): any[];
+    get network_interface(): this;
+    get domainNames(): Set<any>;
+    matches(other: any): boolean;
+    set network(network: any);
+    get network(): any;
+    get rawAddress(): any;
+    get rawIPv4Address(): any;
+    get rawIPv6Address(): any;
+    get cidrAddress(): any;
+}
+export {};

package/types/services/dns.d.mts

@@ -297,6 +297,11 @@ export class DNSService extends ExtraSourceService {
                 writeable: boolean;
                 default: boolean;
             };
+            excludeInterfaceKinds: {
+                type: string;
+                collection: boolean;
+                writeable: boolean;
+            };
             exclude: {
                 type: string;
                 collection: boolean;
@@ -355,6 +360,7 @@ export class DNSService extends ExtraSourceService {
     _protected: any[];
     _open: any[];
     _exclude: Set<any>;
+    _excludeInterfaceKinds: Set<any>;
     serial: number;
     refresh: number;
     retry: number;
@@ -369,6 +375,8 @@ export class DNSService extends ExtraSourceService {
     get open(): any[];
     set exclude(value: Set<any>);
     get exclude(): Set<any>;
+    set excludeInterfaceKinds(value: Set<any>);
+    get excludeInterfaceKinds(): Set<any>;
     get systemdConfig(): (string | {
         DNS: string;
         FallbackDNS: string;

package/types/subnet.d.mts

@@ -30,10 +30,10 @@ export class Subnet extends Base {
     longPrefix: any;
     get fullName(): string;
     matchesAddress(address: any): any;
-    get isLinkLocal(): boolean;
-    get isIPv4(): boolean;
-    get isIPv6(): boolean;
-    get addressRange(): string[];
+    get isLinkLocal(): any;
+    get isIPv4(): any;
+    get isIPv6(): any;
+    get addressRange(): any;
     get address(): string;
     get longAddress(): string;
     _traverse(...args: any[]): boolean;

package/src/ip.mjs

@@ -1,323 +0,0 @@
-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.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) {
-  const d = _definition(address);
-  return d && _encode(d, 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 "bigint":
-      return _encodeBigInt(definition, address);
-
-    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);
-}
-
-function _definition(address) {
-  for (const defintion of [ipv4, ipv6]) {
-    if (_is(defintion, address)) {
-      return defintion;
-    }
-  }
-}
-
-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 rangeIP(address, prefix, lowerAdd = 0, upperReduce = 0) {
-  const definition = isIPv4(address) ? ipv4 : ipv6;
-
-  const from = _prefix(definition, address, prefix);
-  const to = from | ((1n << BigInt(definition.bitLength - prefix)) - 1n);
-
-  return [_encode(definition, from + BigInt(lowerAdd)), _encode(definition, to - BigInt(upperReduce))];
-}
-
-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/types/ip.d.mts

@@ -1,37 +0,0 @@
-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 rangeIP(address: any, prefix: any, lowerAdd?: number, upperReduce?: number): any[];
-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;