mybase 1.1.29 → 1.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.29",
+  "version": "1.1.30",
   "description": "",
   "main": "mybase.js",
   "scripts": {
@@ -10,25 +10,25 @@
   "license": "ISC",
   "dependencies": {
     "@7c/validurl": "0.0.3",
+    "@types/debug": "^4.1.12",
+    "@types/ip6addr": "^0.2.6",
+    "@types/mysql": "^2.15.25",
+    "@types/node": "^20.11.5",
+    "@types/request": "^2.48.12",
+    "@types/validator": "^13.11.8",
     "aes-js": "^3.1.2",
     "chalk": "^3.0.0",
     "debug": "^4.3.4",
     "ip-range-check": "^0.2.0",
     "ip6": "=0.2.7",
-    "ip6addr": "^0.2.5",
+    "ip6addr": "github:7c/node-ip6addr#db6d558af1f314bcb0a733fd61611fa85e1a3eff",
     "js-sha512": "^0.8.0",
     "mysql": "^2.18.1",
     "mysql2": "^3.9.1",
     "node-vault": "^0.10.2",
     "psl": "^1.9.0",
     "punycode": "^2.1.1",
-    "validator": "^13.7.0",
-    "@types/debug": "^4.1.12",
-    "@types/ip6addr": "^0.2.6",
-    "@types/mysql": "^2.15.25",
-    "@types/node": "^20.11.5",
-    "@types/validator": "^13.11.8",
-    "@types/request": "^2.48.12"
+    "validator": "^13.7.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",

package/ts/funcs/isLANIp.js

@@ -3,24 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLANIp = void 0;
+exports.isLANIp = exports.private_network_cidrs = void 0;
 const ip6addr_1 = __importDefault(require("ip6addr"));
 const net_1 = __importDefault(require("net"));
-const private_network_cidrs = [ip6addr_1.default.createCIDR('10.0.0.0/8'),
+exports.private_network_cidrs = [
+    ip6addr_1.default.createCIDR('10.0.0.0/8'),
     ip6addr_1.default.createCIDR('172.16.0.0/12'),
     ip6addr_1.default.createCIDR('192.168.0.0/16'),
     ip6addr_1.default.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
-    ,
     ip6addr_1.default.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
 ];
-function normalizeIp(ip) {
-    // also support ipv6
-    if (net_1.default.isIP(ip) === 0)
-        return '';
-    if (net_1.default.isIPv6(ip))
-        return ip.toLowerCase().replace(/^::ffff:/, '');
-    return ip;
-}
 function isLANIp(ip) {
     ip = normalizeIp(ip);
     if (net_1.default.isIP(ip) === 0)
@@ -28,7 +20,7 @@ function isLANIp(ip) {
     try {
         // speed optimized
         let ipVersion = net_1.default.isIPv4(ip) ? 'ipv4' : 'ipv6';
-        for (let cidr of private_network_cidrs) {
+        for (let cidr of exports.private_network_cidrs) {
             if (!cidr)
                 continue;
             let first = cidr.first();
@@ -44,4 +36,12 @@ function isLANIp(ip) {
     return false;
 }
 exports.isLANIp = isLANIp;
+function normalizeIp(ip) {
+    // also support ipv6
+    if (net_1.default.isIP(ip) === 0)
+        return '';
+    if (net_1.default.isIPv6(ip))
+        return ip.toLowerCase().replace(/^::ffff:/, '');
+    return ip;
+}
 //# sourceMappingURL=isLANIp.js.map

package/ts/funcs/isLANIp.ts

@@ -1,25 +1,17 @@
 import ip6addr from 'ip6addr'
 import net from 'net'
 
-const private_network_cidrs = [ip6addr.createCIDR('10.0.0.0/8')
-            ,ip6addr.createCIDR('172.16.0.0/12')
-            ,ip6addr.createCIDR('192.168.0.0/16')
-            ,ip6addr.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
-            ,ip6addr.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
-        ]
-
-
-function normalizeIp(ip:string):string {
-    // also support ipv6
-    if (net.isIP(ip) === 0) return ''
-    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-    return ip
-}
-
+export const private_network_cidrs = [
+    ip6addr.createCIDR('10.0.0.0/8'),
+    ip6addr.createCIDR('172.16.0.0/12'),
+    ip6addr.createCIDR('192.168.0.0/16'),
+    ip6addr.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
+    ip6addr.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
+]
 
 export function isLANIp(ip:string) : boolean { 
     ip=normalizeIp(ip)
-    if (net.isIP(ip) === 0) return false
+    if (net.isIP(ip)===0) return false
     try {
         // speed optimized
         let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
@@ -36,3 +28,10 @@ export function isLANIp(ip:string) : boolean {
     }
     return false
 }
+
+function normalizeIp(ip:string):string {
+    // also support ipv6
+    if (net.isIP(ip) === 0) return ''
+    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
+    return ip
+}

package/ts/funcs/isLoopbackIP.js

@@ -3,19 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLoopbackIP = void 0;
+exports.isLoopbackIP = exports.local_network_cidrs = void 0;
 const ip6addr_1 = __importDefault(require("ip6addr"));
 const net_1 = __importDefault(require("net"));
-const local_network_cidrs = [ip6addr_1.default.createCIDR('127.0.0.0/8'),
-    ip6addr_1.default.createCIDR('::1/128')];
-function normalizeIp(ip) {
-    // also support ipv6
-    if (net_1.default.isIP(ip) === 0)
-        return '';
-    if (net_1.default.isIPv6(ip))
-        return ip.toLowerCase().replace(/^::ffff:/, '');
-    return ip;
-}
+exports.local_network_cidrs = [
+    ip6addr_1.default.createCIDR('127.0.0.0/8'),
+    ip6addr_1.default.createCIDR('::1/128')
+];
 function isLoopbackIP(ip) {
     ip = normalizeIp(ip);
     if (net_1.default.isIP(ip) === 0)
@@ -23,7 +17,7 @@ function isLoopbackIP(ip) {
     try {
         // speed optimized
         let ipVersion = net_1.default.isIPv4(ip) ? 'ipv4' : 'ipv6';
-        for (let cidr of local_network_cidrs) {
+        for (let cidr of exports.local_network_cidrs) {
             let first = cidr.first();
             if (first.kind() !== ipVersion)
                 continue;
@@ -37,4 +31,12 @@ function isLoopbackIP(ip) {
     return false;
 }
 exports.isLoopbackIP = isLoopbackIP;
+function normalizeIp(ip) {
+    // also support ipv6
+    if (net_1.default.isIP(ip) === 0)
+        return '';
+    if (net_1.default.isIPv6(ip))
+        return ip.toLowerCase().replace(/^::ffff:/, '');
+    return ip;
+}
 //# sourceMappingURL=isLoopbackIP.js.map

package/ts/funcs/isLoopbackIP.ts

@@ -1,21 +1,14 @@
 import ip6addr from 'ip6addr'
 import net from 'net'
 
-const local_network_cidrs = [ip6addr.createCIDR('127.0.0.0/8')
-        ,ip6addr.createCIDR('::1/128')]
-
-
-function normalizeIp(ip:string):string {
-    // also support ipv6
-    if (net.isIP(ip) === 0) return ''
-    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-    return ip
-}
-
+export const local_network_cidrs = [
+    ip6addr.createCIDR('127.0.0.0/8'),
+    ip6addr.createCIDR('::1/128')
+]
 
 export function isLoopbackIP(ip:string) : boolean {
     ip=normalizeIp(ip)
-    if (net.isIP(ip) === 0) return false
+    if (net.isIP(ip)===0) return false
     try {
         // speed optimized
         let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
@@ -30,3 +23,10 @@ export function isLoopbackIP(ip:string) : boolean {
     }
     return false
 }
+
+function normalizeIp(ip:string):string {
+    // also support ipv6
+    if (net.isIP(ip) === 0) return ''
+    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
+    return ip
+}

package/ts/index.test.ts

@@ -2,6 +2,6 @@ import * as IMPORTS from "./index";
 
 test('exports', () => {
     for(let fn of Object.values(IMPORTS)) {
-        expect(typeof fn).toBe('function')
+        expect(typeof fn=='function' || typeof fn==='object').toBe(true)
     }
 })

package/ts/models/IPAddress.js

@@ -4,9 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IPAddress = void 0;
+const debug_1 = __importDefault(require("debug"));
 const __1 = require("./../");
 const ip6addr_1 = __importDefault(require("ip6addr"));
+const net_1 = __importDefault(require("net"));
 const ip6 = require('ip6'); // "url": "https://github.com/elgs/ip6"
+const dbg = (0, debug_1.default)('_IPAddress');
+dbg.enabled = true;
 // need version "ip6": "0.2.7",!!
 class IPAddress {
     constructor(ip) {
@@ -51,10 +55,33 @@ class IPAddress {
         return new IPAddress('0.0.0.0');
     }
     isLoopbackIP() {
-        return (0, __1.isLoopbackIP)(this._ip.toString());
+        return this.partOfCIDR(IPAddress.loopback_cidrs);
     }
     isLANIP() {
-        return (0, __1.isLANIp)(this._ip.toString());
+        return this.partOfCIDR(IPAddress.lan_cidrs);
+    }
+    isLocalIP() {
+        return this.partOfCIDR(IPAddress.local_cidrs);
+    }
+    partOfCIDR(cidr_networks) {
+        const ipNormalized = this.toString();
+        let ipVersion = net_1.default.isIPv4(ipNormalized) ? 'ipv4' : 'ipv6';
+        for (let cidr of cidr_networks) {
+            if (!cidr)
+                continue;
+            let first = cidr.first();
+            if (first.kind() !== ipVersion)
+                continue;
+            if (cidr.contains(ipNormalized))
+                return true;
+        }
+        return false;
+    }
+    static partOfCIDR(_ip, cidr_networks) {
+        const ip = IPAddress.try(_ip);
+        if (ip === undefined)
+            return false;
+        return ip.partOfCIDR(cidr_networks);
     }
     isPublicIP() {
         return this.toString() !== '0.0.0.0' && !this.isLoopbackIP() && !this.isLANIP();
@@ -82,6 +109,50 @@ class IPAddress {
     static randomIP6() {
         return new IPAddress((0, __1.randomIP6)());
     }
+    static randomCIDRIp(cidr) {
+        if (cidr === 'loopback')
+            cidr = IPAddress.loopback_cidrs;
+        if (cidr === 'loopback4')
+            cidr = IPAddress.loopback_cidrs4;
+        if (cidr === 'loopback6')
+            cidr = IPAddress.loopback_cidrs6;
+        if (cidr === 'lan')
+            cidr = IPAddress.lan_cidrs;
+        if (cidr === 'lan4')
+            cidr = IPAddress.lan_cidrs4;
+        if (cidr === 'lan6')
+            cidr = IPAddress.lan_cidrs6;
+        if (cidr === 'local')
+            cidr = IPAddress.local_cidrs;
+        if (cidr === 'local4')
+            cidr = IPAddress.local_cidrs4;
+        if (cidr === 'local6')
+            cidr = IPAddress.local_cidrs6;
+        // dbg('randomCIDRIp', cidr)
+        if (cidr.length === 0)
+            throw new Error('CIDR array is empty');
+        // Pick a random CIDR network
+        const network = cidr[Math.floor(Math.random() * cidr.length)];
+        // dbg('randomCIDRIp:network', network)
+        // Get the range of IPs in this CIDR
+        const start = network.first().toBigInt();
+        // dbg('randomCIDRIp:first', network.first().toString(),start)
+        const end = network.last().toBigInt();
+        // dbg('randomCIDRIp:last', network.last().toString(),end)
+        let range = end - start;
+        // dbg('randomCIDRIp:first:last', start, end)
+        // Generate a random Long between the start and end
+        // if start-end > Maximum integer number
+        // we need to use BigInt
+        if (range > BigInt(Number.MAX_SAFE_INTEGER))
+            range = (Number.MAX_SAFE_INTEGER);
+        const randomBigInt = BigInt(Math.floor(Math.random() * (Number(range) + 1))) + start;
+        // dbg('randomBigInt', randomBigInt)
+        // Convert the BigInt back to an IP address
+        const randomIp = ip6addr_1.default.parse(randomBigInt);
+        // dbg('randomCIDRIp', randomIp.toString())
+        return new IPAddress(randomIp.toString());
+    }
     serialize() {
         if (this.kind() === 4) {
             // zero pad ipv4
@@ -158,4 +229,24 @@ class IPAddress {
     }
 }
 exports.IPAddress = IPAddress;
+IPAddress.loopback_cidrs4 = [
+    ip6addr_1.default.createCIDR('127.0.0.0/8'),
+];
+IPAddress.loopback_cidrs6 = [
+    ip6addr_1.default.createCIDR('::1/128') // yes ipv6 has single address
+];
+IPAddress.loopback_cidrs = IPAddress.loopback_cidrs4.concat(IPAddress.loopback_cidrs6);
+IPAddress.lan_cidrs4 = [
+    ip6addr_1.default.createCIDR('10.0.0.0/8'),
+    ip6addr_1.default.createCIDR('172.16.0.0/12'),
+    ip6addr_1.default.createCIDR('192.168.0.0/16'),
+];
+IPAddress.lan_cidrs6 = [
+    ip6addr_1.default.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
+    ip6addr_1.default.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
+];
+IPAddress.lan_cidrs = IPAddress.lan_cidrs4.concat(IPAddress.lan_cidrs6);
+IPAddress.local_cidrs = IPAddress.loopback_cidrs.concat(IPAddress.lan_cidrs);
+IPAddress.local_cidrs4 = IPAddress.loopback_cidrs4.concat(IPAddress.lan_cidrs4);
+IPAddress.local_cidrs6 = IPAddress.loopback_cidrs6.concat(IPAddress.lan_cidrs6);
 //# sourceMappingURL=IPAddress.js.map

package/ts/models/IPAddress.test.ts

@@ -63,22 +63,22 @@ describe('IPAddress', () => {
   })
 
   it('randomly generated ipv4 serialization', () => {
-    for(let i = 0; i < 100; i++) {
+    for (let i = 0; i < 100; i++) {
       const ip = randomIP()
       expect(IPAddress.unserialize(IPAddress.fromString(ip).serialize()).toString()).toBe(ip)
     }
   })
 
   it('randomly generated ipv6 serialization and unserialization', () => {
-    for(let i = 0; i < 100; i++) {
+    for (let i = 0; i < 100; i++) {
       const ip = randomIP6()
       let ip2 = IPAddress.unserialize(IPAddress.fromString(ip).serialize()).toString()
-      expect(ip6addr.compare(ip, ip2)).toEqual(0) 
+      expect(ip6addr.compare(ip, ip2)).toEqual(0)
     }
   })
 
   it('it should detect the kind of ip4', () => {
-    for(let i = 0; i < 100; i++) 
+    for (let i = 0; i < 100; i++)
       expect(IPAddress.randomIP4().kind()).toBe(4)
   })
 
@@ -88,10 +88,10 @@ describe('IPAddress', () => {
 
   it('randomPad return valid ipv4 results', () => {
     let compared = 0
-    while(compared<100) {
+    while (compared < 100) {
       const ip1 = IPAddress.randomIP4()
       const ip2 = ip1.randomPad()
-      if (ip1.toString()!==ip2) { // find ips they are padded from the original
+      if (ip1.toString() !== ip2) { // find ips they are padded from the original
         compared++
       }
       expect(IPAddress.validate(ip2)).toBe(true)
@@ -100,10 +100,10 @@ describe('IPAddress', () => {
 
   it('compare ipv4 should detect equality even if they are padded', () => {
     let compared = 0
-    while(compared<100) {
+    while (compared < 100) {
       const ip1 = IPAddress.randomIP4()
       const ip2 = ip1.randomPad()
-      if (ip1.toString()!==ip2) { // find ips they are padded from the original
+      if (ip1.toString() !== ip2) { // find ips they are padded from the original
         compared++
       }
       expect(ip1.equals(IPAddress.fromString(ip2))).toBe(true)
@@ -137,20 +137,20 @@ describe('IPAddress IPv6', () => {
 
   it('it should detect the kind of ip6', () => {
     expect(new IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3').kind()).toBe(6);
-    for(let i = 0; i < 100; i++) 
+    for (let i = 0; i < 100; i++)
       expect(IPAddress.randomIP6().kind()).toBe(6)
   })
 
   it('randomPad return valid ipv6 results be compareable with equals', () => {
     let compared = 0
-    while(compared<500) {
+    while (compared < 500) {
       const ip1 = IPAddress.randomIP6()
       const ip2 = ip1.randomPad()
       expect(ip1.kind()).toBe(6)
-      if (ip1.toString()!==ip2) { // find ips they are padded from the original
+      if (ip1.toString() !== ip2) { // find ips they are padded from the original
         compared++
       }
-      
+
       expect(IPAddress.validate(ip2)).toBe(true)
       expect(ip1.equals(IPAddress.fromString(ip2))).toBe(true)
     }
@@ -173,16 +173,135 @@ describe('IPAddress asciiChecksum', () => {
   })
 
   it('it should always return a single character ipv4/v6', () => {
-    for(let i=0;i<10000;i++) {
+    for (let i = 0; i < 10000; i++) {
       expect(new IPAddress(randomIP()).asciiChecksum().length).toBe(1)
       expect(new IPAddress(randomIP6()).asciiChecksum().length).toBe(1)
     }
   })
 
-  it('it should return a-z0-9 ascii only',()=>{
-    for(let i=0;i<10000;i++) {
+  it('it should return a-z0-9 ascii only', () => {
+    for (let i = 0; i < 10000; i++) {
       expect('abcdefghijklmnopqrstuvwxyz0123456789').toContain(new IPAddress(randomIP()).asciiChecksum())
       expect('abcdefghijklmnopqrstuvwxyz0123456789').toContain(new IPAddress(randomIP6()).asciiChecksum())
     }
   })
+})
+
+describe('IPAddress partOfCIDR', () => {
+  it('should detect cidrs in ipv4', () => {
+    expect(IPAddress.partOfCIDR('127.0.0.1', [ip6addr.createCIDR('127.0.0.0/8')])).toBe(true)
+    expect(IPAddress.partOfCIDR('127.0.0.1', [ip6addr.createCIDR('128.0.0.0/8')])).toBe(false)
+    expect(IPAddress.partOfCIDR('127.0.0.1', [ip6addr.createCIDR('126.0.0.0/8')])).toBe(false)
+  })
+  it('should detect cidrs in ipv6', () => {
+    expect(IPAddress.partOfCIDR('::1', [ip6addr.createCIDR('::/8')])).toBe(true)
+    expect(IPAddress.partOfCIDR('::1', [ip6addr.createCIDR('2ff0::1:0/8')])).toBe(false)
+    expect(IPAddress.partOfCIDR('::1', [ip6addr.createCIDR('3ff0::2:0/8')])).toBe(false)
+  })
+
+  it('should also work non-static', () => {
+    expect(new IPAddress('::1').partOfCIDR([ip6addr.createCIDR('::/8')])).toBe(true)
+  })
+})
+
+describe('IPAddress randomCIDRIp', () => {
+  const testCount = 25000
+
+  it('"loopback" should return random loopback ip4/6', () => {
+    const stats:any={
+      '4':0,
+      '6':0
+    }
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('loopback')
+      stats[rip.kind().toString()]++
+      expect(rip.isLoopbackIP()).toBe(true)
+    }
+    // we need to have at least 30% of ipv4 and ipv6
+    expect(stats['4']).toBeGreaterThan(testCount*0.3)
+    expect(stats['6']).toBeGreaterThan(testCount*0.3)
+  })
+
+  it('"loopback4" should return random loopback ip4', () => {
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('loopback4')
+      expect(rip.kind()).toBe(4)
+      expect(rip.isLoopbackIP()).toBe(true)
+    }
+  })
+
+
+  it('"loopback6" should return random loopback ip6', () => {
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('loopback6')
+      expect(rip.kind()).toBe(6)
+      expect(rip.isLoopbackIP()).toBe(true)
+      // ipv6 has single loopback address
+      expect(rip.toString()).toBe('::1')
+    }
+  })
+
+  it('"lan" should return random LAN ip4/6', () => {
+    const stats:any={
+      '4':0,
+      '6':0
+    }
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('lan')
+      stats[rip.kind().toString()]++
+      // if (!rip.isLANIP()) console.log(rip.toString(),`must be lan but it is not`)
+      expect(rip.isLANIP()).toBe(true)
+    }
+    // we need to have at least 30% of ipv4 and ipv6
+    expect(stats['4']).toBeGreaterThan(testCount*0.3)
+    expect(stats['6']).toBeGreaterThan(testCount*0.3)
+  })
+
+
+  it('"lan6" should return random lan ip6', () => {
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('lan6')
+      expect(rip.kind()).toBe(6)
+      expect(rip.isLANIP()).toBe(true)
+    }
+  })
+
+  it('"lan4" should return random lan ip4', () => {
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('lan4')
+      expect(rip.kind()).toBe(4)
+      expect(rip.isLANIP()).toBe(true)
+    }
+  })
+
+  it('"local" should return random local ip4/6', () => {
+    const stats:any={
+      '4':0,
+      '6':0
+    }
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('local')
+      stats[rip.kind().toString()]++
+      expect(rip.isLocalIP()).toBe(true)
+    }
+    // we need to have at least 30% of ipv4 and ipv6
+    expect(stats['4']).toBeGreaterThan(testCount*0.3)
+    expect(stats['6']).toBeGreaterThan(testCount*0.3)
+  })
+
+  it('"local4" should return random local ip4', () => {
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('local4')
+      expect(rip.kind()).toBe(4)
+      expect(rip.isLocalIP()).toBe(true)
+    }
+  })
+
+  it('"local6" should return random local ip6', () => {
+    for(var i=0;i<testCount;i++) {
+      const rip = IPAddress.randomCIDRIp('local6')
+      expect(rip.kind()).toBe(6)
+      expect(rip.isLocalIP()).toBe(true)
+    }
+  })
 })

package/ts/models/IPAddress.ts

@@ -1,11 +1,43 @@
-import { randomIP, randomIP6, isLoopbackIP, isLANIp } from "./../"
+import debug from 'debug'
+import { randomIP, randomIP6, } from "./../"
 import ip6addr, { Addr, ToStringOpts } from 'ip6addr'
+import net from 'net'
 const ip6 = require('ip6') // "url": "https://github.com/elgs/ip6"
+const dbg = debug('_IPAddress')
+dbg.enabled = true
 // need version "ip6": "0.2.7",!!
 
 export class IPAddress {
     private _ip: Addr
 
+    public static loopback_cidrs4 = [
+        ip6addr.createCIDR('127.0.0.0/8'),
+    ]
+
+    public static loopback_cidrs6 = [
+        ip6addr.createCIDR('::1/128') // yes ipv6 has single address
+    ]
+
+    public static loopback_cidrs = IPAddress.loopback_cidrs4.concat(IPAddress.loopback_cidrs6)
+
+    public static lan_cidrs4 = [
+        ip6addr.createCIDR('10.0.0.0/8'),
+        ip6addr.createCIDR('172.16.0.0/12'),
+        ip6addr.createCIDR('192.168.0.0/16'),
+    ]
+
+    public static lan_cidrs6 = [
+        ip6addr.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
+        ip6addr.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
+    ]
+
+    public static lan_cidrs = IPAddress.lan_cidrs4.concat(IPAddress.lan_cidrs6)
+
+    public static local_cidrs = IPAddress.loopback_cidrs.concat(IPAddress.lan_cidrs)
+    public static local_cidrs4 = IPAddress.loopback_cidrs4.concat(IPAddress.lan_cidrs4)
+    public static local_cidrs6 = IPAddress.loopback_cidrs6.concat(IPAddress.lan_cidrs6)
+
+
     constructor(ip: string) { // may throw
         if (ip === '-') ip = '0.0.0.0'
 
@@ -51,11 +83,34 @@ export class IPAddress {
     }
 
     public isLoopbackIP(): boolean {
-        return isLoopbackIP(this._ip.toString())
+        return this.partOfCIDR(IPAddress.loopback_cidrs)
     }
 
     public isLANIP(): boolean {
-        return isLANIp(this._ip.toString())
+        return this.partOfCIDR(IPAddress.lan_cidrs)
+    }
+
+    public isLocalIP(): boolean {
+        return this.partOfCIDR(IPAddress.local_cidrs)
+    }
+
+    partOfCIDR(cidr_networks: ip6addr.CIDR[]): boolean {
+        const ipNormalized = this.toString()
+        let ipVersion = net.isIPv4(ipNormalized) ? 'ipv4' : 'ipv6'
+        for (let cidr of cidr_networks) {
+            if (!cidr) continue
+            let first = cidr.first()
+            if (first.kind() !== ipVersion) continue
+            if (cidr.contains(ipNormalized))
+                return true
+        }
+        return false
+    }
+
+    static partOfCIDR(_ip: string, cidr_networks: ip6addr.CIDR[]): boolean {
+        const ip = IPAddress.try(_ip)
+        if (ip === undefined) return false
+        return ip.partOfCIDR(cidr_networks)
     }
 
     public isPublicIP(): boolean {
@@ -86,6 +141,46 @@ export class IPAddress {
         return new IPAddress(randomIP6())
     }
 
+
+    public static randomCIDRIp(cidr: ip6addr.CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress {
+        if (cidr === 'loopback') cidr = IPAddress.loopback_cidrs
+        if (cidr === 'loopback4') cidr = IPAddress.loopback_cidrs4
+        if (cidr === 'loopback6') cidr = IPAddress.loopback_cidrs6
+        if (cidr === 'lan') cidr = IPAddress.lan_cidrs
+        if (cidr === 'lan4') cidr = IPAddress.lan_cidrs4
+        if (cidr === 'lan6') cidr = IPAddress.lan_cidrs6
+        if (cidr === 'local') cidr = IPAddress.local_cidrs
+        if (cidr === 'local4') cidr = IPAddress.local_cidrs4
+        if (cidr === 'local6') cidr = IPAddress.local_cidrs6
+        // dbg('randomCIDRIp', cidr)
+        if (cidr.length === 0) throw new Error('CIDR array is empty')
+        // Pick a random CIDR network
+        const network = cidr[Math.floor(Math.random() * cidr.length)];
+        // dbg('randomCIDRIp:network', network)
+        // Get the range of IPs in this CIDR
+        const start = network.first().toBigInt()
+        // dbg('randomCIDRIp:first', network.first().toString(),start)
+        const end = network.last().toBigInt();
+        // dbg('randomCIDRIp:last', network.last().toString(),end)
+        let range : any = end-start
+        // dbg('randomCIDRIp:first:last', start, end)
+
+        
+        // Generate a random Long between the start and end
+        // if start-end > Maximum integer number
+        // we need to use BigInt
+        if (range > BigInt(Number.MAX_SAFE_INTEGER)) range=(Number.MAX_SAFE_INTEGER)
+        
+        const randomBigInt = BigInt(Math.floor(Math.random() * (Number(range) + 1))) + start;
+        // dbg('randomBigInt', randomBigInt)
+
+        // Convert the BigInt back to an IP address
+        const randomIp = ip6addr.parse(randomBigInt)
+        // dbg('randomCIDRIp', randomIp.toString())
+
+        return new IPAddress(randomIp.toString())
+    }
+
     public serialize(): string {
         if (this.kind() === 4) {
             // zero pad ipv4

package/tsconfig.json

@@ -26,7 +26,8 @@
       "@root/*": ["./*"],
       "@models/*": ["./models/*"],
       "@inc/*": ["./inc/ts/*"]
-    }
+    },
+    "typeRoots": ["./node_modules/@types", "./types/"]
   },
   "exclude": [
     "**/*.test.ts"

package/types/ip6addr.d.ts

@@ -0,0 +1,46 @@
+declare module 'ip6addr' {
+    export interface ToStringOpts {
+        format?: "auto" | "v4" | "v4-mapped" | "v6" | undefined;
+        zeroElide?: boolean | undefined;
+        zeroPad?: boolean | undefined;
+    }
+    
+    export interface Addr {
+        kind: () => "ipv4" | "ipv6";
+        toString: (opts?: ToStringOpts) => string;
+        toBuffer: (buff?: Uint8Array) => Uint8Array;
+        toLong: () => number;
+        toBigInt: () => bigint;
+        offset: (num: number) => Addr | null;
+        compare: (other: string | Addr) => number;
+        clone: () => Addr;
+        and: (input: string | Addr) => Addr;
+        or: (input: string | Addr) => Addr;
+        not: () => Addr;
+    }
+    
+    export interface AddrRange {
+        contains: (input: string | Addr) => boolean;
+        first: () => Addr;
+        last: () => Addr;
+    }
+    
+    export interface CIDR extends AddrRange {
+        broadcast: () => Addr;
+        compare: (other: string | CIDR) => number;
+        prefixLength: (format?: "auto" | "v4" | "v6") => number;
+        address: () => Addr;
+        toString: (opts?: ToStringOpts) => string;
+    }
+    
+    export function compare(addr1: string | Addr, addr2: string | Addr): number;
+    
+    export function compareCIDR(cidr1: string | CIDR, cidr2: string | CIDR): number;
+    
+    export function createAddrRange(begin: string | Addr, end: string | Addr): AddrRange;
+    
+    export function createCIDR(addr: string | Addr, len?: number): CIDR;
+    
+    export function parse(input: string | number | Addr | BigInt): Addr;
+    
+}