mybase 1.1.51 → 1.2.2

package/mybase.ts

@@ -0,0 +1,397 @@
+/// <reference path="./ip6addr.d.ts" />
+//#region imports
+import ipRangeCheck from 'ip-range-check'
+import aesjs from 'aes-js'
+import createDebug from 'debug'
+import os from 'os'
+import fs from 'fs'
+import path from 'path'
+import net from 'net'
+import chalk from 'chalk'
+import validURLFn from '@7c/validurl'
+import { sha512 } from 'js-sha512'
+import * as ip6 from 'ip6'
+import { Reader as MaxmindReader } from '@maxmind/geoip2-node'
+import type { MysqlConfig, MysqlConnection, MysqlConnector, SqlQueryable } from './ts/types'
+import { randomString } from './ts/funcs/randomString'
+//#endregion
+
+//#region re-export from ts/funcs
+export { randomString }
+export { wait } from './ts/funcs/wait'
+export { utcnow } from './ts/funcs/utcnow'
+export { isLocal } from './ts/funcs/isLocal'
+export { validEmail } from './ts/funcs/validEmail'
+export { asJSON } from './ts/funcs/asJSON'
+export { promiseTimeout } from './ts/funcs/promiseTimeout'
+export { randomIP } from './ts/funcs/randomIP'
+export { MaxRuntimeHours } from './ts/funcs/MaxRuntimeHours'
+export { Geoip2Paths } from './ts/funcs/Geoip2Paths'
+export { vaultRead } from './ts/funcs/vaultRead'
+export { vaultFill } from './ts/funcs/vaultFill'
+export { hash_sha512 } from './ts/funcs/hash_sha512'
+export { isLoopbackIP } from './ts/funcs/isLoopbackIP'
+export { isLANIp } from './ts/funcs/isLANIp'
+//#endregion
+
+const debug = createDebug('mybase')
+
+//#region Date.prototype extension
+declare global {
+  interface Date {
+    yyyymmdd(): string
+  }
+}
+
+Date.prototype.yyyymmdd = function yyyymmdd(this: Date) {
+  const mm = this.getMonth() + 1
+  const dd = this.getDate()
+  return [this.getFullYear(), (mm > 9 ? '' : '0') + mm, (dd > 9 ? '' : '0') + dd].join('')
+}
+//#endregion
+
+export function validHPassword(hpassword: string): boolean {
+  return !!(hpassword && hpassword.length === 128 && hpassword.search(/^[a-f0-9]+$/) === 0)
+}
+
+export function randomHPassword(length = 10): string {
+  const plain = randomString(length)
+  return sha512(plain)
+}
+
+export function arrayRandomItem<T>(arry: unknown, defaultValue: T | false = false): T | false {
+  if (Array.isArray(arry)) return arry[Math.floor(Math.random() * arry.length)] as T
+  return defaultValue
+}
+
+export function validIp(str: unknown): boolean {
+  console.log(`WARNING: validIp is deprecated, use validIpNative or IPAddress model`)
+  if (str && typeof str === 'string') {
+    const splitted = str.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)$/)
+    if (splitted) {
+      for (const octet of splitted) {
+        if (parseInt(octet, 10) >= 0 && parseInt(octet, 10) <= 255) continue
+        return false
+      }
+      return true
+    }
+  }
+  return false
+}
+
+export function validIpNative(str: string): boolean {
+  return net.isIP(str) !== 0
+}
+
+export function isURL(url: unknown): URL | false {
+  if (typeof url === 'string') {
+    try {
+      return new URL(url)
+    } catch {
+      /* ignore */
+    }
+  }
+  return false
+}
+
+export function validTime(t: unknown): number | false {
+  const valid = !!(t && parseInt(String(t), 10) > 0 && String(t).length === 10)
+  if (!valid) return false
+  return parseInt(String(t), 10)
+}
+
+export function validURL(host: unknown): boolean {
+  return validURLFn(host)
+}
+
+export function isObject(a: unknown): boolean {
+  return !!a && (a as object).constructor === Object
+}
+
+export async function getMysql(mysqlClass: MysqlConnector, config: MysqlConfig, keep_pinging = true): Promise<MysqlConnection> {
+  const mysql_client = mysqlClass.createConnection({
+    host: config.host,
+    port: config.port ? config.port : 3306,
+    user: config.login,
+    password: config.password,
+    database: config.db,
+  })
+  await new Promise<void>((resolve, reject) => {
+    mysql_client.connect((err) => {
+      if (err) {
+        debug(`mysql connection has failed to ${config.host}@${config.db}`, err)
+        reject(err)
+        return
+      }
+      debug(`mysql connection has been established to ${config.host}@${config.db}`)
+      if (keep_pinging) {
+        setInterval(() => {
+          mysql_client.ping((errPing?: NodeJS.ErrnoException | Error | null) => {
+            if (errPing && 'code' in errPing) return console.log(`could not ping mysql ${config.host}@${config.db}`, errPing.code)
+            debug(chalk.bold(`mysql ${config.host}@${config.db} is pinging properly`))
+          })
+        }, 30000)
+      }
+      resolve()
+    })
+  })
+  return mysql_client
+}
+
+export async function maxmindOpen(geoipFile: string) {
+  debug(`maxmindOpen ${geoipFile}`)
+  try {
+    const reader = await MaxmindReader.open(geoipFile, { watchForUpdates: true })
+    debug(`${geoipFile} is opened successfully`)
+    return reader
+  } catch (err) {
+    debug(`maxmindOpen Error at ${geoipFile}`, err)
+    throw err
+  }
+}
+
+export function randomBase32(length = 10): string {
+  const charSet = 'abcdefghijklmnopqrstuvwxyz234567'
+  let text = ''
+  for (let i = 0; i < length; i++) text += charSet.charAt(Math.floor(Math.random() * charSet.length))
+  return text
+}
+
+export function validAuthcode(authcode: string): boolean {
+  const alphabetOnly = 'abcdefghijklmnopqrstuvwxyz'
+  if (!authcode || authcode.length !== 12) return false
+  const ac = authcode.toLowerCase()
+  if (ac.charAt(3) !== '-') return false
+  if (ac.charAt(9) !== '-') return false
+  let checksum = 0
+  const body = ac.substring(1)
+  for (let i = 0; i < body.length; i++) {
+    const c = body.charAt(i)
+    if (c === '-') continue
+    checksum += c.charCodeAt(0)
+  }
+  const checksumChar = alphabetOnly.charAt(checksum % alphabetOnly.length)
+  if (checksumChar !== ac.charAt(0)) return false
+  return true
+}
+
+export function randomAuthcode(): string {
+  const length = 9
+  const charSet = 'abcdefghijklmnopqrstuvwxyz234567'
+  const alphabetOnly = 'abcdefghijklmnopqrstuvwxyz'
+  let checksum = 0
+  let text = ''
+  for (let i = 0; i < length; i++) {
+    if (i === 2 || i === 7) text += '-'
+    const c = charSet.charAt(Math.floor(Math.random() * charSet.length))
+    checksum += c.charCodeAt(0)
+    text += c
+  }
+  text = alphabetOnly.charAt(checksum % alphabetOnly.length) + text
+  return text
+}
+
+export function array_shuffle<T>(a: T[]): T[] {
+  let j: number
+  let x: T
+  for (let i = a.length - 1; i > 0; i--) {
+    j = Math.floor(Math.random() * (i + 1))
+    x = a[i]
+    a[i] = a[j]
+    a[j] = x
+  }
+  return a
+}
+
+export function object_shuffle<T extends Record<string, unknown>>(object: T): T {
+  const keys = array_shuffle(Object.keys(object))
+  const ret: Record<string, unknown> = {}
+  for (const k of keys) ret[k] = object[k]
+  return ret as T
+}
+
+export async function canReadAndWrite(targetPath: string, _create = false): Promise<boolean> {
+  await new Promise<void>((resolve, reject) => {
+    fs.stat(targetPath, (err) => {
+      if (err) {
+        if (err.code === 'ENOENT') {
+          fs.mkdirSync(targetPath)
+        } else {
+          reject(err)
+          return
+        }
+      }
+      fs.access(targetPath, fs.constants.W_OK | fs.constants.R_OK, (errAcc) => {
+        if (errAcc) return reject(errAcc)
+        debug(`canReadAndWrite ${targetPath}`)
+        resolve()
+      })
+    })
+  })
+  return true
+}
+
+export function softexit(message: string | false = false, seconds = 60, exitcode = 1): void {
+  if (message) console.log(message)
+  console.log(`Softexit: will stop in ${seconds} seconds..`)
+  setTimeout(() => {
+    process.exit(exitcode)
+  }, seconds * 1000)
+}
+
+export function validHostname(value: unknown): boolean {
+  if (typeof value !== 'string') return false
+  let v = value
+  const validHostnameChars = /^[a-zA-Z0-9-.]{1,253}\.?$/g
+  if (!validHostnameChars.test(v)) return false
+  if (v.endsWith('.')) v = v.slice(0, v.length - 1)
+  if (v.length > 253) return false
+  const labels = v.split('.')
+  return labels.every((label) => {
+    const validLabelChars = /^([a-zA-Z0-9-]+)$/g
+    return validLabelChars.test(label) && label.length < 64 && !label.startsWith('-') && !label.endsWith('-')
+  })
+}
+
+export function validHostname2(domainName: unknown): boolean {
+  const domainNameRegex =
+    /^(?:[a-z0-9](?:[a-z0-9_\-]{0,61}[a-z0-9])?\.){0,126}(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9]))\.?$/i
+  if (!domainName || typeof domainName !== 'string') return false
+  if (net.isIPv4(domainName) || net.isIPv6(domainName.replace(/[\[\]]/g, ''))) return true
+  let dn = domainName.replace(/\.$/, '')
+  if (dn.length < 2) return false
+  if (dn.length > 255) return false
+  if (dn.search(/\./) < 0 && dn.search(/^[0-9]+$/) === 0) return false
+  return domainNameRegex.test(dn)
+}
+
+export function removeDoubleSlashes(url: unknown): string | false {
+  if (typeof url === 'string') return url.replace(/([^:]\/)\/+/g, '$1')
+  return false
+}
+
+export function getTemp(filename: string | false = false): string {
+  const tempDirectorySymbol = Symbol.for('__RESOLVED_TEMP_DIRECTORY__')
+  const g = globalThis as typeof globalThis & { [k: symbol]: string | undefined }
+  if (!g[tempDirectorySymbol]) {
+    Object.defineProperty(g, tempDirectorySymbol, {
+      value: fs.realpathSync(os.tmpdir()),
+    })
+  }
+  let tmp = g[tempDirectorySymbol] as string
+  if (filename) tmp = path.join(tmp, filename)
+  return tmp
+}
+
+export async function sqlQuery(sqlHandle: SqlQueryable, query: string, values: unknown[] = []): Promise<unknown> {
+  return await new Promise((resolve, reject) => {
+    sqlHandle.query(query, values, (err, res) => {
+      if (err) return reject(err)
+      resolve(res)
+    })
+  })
+}
+
+export function isMochaRunning(): boolean {
+  const context = globalThis as typeof globalThis & Record<string, unknown>
+  return ['afterEach', 'after', 'beforeEach', 'before', 'describe', 'it'].every((functionName) => {
+    return context[functionName] instanceof Function
+  })
+}
+
+export function validUUID4(uuid: string): boolean {
+  return /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.test(uuid)
+}
+
+export async function portCheck_tcp(port: number, opts: { timeout?: number; host?: string } = {}): Promise<boolean> {
+  const { timeout = 1000, host = '127.0.0.1' } = opts
+  const promise = new Promise<void>((resolve, reject) => {
+    const socket = new net.Socket()
+    const onError = (err: unknown) => {
+      debug(`onError`, err)
+      socket.destroy()
+      reject()
+    }
+    socket.setTimeout(timeout)
+    socket.once('error', onError)
+    socket.once('timeout', onError)
+    socket.connect(port, host, () => {
+      debug(`socket.connect ${host}:${port}`)
+      socket.end()
+      resolve()
+    })
+  })
+  try {
+    await promise
+    return true
+  } catch (e) {
+    console.log(e)
+    return false
+  }
+}
+
+export function ensureProperty<T>(target: Record<string, unknown>, propsString: string, defaultValue: T | false = false, debugWalk = false): unknown {
+  function iterate(o: Record<string, unknown>, parts: string[]): unknown {
+    if (debugWalk) console.log(parts)
+    const pname = parts.shift()
+    if (pname === undefined) return defaultValue
+    if (debugWalk) console.log(`iterate`, o, pname)
+    if (Object.prototype.hasOwnProperty.call(o, pname) && typeof o[pname] === 'object' && o[pname] !== null && parts.length > 0) {
+      return iterate(o[pname] as Record<string, unknown>, parts)
+    }
+    if (debugWalk) console.log(`--`, o, pname, o[pname], parts)
+    if (Object.prototype.hasOwnProperty.call(o, pname) && parts.length === 0) return o[pname]
+    if (debugWalk) console.log(`+++`)
+    return defaultValue
+  }
+  const parts = propsString.split('.')
+  return iterate(target, parts)
+}
+
+export function int2ip(ipInt: number): string {
+  return `${ipInt >>> 24}.${(ipInt >> 16) & 255}.${(ipInt >> 8) & 255}.${ipInt & 255}`
+}
+
+export function ip2int(ip: string): number {
+  return (
+    ip.split('.').reduce((ipInt, octet) => (ipInt << 8) + parseInt(octet, 10), 0) >>> 0
+  )
+}
+
+export function encryptAES_CBC_NOIV(plainString: string, encryptionKey: string): string | false {
+  try {
+    const key = aesjs.utils.utf8.toBytes(encryptionKey)
+    const textBytes = aesjs.utils.utf8.toBytes(plainString)
+    const aesCbc = new aesjs.ModeOfOperation.cbc(key)
+    const encryptedBytes = aesCbc.encrypt(aesjs.padding.pkcs7.pad(textBytes, 16))
+    return aesjs.utils.hex.fromBytes(encryptedBytes)
+  } catch {
+    return false
+  }
+}
+
+export function decryptAES_CBC_NOIV(encryptedHex: string, encryptionKey: string): string | false {
+  try {
+    const key = aesjs.utils.utf8.toBytes(encryptionKey)
+    const encryptedBytes = aesjs.utils.hex.toBytes(encryptedHex)
+    const aesCbc = new aesjs.ModeOfOperation.cbc(key)
+    const decryptedBytes = aesjs.padding.pkcs7.strip(aesCbc.decrypt(encryptedBytes))
+    return aesjs.utils.utf8.fromBytes(decryptedBytes)
+  } catch {
+    return false
+  }
+}
+
+export function isReservedLANIP(address: string): boolean {
+  const reservedLANIPRanges = [
+    '127.0.0.0/8',
+    '10.0.0.0/8',
+    '172.16.0.0/12',
+    '192.168.0.0/16',
+    '100.64.0.0/10',
+    'fd00::/8',
+  ]
+  const normalizedAddress = net.isIPv6(address) ? ip6.normalize(address) : address
+  return ipRangeCheck(normalizedAddress, reservedLANIPRanges)
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.51",
+  "version": "1.2.2",
   "description": "",
   "main": "mybase.js",
   "scripts": {
@@ -11,6 +11,7 @@
   "dependencies": {
     "@7c/node-ip6addr": "https://github.com/7c/node-ip6addr.git",
     "@7c/validurl": "0.0.3",
+    "@maxmind/geoip2-node": "^5.0.0",
     "@types/debug": "^4.1.12",
     "@types/ip6addr": "^0.2.6",
     "@types/mysql": "^2.15.25",
@@ -26,7 +27,7 @@
     "knex": "^3.1.0",
     "mysql": "^2.18.1",
     "mysql2": "^3.9.1",
-    "node-vault": "^0.10.2",
+    "node-vault": "^0.12.0",
     "psl": "^1.9.0",
     "punycode": "^2.1.1",
     "validator": "^13.7.0"

package/ts/funcs/Geoip2Paths.js

@@ -7,7 +7,7 @@ exports.Geoip2Paths = Geoip2Paths;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 function Geoip2Paths() {
-    var _a, _b, _c, _d;
+    var _a;
     function firstExisting(paths) {
         if (Array.isArray(paths))
             for (let fpath of paths)
@@ -15,11 +15,13 @@ function Geoip2Paths() {
                     return fpath;
         return false;
     }
+    const pkgRoot = path_1.default.join(__dirname, '..', '..');
+    const mainPath = (_a = require === null || require === void 0 ? void 0 : require.main) === null || _a === void 0 ? void 0 : _a.path;
     return {
-        country: firstExisting(['/opt/geoip2/GeoIP2-Country.mmdb', '/usr/local/var/GeoIP/GeoIP2-Country.mmdb', '/var/lib/GeoIP/GeoIP2-Country.mmdb', '/usr/share/GeoIP/GeoIP2-Country.mmdb', path_1.default.join(__dirname, 'assets/GeoIP2-Country.mmdb'), path_1.default.join(((_a = require === null || require === void 0 ? void 0 : require.main) === null || _a === void 0 ? void 0 : _a.path) || __dirname, 'assets/GeoIP2-Country.mmdb')]),
-        city: firstExisting(['/opt/geoip2/GeoIP2-City.mmdb', '/usr/local/var/GeoIP/GeoIP2-City.mmdb', '/var/lib/GeoIP/GeoIP2-City.mmdb', '/usr/share/GeoIP/GeoIP2-City.mmdb', path_1.default.join(__dirname, 'assets/GeoIP2-City.mmdb'), path_1.default.join(((_b = require === null || require === void 0 ? void 0 : require.main) === null || _b === void 0 ? void 0 : _b.path) || __dirname, 'assets/GeoIP2-City.mmdb')]),
-        isp: firstExisting(['/opt/geoip2/GeoIP2-ISP.mmdb', '/usr/local/var/GeoIP/GeoIP2-ISP.mmdb', '/var/lib/GeoIP/GeoIP2-ISP.mmdb', '/usr/share/GeoIP/GeoIP2-ISP.mmdb', path_1.default.join(__dirname, 'assets/GeoIP2-ISP.mmdb'), path_1.default.join(((_c = require === null || require === void 0 ? void 0 : require.main) === null || _c === void 0 ? void 0 : _c.path) || __dirname, 'assets/GeoIP2-ISP.mmdb')]),
-        ct: firstExisting(['/opt/geoip2/GeoIP2-Connection-Type.mmdb', '/usr/local/var/GeoIP/GeoIP2-Connection-Type.mmdb', '/var/lib/GeoIP/GeoIP2-Connection-Type.mmdb', '/usr/share/GeoIP/GeoIP2-Connection-Type.mmdb', path_1.default.join(__dirname, 'assets/GeoIP2-Connection-Type.mmdb'), path_1.default.join(((_d = require === null || require === void 0 ? void 0 : require.main) === null || _d === void 0 ? void 0 : _d.path) || __dirname, 'assets/GeoIP2-Connection-Type.mmdb')]),
+        country: firstExisting(['/opt/geoip2/GeoIP2-Country.mmdb', '/usr/local/var/GeoIP/GeoIP2-Country.mmdb', '/var/lib/GeoIP/GeoIP2-Country.mmdb', '/usr/share/GeoIP/GeoIP2-Country.mmdb', path_1.default.join(pkgRoot, 'assets/GeoIP2-Country.mmdb'), path_1.default.join(mainPath || pkgRoot, 'assets/GeoIP2-Country.mmdb')]),
+        city: firstExisting(['/opt/geoip2/GeoIP2-City.mmdb', '/usr/local/var/GeoIP/GeoIP2-City.mmdb', '/var/lib/GeoIP/GeoIP2-City.mmdb', '/usr/share/GeoIP/GeoIP2-City.mmdb', path_1.default.join(pkgRoot, 'assets/GeoIP2-City.mmdb'), path_1.default.join(mainPath || pkgRoot, 'assets/GeoIP2-City.mmdb')]),
+        isp: firstExisting(['/opt/geoip2/GeoIP2-ISP.mmdb', '/usr/local/var/GeoIP/GeoIP2-ISP.mmdb', '/var/lib/GeoIP/GeoIP2-ISP.mmdb', '/usr/share/GeoIP/GeoIP2-ISP.mmdb', path_1.default.join(pkgRoot, 'assets/GeoIP2-ISP.mmdb'), path_1.default.join(mainPath || pkgRoot, 'assets/GeoIP2-ISP.mmdb')]),
+        ct: firstExisting(['/opt/geoip2/GeoIP2-Connection-Type.mmdb', '/usr/local/var/GeoIP/GeoIP2-Connection-Type.mmdb', '/var/lib/GeoIP/GeoIP2-Connection-Type.mmdb', '/usr/share/GeoIP/GeoIP2-Connection-Type.mmdb', path_1.default.join(pkgRoot, 'assets/GeoIP2-Connection-Type.mmdb'), path_1.default.join(mainPath || pkgRoot, 'assets/GeoIP2-Connection-Type.mmdb')]),
     };
 }
 //# sourceMappingURL=Geoip2Paths.js.map

package/ts/funcs/Geoip2Paths.ts

@@ -17,10 +17,12 @@ export function Geoip2Paths() :Geoip2Paths {
         return false
     }
 
+    const pkgRoot = path.join(__dirname, '..', '..')
+    const mainPath = require?.main?.path
     return {
-        country:firstExisting(['/opt/geoip2/GeoIP2-Country.mmdb','/usr/local/var/GeoIP/GeoIP2-Country.mmdb','/var/lib/GeoIP/GeoIP2-Country.mmdb','/usr/share/GeoIP/GeoIP2-Country.mmdb',path.join(__dirname, 'assets/GeoIP2-Country.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-Country.mmdb')]),
-        city:firstExisting(['/opt/geoip2/GeoIP2-City.mmdb','/usr/local/var/GeoIP/GeoIP2-City.mmdb','/var/lib/GeoIP/GeoIP2-City.mmdb','/usr/share/GeoIP/GeoIP2-City.mmdb',path.join(__dirname, 'assets/GeoIP2-City.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-City.mmdb')]),
-        isp:firstExisting(['/opt/geoip2/GeoIP2-ISP.mmdb','/usr/local/var/GeoIP/GeoIP2-ISP.mmdb','/var/lib/GeoIP/GeoIP2-ISP.mmdb','/usr/share/GeoIP/GeoIP2-ISP.mmdb',path.join(__dirname, 'assets/GeoIP2-ISP.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-ISP.mmdb')]),
-        ct:firstExisting(['/opt/geoip2/GeoIP2-Connection-Type.mmdb','/usr/local/var/GeoIP/GeoIP2-Connection-Type.mmdb','/var/lib/GeoIP/GeoIP2-Connection-Type.mmdb','/usr/share/GeoIP/GeoIP2-Connection-Type.mmdb',path.join(__dirname, 'assets/GeoIP2-Connection-Type.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-Connection-Type.mmdb')]),
+        country:firstExisting(['/opt/geoip2/GeoIP2-Country.mmdb','/usr/local/var/GeoIP/GeoIP2-Country.mmdb','/var/lib/GeoIP/GeoIP2-Country.mmdb','/usr/share/GeoIP/GeoIP2-Country.mmdb',path.join(pkgRoot, 'assets/GeoIP2-Country.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-Country.mmdb')]),
+        city:firstExisting(['/opt/geoip2/GeoIP2-City.mmdb','/usr/local/var/GeoIP/GeoIP2-City.mmdb','/var/lib/GeoIP/GeoIP2-City.mmdb','/usr/share/GeoIP/GeoIP2-City.mmdb',path.join(pkgRoot, 'assets/GeoIP2-City.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-City.mmdb')]),
+        isp:firstExisting(['/opt/geoip2/GeoIP2-ISP.mmdb','/usr/local/var/GeoIP/GeoIP2-ISP.mmdb','/var/lib/GeoIP/GeoIP2-ISP.mmdb','/usr/share/GeoIP/GeoIP2-ISP.mmdb',path.join(pkgRoot, 'assets/GeoIP2-ISP.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-ISP.mmdb')]),
+        ct:firstExisting(['/opt/geoip2/GeoIP2-Connection-Type.mmdb','/usr/local/var/GeoIP/GeoIP2-Connection-Type.mmdb','/var/lib/GeoIP/GeoIP2-Connection-Type.mmdb','/usr/share/GeoIP/GeoIP2-Connection-Type.mmdb',path.join(pkgRoot, 'assets/GeoIP2-Connection-Type.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-Connection-Type.mmdb')]),
     }
 }

package/ts/funcs/asJSON.d.ts

@@ -1 +1 @@
-export declare function asJSON(inputString: string): any | boolean;
+export declare function asJSON(str: unknown): unknown | false;

package/ts/funcs/asJSON.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asJSON = asJSON;
-function asJSON(inputString) {
-    if (!inputString || typeof inputString !== 'string')
+function asJSON(str) {
+    if (!str || typeof str !== 'string')
         return false;
     try {
-        return JSON.parse(inputString);
+        return JSON.parse(str);
+    }
+    catch (_a) {
+        /* ignore */
     }
-    catch (_) { }
     return false;
 }
 //# sourceMappingURL=asJSON.js.map

package/ts/funcs/asJSON.ts

@@ -1,6 +1,9 @@
-
-export function asJSON(inputString: string): any | boolean {
-    if (!inputString || typeof inputString !== 'string') return false
-    try { return JSON.parse(inputString) } catch (_) { }
-    return false
+export function asJSON(str: unknown): unknown | false {
+  if (!str || typeof str !== 'string') return false
+  try {
+    return JSON.parse(str)
+  } catch {
+    /* ignore */
+  }
+  return false
 }

package/ts/funcs/hash_sha512.d.ts

@@ -1 +1 @@
-export declare function hash_sha512(plainString: string): string;
+export declare function hash_sha512(plain: unknown): string | false;

package/ts/funcs/hash_sha512.js

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

package/ts/funcs/hash_sha512.ts

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

package/ts/funcs/isLANIp.d.ts

@@ -1,3 +1,2 @@
-import ip6addr from '@7c/node-ip6addr';
-export declare const private_network_cidrs: ip6addr.CIDR[];
-export declare function isLANIp(ip: string): boolean;
+export declare const private_network_cidrs: import("@7c/node-ip6addr").CIDR[];
+export declare function isLANIp(ip: string): boolean | null;

package/ts/funcs/isLANIp.js

@@ -14,34 +14,33 @@ exports.private_network_cidrs = [
     node_ip6addr_1.default.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
     node_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);
+function normalizeIp(ip) {
     if (net_1.default.isIP(ip) === 0)
         return false;
+    if (net_1.default.isIPv6(ip))
+        return ip.toLowerCase().replace(/^::ffff:/, '');
+    return ip;
+}
+function isLANIp(ip) {
+    const n = normalizeIp(ip);
+    if (n === false || net_1.default.isIP(n) === 0)
+        return false;
     try {
-        // speed optimized
-        let ipVersion = net_1.default.isIPv4(ip) ? 'ipv4' : 'ipv6';
-        for (let cidr of exports.private_network_cidrs) {
+        const ipVersion = net_1.default.isIPv4(n) ? 'ipv4' : 'ipv6';
+        for (const cidr of exports.private_network_cidrs) {
             if (!cidr)
                 continue;
-            let first = cidr.first();
+            const first = cidr.first();
             if (first.kind() !== ipVersion)
                 continue;
-            if (cidr.contains(ip))
+            if (cidr.contains(n))
                 return true;
         }
+        return null;
     }
     catch (err) {
         console.log(err);
     }
     return false;
 }
-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

@@ -9,10 +9,9 @@ describe('isLANIp', () => {
     // 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 null for non-LAN IP addresses', () => {
+    expect(isLANIp('8.8.8.8')).toBeNull();
+    expect(isLANIp('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBeNull();
   });
 
   it('should return false for invalid IP addresses', () => {
@@ -34,12 +33,12 @@ test('should return true for private IPv6', () => {
 
 test('should return null for public IPv4', () => {
     const ip = '8.8.8.8';
-    expect(isLANIp(ip)).toBe(false);
+    expect(isLANIp(ip)).toBeNull();
 });
 
-test('should return false for public IPv6', () => {
+test('should return null for public IPv6', () => {
     const ip = '2001:4860:4860::8888';
-    expect(isLANIp(ip)).toBe(false);
+    expect(isLANIp(ip)).toBeNull();
 });
 
 test('should return false for invalid IP', () => {
@@ -54,6 +53,6 @@ test('should return false for invalid IP', () => {
 
 test('should return null for non private IPv6', () => {
     const ip = '::2';
-    expect(isLANIp(ip)).toBe(false);
+    expect(isLANIp(ip)).toBeNull();
 });
 });