mybase 1.1.34 → 1.1.36

package/ts/funcs/getMysql2.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMysql2 = void 0;
+const mysql2 = __importStar(require("mysql2"));
+const debug_1 = __importDefault(require("debug"));
+const dbg = (0, debug_1.default)("getMysql2");
+async function getMysql2(config, pingInterval = 0) {
+    return new Promise((resolve, reject) => {
+        const mysql_client = mysql2.createConnection({
+            host: config.host,
+            port: config.port ? config.port : 3306,
+            user: config.login,
+            password: config.password,
+            database: config.db
+        });
+        mysql_client.connect((err) => {
+            if (err) {
+                dbg(`mysql connection has failed to ${config.host}@${config.db}`, err);
+                return reject(err);
+            }
+            dbg(`mysql connection has been established to ${config.host}@${config.db}`);
+            // install a pinger every 30 seconds to keep the connection alive
+            if (pingInterval > 0)
+                setInterval(() => {
+                    mysql_client.ping(function (err) {
+                        if (err)
+                            return console.log(`could not ping mysql ${config.host}@${config.db}`, err.code);
+                        dbg(`mysql ${config.host}@${config.db} is pinging properly`);
+                    });
+                }, pingInterval);
+            resolve(mysql_client);
+        });
+    });
+}
+exports.getMysql2 = getMysql2;
+//# sourceMappingURL=getMysql2.js.map

package/ts/funcs/getMysql2.ts

@@ -0,0 +1,42 @@
+import * as mysql2 from "mysql2"
+import { QueryError,Connection } from "mysql2"
+import debug from "debug"
+const dbg = debug("getMysql2")
+
+export type Mysql2ServerConfiguration = {
+    host: string,
+    port: number,
+    login: string,
+    password: string,
+    db: string
+}
+
+export async function getMysql2(config: Mysql2ServerConfiguration, pingInterval: number = 0):Promise<Connection> {
+    return new Promise((resolve, reject) => {
+        const mysql_client = mysql2.createConnection({
+            host: config.host,
+            port: config.port ? config.port : 3306,
+            user: config.login,
+            password: config.password,
+            database: config.db
+        })
+
+        mysql_client.connect((err: QueryError | null) => {
+            if (err) {
+                dbg(`mysql connection has failed to ${config.host}@${config.db}`, err)
+                return reject(err)
+            }
+            dbg(`mysql connection has been established to ${config.host}@${config.db}`)
+            // install a pinger every 30 seconds to keep the connection alive
+            if (pingInterval > 0)
+                setInterval(() => {
+                    mysql_client.ping(function (err:QueryError | null) {
+                        if (err) 
+                            return console.log(`could not ping mysql ${config.host}@${config.db}`, err.code)
+                        dbg(`mysql ${config.host}@${config.db} is pinging properly`)
+                    })
+                }, pingInterval)
+            resolve(mysql_client)
+        })
+    })
+}

package/ts/funcs/getWeekNumber.d.ts

@@ -0,0 +1 @@
+export declare function getWeekNumber(d?: Date): number;

package/ts/funcs/getWeekNumber.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWeekNumber = void 0;
+// credit: https://stackoverflow.com/questions/6117814/get-week-of-year-in-javascript-like-in-php
+/* For a given date, get the ISO week number
+ 
+  Based on information at:
+ 
+     THIS PAGE (DOMAIN EVEN) DOESN'T EXIST ANYMORE UNFORTUNATELY
+     http://www.merlyn.demon.co.uk/weekcalc.htm#WNR
+ 
+  Algorithm is to find nearest thursday, it's year
+  is the year of the week number. Then get weeks
+  between that date and the first day of that year.
+ 
+  Note that dates in one year can be weeks of previous
+  or next year, overlap is up to 3 days.
+ 
+  e.g. 2014/12/29 is Monday in week  1 of 2015
+       2012/1/1   is Sunday in week 52 of 2011
+*/
+function getWeekNumber(d = new Date()) {
+    // Copy date so don't modify original
+    const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+    // Set to nearest Thursday: current date + 4 - current day number
+    // Make Sunday's day number 7
+    date.setUTCDate(date.getUTCDate() + 4 - (date.getUTCDay() || 7));
+    // Get first day of year
+    const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+    // Calculate full weeks to nearest Thursday
+    const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    // Return the week number
+    return weekNo;
+}
+exports.getWeekNumber = getWeekNumber;
+//# sourceMappingURL=getWeekNumber.js.map

