mybase 1.1.14 → 1.1.16

package/jest/isLoopbackIP.test.js

@@ -1,32 +1,31 @@
-const { isLoopbackIP } = require('./../mybase'); // adjust the path to mybase.js
+const { isLoopbackIP } = require('./../mybase') // adjust the path to mybase.js
 
 test('should return true for local IPv4', () => {
-    const ip = '127.0.0.1';
-    expect(isLoopbackIP(ip)).toBe(true);
-});
+    const ip = '127.0.0.1'
+    expect(isLoopbackIP(ip)).toBe(true)
+})
 
 test('should return true for local IPv4', () => {
-    const ip = '127.127.127.127';
-    expect(isLoopbackIP(ip)).toBe(true);
-});
-
+    const ip = '127.127.127.127'
+    expect(isLoopbackIP(ip)).toBe(true)
+})
 
 test('should return true for local IPv6', () => {
-    const ip = '::1';
-    expect(isLoopbackIP(ip)).toBe(true);
-});
+    const ip = '::1'
+    expect(isLoopbackIP(ip)).toBe(true)
+})
 
 test('should return null for non-local IPv4', () => {
-    const ip = '8.8.8.8';
-    expect(isLoopbackIP(ip)).toBe(null);
-});
+    const ip = '8.8.8.8'
+    expect(isLoopbackIP(ip)).toBe(null)
+})
 
 test('should return null for non-local IPv6', () => {
-    const ip = '2001:4860:4860::8888';
-    expect(isLoopbackIP(ip)).toBe(null);
-});
+    const ip = '2001:4860:4860::8888'
+    expect(isLoopbackIP(ip)).toBe(null)
+})
 
 test('should return false for invalid IP', () => {
-    const ip = 'invalid';
-    expect(isLoopbackIP(ip)).toBe(false);
-});
+    const ip = 'invalid'
+    expect(isLoopbackIP(ip)).toBe(false)
+})

package/jest.config.js

@@ -2,4 +2,5 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
+  testTimeout: 15000,
 };

package/mybase.js

@@ -14,8 +14,10 @@ const ip6addr = require('ip6addr')
 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')
+            ,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.
         ]
+
 const local_network_cidrs = [ip6addr.createCIDR('127.0.0.0/8')
         ,ip6addr.createCIDR('::1/128')]
 
@@ -47,7 +49,7 @@ function normalizeIp(ip) {
 }
 
 