package/ts/funcs/getWeekNumber.test.ts

@@ -0,0 +1,9 @@
+import { getWeekNumber } from './getWeekNumber'
+
+
+describe('getWeekNumber', () => {
+    it('should return the correct week number', () => {
+        expect(getWeekNumber(new Date('2012-01-01'))).toBe(52)
+        expect(getWeekNumber(new Date('2014-12-30'))).toBe(1)
+    })  
+})

package/ts/funcs/getWeekNumber.ts

@@ -0,0 +1,31 @@
+// credit: https://stackoverflow.com/questions/6117814/get-week-of-year-in-javascript-like-in-php
+/* For a given date, get the ISO week number
+ 
+  Based on information at:
+ 
+     THIS PAGE (DOMAIN EVEN) DOESN'T EXIST ANYMORE UNFORTUNATELY
+     http://www.merlyn.demon.co.uk/weekcalc.htm#WNR
+ 
+  Algorithm is to find nearest thursday, it's year
+  is the year of the week number. Then get weeks
+  between that date and the first day of that year.
+ 
+  Note that dates in one year can be weeks of previous
+  or next year, overlap is up to 3 days.
+ 
+  e.g. 2014/12/29 is Monday in week  1 of 2015
+       2012/1/1   is Sunday in week 52 of 2011
+*/
+export function getWeekNumber(d: Date = new Date()): number {
+    // Copy date so don't modify original
+    const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+    // Set to nearest Thursday: current date + 4 - current day number
+    // Make Sunday's day number 7
+    date.setUTCDate(date.getUTCDate() + 4 - (date.getUTCDay() || 7));
+    // Get first day of year
+    const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+    // Calculate full weeks to nearest Thursday
+    const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    // Return the week number
+    return weekNo;
+}

package/ts/funcs/hash_sha512.d.ts

@@ -0,0 +1 @@
+export declare function hash_sha512(plainString: string): string;

package/ts/funcs/hash_sha512.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash_sha512 = void 0;
+const js_sha512_1 = require("js-sha512");
+function hash_sha512(plainString) {
+    if (typeof plainString === 'string')
+        return (0, js_sha512_1.sha512)(plainString);
+    return "";
+}
+exports.hash_sha512 = hash_sha512;
+//# sourceMappingURL=hash_sha512.js.map

package/ts/funcs/hash_sha512.ts

@@ -0,0 +1,7 @@
+import { sha512 } from 'js-sha512'
+
+export function hash_sha512(plainString:string) : string {
+    if (typeof plainString==='string') 
+        return sha512(plainString)
+    return ""
+}

package/ts/funcs/initMysql2Pool.d.ts

@@ -0,0 +1,3 @@
+import { Pool } from "mysql2";
+import { Mysql2ServerConfiguration } from "./getMysql2";
+export declare function initMysql2Pool(sqlServer: Mysql2ServerConfiguration): Pool;

package/ts/funcs/initMysql2Pool.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMysql2Pool = void 0;
+const mysql2 = __importStar(require("mysql2"));
+const debug_1 = __importDefault(require("debug"));
+const dbg = (0, debug_1.default)("initMysql2Pool");
+function initMysql2Pool(sqlServer) {
+    const connectionUri = `mysql://${sqlServer.login}:${sqlServer.password}@${sqlServer.host}`;
+    dbg(`creating mysql pool to ${sqlServer.host}@${sqlServer.db} as connectionUri=${connectionUri}`);
+    return mysql2.createPool(connectionUri);
+}
+exports.initMysql2Pool = initMysql2Pool;
+//# sourceMappingURL=initMysql2Pool.js.map

package/ts/funcs/initMysql2Pool.ts

@@ -0,0 +1,11 @@
+import * as mysql2 from "mysql2"
+import { Pool } from "mysql2"
+import debug from "debug"
+import { Mysql2ServerConfiguration } from "./getMysql2"
+const dbg = debug("initMysql2Pool")
+
+export function initMysql2Pool(sqlServer: Mysql2ServerConfiguration): Pool {
+    const connectionUri = `mysql://${sqlServer.login}:${sqlServer.password}@${sqlServer.host}`
+    dbg(`creating mysql pool to ${sqlServer.host}@${sqlServer.db} as connectionUri=${connectionUri}`)
+    return mysql2.createPool(connectionUri)
+}

package/ts/funcs/int2ip.d.ts

@@ -0,0 +1 @@
+export declare function int2ip(ipInt: number): string;

package/ts/funcs/int2ip.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.int2ip = void 0;
+const net_1 = __importDefault(require("net"));
+//we only support ipv4
+function int2ip(ipInt) {
+    if (typeof ipInt !== 'number' || ipInt < 0)
+        throw new Error(`require number as input`);
+    const ip4 = ((ipInt >>> 24) + '.' + (ipInt >> 16 & 255) + '.' + (ipInt >> 8 & 255) + '.' + (ipInt & 255));
+    if (net_1.default.isIP(ip4) !== 4)
+        throw new Error(`Invalid IP: ${ip4}`);
+    return ip4;
+}
+exports.int2ip = int2ip;
+//# sourceMappingURL=int2ip.js.map

package/ts/funcs/int2ip.test.js

@@ -0,0 +1,33 @@
+const { int2ip } =require('./int2ip')
+
+describe('int2ip', () => {
+  it('should convert integer to valid IPv4 address', () => {
+    const ipInt = 3232235521; // equivalent to 192.168.0.1
+    const result = int2ip(ipInt);
+    expect(result).toBe('192.168.0.1');
+  });
+
+  it('should throw an error for non-numeric input', () => {
+    const ipInt = '3232235521'; // string input instead of number
+    expect(() => int2ip(ipInt)).toThrow('require number as input');
+    expect(() => int2ip([])).toThrow('require number as input');
+    expect(() => int2ip(null)).toThrow('require number as input');
+    expect(() => int2ip({})).toThrow('require number as input');
+  });
+
+  it('overflowing is allowed', () => {
+    const ipInt = 4294967297;
+    let ip = int2ip(ipInt)
+    expect(ip).toBe('0.0.0.1')
+  });
+
+  it('should support 0', () => {
+    const ipInt = 0;
+    expect(int2ip(ipInt)).toBe('0.0.0.0')
+  });
+
+  it('negative numbers should throw', () => {
+    expect(() => int2ip(-1)).toThrow('require number as input');
+  })
+
+});

package/ts/funcs/int2ip.ts

@@ -0,0 +1,9 @@
+import net from 'net'
+
+//we only support ipv4
+export function int2ip (ipInt: number) : string {
+    if (typeof ipInt !== 'number' || ipInt<0) throw new Error(`require number as input`)
+    const ip4 = ( (ipInt>>>24) +'.' + (ipInt>>16 & 255) +'.' + (ipInt>>8 & 255) +'.' + (ipInt & 255) )
+    if (net.isIP(ip4) !== 4) throw new Error(`Invalid IP: ${ip4}`)
+    return ip4
+}

package/ts/funcs/ip2int.d.ts

@@ -0,0 +1 @@
+export declare function ip2int(ip: string): number;

package/ts/funcs/ip2int.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ip2int = void 0;
+const net_1 = __importDefault(require("net"));
+// function int2ip (ipInt) {
+//     return ( (ipInt>>>24) +'.' + (ipInt>>16 & 255) +'.' + (ipInt>>8 & 255) +'.' + (ipInt & 255) );
+// }
+// only supports ipv4
+function ip2int(ip) {
+    if (net_1.default.isIP(ip) !== 4)
+        throw new Error(`Invalid IP: ${ip}`);
+    return ip.split('.').reduce(function (ipInt, octet) { return (ipInt << 8) + parseInt(octet, 10); }, 0) >>> 0;
+}
+exports.ip2int = ip2int;
+//# sourceMappingURL=ip2int.js.map

package/ts/funcs/ip2int.test.js