-function isLoopbackIP(ip) {
+function isLoopbackIP(ip) { // ported
     ip=normalizeIp(ip)
     if (net.isIP(ip) === 0) return false
     try {
@@ -66,13 +68,14 @@ function isLoopbackIP(ip) {
     return false
 }
 
-function isLANIp(ip) {
+function isLANIp(ip) { // ported
     ip=normalizeIp(ip)
     if (net.isIP(ip) === 0) return false
     try {
         // speed optimized
         let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
         for (let cidr of private_network_cidrs) {
+            if (!cidr) continue
             let first = cidr.first()
             if (first.kind() !== ipVersion) continue
             if (cidr.contains(ip))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.14",
+  "version": "1.1.16",
   "description": "",
   "main": "mybase.js",
   "scripts": {
@@ -25,6 +25,7 @@
   "devDependencies": {
     "@jest/globals": "^29.7.0",
     "@types/debug": "^4.1.12",
+    "@types/ip6addr": "^0.2.6",
     "@types/jest": "^29.5.11",
     "@types/node": "^20.11.5",
     "@types/validator": "^13.11.8",

package/ts/funcs/isLANIp.d.ts

@@ -0,0 +1 @@
+export declare function isLANIp(ip: string): boolean;

package/ts/funcs/isLANIp.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLANIp = 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'),
+    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)
+        return false;
+    try {
+        // speed optimized
+        let ipVersion = net_1.default.isIPv4(ip) ? 'ipv4' : 'ipv6';
+        for (let cidr of private_network_cidrs) {
+            if (!cidr)
+                continue;
+            let first = cidr.first();
+            if (first.kind() !== ipVersion)
+                continue;
+            if (cidr.contains(ip))
+                return true;
+        }
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return false;
+}
+exports.isLANIp = isLANIp;

package/ts/funcs/isLANIp.test.ts

@@ -0,0 +1,59 @@
+import { isLANIp } from './isLANIp';
+
+describe('isLANIp', () => {
+  it('should return true for LAN IP addresses', () => {
+    expect(isLANIp('192.168.0.1')).toBe(true);
+    expect(isLANIp('10.0.0.1')).toBe(true);
+    expect(isLANIp('172.16.0.1')).toBe(true);
+    
+    // Add more test cases for LAN IP addresses
+  });
+
+  it('should return false for non-LAN IP addresses', () => {
+    expect(isLANIp('8.8.8.8')).toBe(false);
+    expect(isLANIp('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(false);
+    // Add more test cases for non-LAN IP addresses
+  });
+
+  it('should return false for invalid IP addresses', () => {
+    expect(isLANIp('')).toBe(false);
+    expect(isLANIp('192.168.0.')).toBe(false);
+    expect(isLANIp('256.0.0.1')).toBe(false);
+    // Add more test cases for invalid IP addresses
+  });
+
+  test('should return true for private IPv4', () => {
+    const ip = '192.168.1.1';
+    expect(isLANIp(ip)).toBe(true);
+});
+
+test('should return true for private IPv6', () => {
+    const ip = 'fd00::';
+    expect(isLANIp(ip)).toBe(true);
+});
+
+test('should return null for public IPv4', () => {
+    const ip = '8.8.8.8';
+    expect(isLANIp(ip)).toBe(false);
+});
+
+test('should return false for public IPv6', () => {
+    const ip = '2001:4860:4860::8888';
+    expect(isLANIp(ip)).toBe(false);
+});
+
+test('should return false for invalid IP', () => {
+    const ip = 'invalid';
+    expect(isLANIp(ip)).toBe(false);
+});
+
+test('should return false for invalid IP', () => {
+    const ip = '1.2.3';
+    expect(isLANIp(ip)).toBe(false);
+});
+
+test('should return null for non private IPv6', () => {
+    const ip = '::2';
+    expect(isLANIp(ip)).toBe(false);
+});
+});

package/ts/funcs/isLANIp.ts

@@ -0,0 +1,38 @@
+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 function isLANIp(ip:string) : boolean { 
+    ip=normalizeIp(ip)
+    if (net.isIP(ip) === 0) return false
+    try {
+        // speed optimized
+        let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
+        for (let cidr of private_network_cidrs) {
+            if (!cidr) continue
+            
+            let first = cidr.first()
+            if (first.kind() !== ipVersion) continue
+            if (cidr.contains(ip))
+                return true
+        }
+    } catch (err) {
+        console.log(err)
+    }
+    return false
+}

package/ts/funcs/isLoopbackIP.d.ts

@@ -0,0 +1 @@
+export declare function isLoopbackIP(ip: string): boolean;

package/ts/funcs/isLoopbackIP.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoopbackIP = 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;
+}
+function isLoopbackIP(ip) {
+    ip = normalizeIp(ip);
+    if (net_1.default.isIP(ip) === 0)
+        return false;
+    try {
+        // speed optimized
+        let ipVersion = net_1.default.isIPv4(ip) ? 'ipv4' : 'ipv6';
+        for (let cidr of local_network_cidrs) {
+            let first = cidr.first();
+            if (first.kind() !== ipVersion)
+                continue;
+            if (cidr.contains(ip))
+                return true;
+        }
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return false;
+}
+exports.isLoopbackIP = isLoopbackIP;

package/ts/funcs/isLoopbackIP.test.ts

@@ -0,0 +1,69 @@
+import { randomIP } from './randomIP';
+import { isLoopbackIP } from './isLoopbackIP';
+
+describe('isLoopbackIP', () => {
+    test('should return true for loopback IPv4 address', () => {
+        expect(isLoopbackIP('127.0.0.1')).toBe(true);
+    });
+
+    test('should return true for loopback IPv6 address', () => {
+        expect(isLoopbackIP('::1')).toBe(true);
+    });
+
+    test('should return false for non-loopback IPv4 address', () => {
+        expect(isLoopbackIP('192.168.0.1')).toBe(false);
+    });
+
+    test('should return false for non-loopback IPv6 address', () => {
+        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(false);
+    });
+
+    test('should return false for invalid IP address', () => {
+        expect(isLoopbackIP('invalid')).toBe(false);
+    });
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.0.0.1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.2.0.1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.255.0.1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.127.127.127'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv6', () => {
+        const ip = '::1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return null for non-local IPv4', () => {
+        const ip = '8.8.8.8'
+        expect(isLoopbackIP(ip)).toBe(false)
+    })
+
+    test('should return null for non-local IPv6', () => {
+        const ip = '2001:4860:4860::8888'
+        expect(isLoopbackIP(ip)).toBe(false)
+    })
+
+    test('should return false for invalid IP', () => {
+        const ip = 'invalid'
+        expect(isLoopbackIP(ip)).toBe(false)
+    })
+
+    test('random ips should not be Loopback', () => {
+        for(let i=0;i<100;i++)
+            expect(isLoopbackIP(randomIP())).toBe(false)
+    })
+});

package/ts/funcs/isLoopbackIP.ts

@@ -0,0 +1,32 @@
+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 function isLoopbackIP(ip:string) : boolean {
+    ip=normalizeIp(ip)
+    if (net.isIP(ip) === 0) return false
+    try {
+        // speed optimized
+        let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
+        for (let cidr of local_network_cidrs) {
+            let first = cidr.first()
+            if (first.kind() !== ipVersion) continue
+            if (cidr.contains(ip))
+                return true
+        }
+    } catch (err) {
+        console.log(err)
+    }
+    return false
+}

package/ts/funcs/randomTCPPort.test.ts

@@ -59,4 +59,4 @@ describe("randomTCPPort", () => {
     expect(port).toBe(false);
   });
 
-});
+})

package/ts/index.d.ts

@@ -16,3 +16,5 @@ export * from "./funcs/int2ip";
 export * from "./funcs/randomIP6";
 export * from "./funcs/randomTCPPort";
 export * from "./funcs/validEmail";
+export * from "./funcs/isLoopbackIP";
+export * from "./funcs/isLANIp";

package/ts/index.js

@@ -32,3 +32,5 @@ __exportStar(require("./funcs/int2ip"), exports);
 __exportStar(require("./funcs/randomIP6"), exports);
 __exportStar(require("./funcs/randomTCPPort"), exports);
 __exportStar(require("./funcs/validEmail"), exports);
+__exportStar(require("./funcs/isLoopbackIP"), exports);
+__exportStar(require("./funcs/isLANIp"), exports);

package/ts/index.ts

@@ -16,4 +16,5 @@ export * from "./funcs/int2ip"
 export * from "./funcs/randomIP6"
 export * from "./funcs/randomTCPPort"
 export * from "./funcs/validEmail"
-
+export * from "./funcs/isLoopbackIP"
+export * from "./funcs/isLANIp"