@@ -0,0 +1,30 @@
+const { ip2int } = require('./ip2int');
+const { randomIP } = require('./randomIP');
+
+describe('ip2int', () => {
+  it('should convert IP address to integer', () => {
+    const ipAddress = '192.168.0.1';
+    const result = ip2int(ipAddress);
+    expect(result).toBe(3232235521);
+  })
+
+  it('invalid inputs', () => {
+    expect(() => ip2int('')).toThrow()
+    expect(() => ip2int('192.168.0')).toThrow()
+    expect(() => ip2int(null)).toThrow()
+    expect(() => ip2int(undefined)).toThrow()
+  })
+
+  it('should not support ipv6', () => {
+    const ipAddress = '::';
+    expect(() => ip2int(ipAddress)).toThrow()
+  })
+
+  it('test 100 random ips', () => {
+    for (let i = 0; i < 100; i++) {
+      const ipAddress = randomIP();
+      const result = ip2int(ipAddress);
+      expect(result).toBe(ip2int(ipAddress));
+    }
+  })
+});

package/ts/funcs/ip2int.ts

@@ -0,0 +1,10 @@
+import net from 'net'
+// function int2ip (ipInt) {
+//     return ( (ipInt>>>24) +'.' + (ipInt>>16 & 255) +'.' + (ipInt>>8 & 255) +'.' + (ipInt & 255) );
+// }
+
+// only supports ipv4
+export function ip2int(ip:string) {
+    if (net.isIP(ip) !== 4) throw new Error(`Invalid IP: ${ip}`)
+    return ip.split('.').reduce(function(ipInt, octet) { return (ipInt<<8) + parseInt(octet, 10)}, 0) >>> 0;
+}

package/ts/funcs/isLANIp.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@root/ip6addr" />
+import ip6addr from 'ip6addr';
+export declare const private_network_cidrs: ip6addr.CIDR[];
+export declare function isLANIp(ip: string): boolean;

package/ts/funcs/isLANIp.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLANIp = exports.private_network_cidrs = void 0;
+const ip6addr_1 = __importDefault(require("ip6addr"));
+const net_1 = __importDefault(require("net"));
+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 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 exports.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;
+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.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,37 @@
+import ip6addr from 'ip6addr'
+import net from 'net'
+
+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
+    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
+}
+
+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/isLocal.d.ts

@@ -0,0 +1 @@
+export declare function isLocal(): boolean;

package/ts/funcs/isLocal.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocal = void 0;
+const os_1 = __importDefault(require("os"));
+function isLocal() {
+    return (os_1.default.type() === 'Darwin');
+}
+exports.isLocal = isLocal;
+//# sourceMappingURL=isLocal.js.map

package/ts/funcs/isLocal.test.ts

@@ -0,0 +1,16 @@
+import { isLocal } from './isLocal';
+import os from 'os';
+
+describe('isLocal', () => {
+  it('should return true on Darwin OS', () => {
+    jest.spyOn(os, 'type').mockReturnValue('Darwin');
+    const result = isLocal();
+    expect(result).toBe(true);
+  });
+
+  it('should return false on non-Darwin OS', () => {
+    jest.spyOn(os, 'type').mockReturnValue('Linux');
+    const result = isLocal();
+    expect(result).toBe(false);
+  });
+});

package/ts/funcs/isLocal.ts

@@ -0,0 +1,5 @@
+import os from  'os'
+
+export function isLocal() : boolean {
+    return (os.type() === 'Darwin')
+}

package/ts/funcs/isLoopbackIP.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@root/ip6addr" />
+import ip6addr from 'ip6addr';
+export declare const local_network_cidrs: ip6addr.CIDR[];
+export declare function isLoopbackIP(ip: string): boolean;

package/ts/funcs/isLoopbackIP.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoopbackIP = exports.local_network_cidrs = void 0;
+const ip6addr_1 = __importDefault(require("ip6addr"));
+const net_1 = __importDefault(require("net"));
+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)
+        return false;
+    try {
+        // speed optimized
+        let ipVersion = net_1.default.isIPv4(ip) ? 'ipv4' : 'ipv6';
+        for (let cidr of exports.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;
+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