mybase 1.1.53 → 1.2.2

package/ts/funcs/isLANIp.ts

@@ -2,36 +2,33 @@ import ip6addr from '@7c/node-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.
+  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 | false {
+  if (net.isIP(ip) === 0) return false
+  if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
+  return ip
 }
 
-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 | null {
+  const n = normalizeIp(ip)
+  if (n === false || net.isIP(n) === 0) return false
+  try {
+    const ipVersion = net.isIPv4(n) ? 'ipv4' : 'ipv6'
+    for (const cidr of private_network_cidrs) {
+      if (!cidr) continue
+      const first = cidr.first()
+      if (first.kind() !== ipVersion) continue
+      if (cidr.contains(n)) return true
+    }
+    return null
+  } catch (err) {
+    console.log(err)
+  }
+  return false
 }

package/ts/funcs/isLoopbackIP.d.ts

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

package/ts/funcs/isLoopbackIP.js

@@ -9,34 +9,33 @@ const node_ip6addr_1 = __importDefault(require("@7c/node-ip6addr"));
 const net_1 = __importDefault(require("net"));
 exports.local_network_cidrs = [
     node_ip6addr_1.default.createCIDR('127.0.0.0/8'),
-    node_ip6addr_1.default.createCIDR('::1/128')
+    node_ip6addr_1.default.createCIDR('::1/128'),
 ];
-function isLoopbackIP(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 isLoopbackIP(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.local_network_cidrs) {
-            let first = cidr.first();
+        const ipVersion = net_1.default.isIPv4(n) ? 'ipv4' : 'ipv6';
+        for (const cidr of exports.local_network_cidrs) {
+            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=isLoopbackIP.js.map

package/ts/funcs/isLoopbackIP.test.ts

@@ -10,12 +10,12 @@ describe('isLoopbackIP', () => {
         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 null for non-loopback IPv4 address', () => {
+        expect(isLoopbackIP('192.168.0.1')).toBeNull();
     });
 
-    test('should return false for non-loopback IPv6 address', () => {
-        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(false);
+    test('should return null for non-loopback IPv6 address', () => {
+        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBeNull();
     });
 
     test('should return false for invalid IP address', () => {
@@ -49,12 +49,12 @@ describe('isLoopbackIP', () => {
 
     test('should return null for non-local IPv4', () => {
         const ip = '8.8.8.8'
-        expect(isLoopbackIP(ip)).toBe(false)
+        expect(isLoopbackIP(ip)).toBeNull()
     })
 
     test('should return null for non-local IPv6', () => {
         const ip = '2001:4860:4860::8888'
-        expect(isLoopbackIP(ip)).toBe(false)
+        expect(isLoopbackIP(ip)).toBeNull()
     })
 
     test('should return false for invalid IP', () => {
@@ -65,7 +65,7 @@ describe('isLoopbackIP', () => {
     test('random ips should not be Loopback', () => {
         for(let i=0;i<10;i++){
             let ip = randomIP()
-            expect(isLoopbackIP(ip)).toBe(false)
+            expect(isLoopbackIP(ip)).toBeNull()
         }
             
     })

package/ts/funcs/isLoopbackIP.ts

@@ -2,31 +2,29 @@ import ip6addr from '@7c/node-ip6addr'
 import net from 'net'
 
 export const local_network_cidrs = [
-    ip6addr.createCIDR('127.0.0.0/8'),
-    ip6addr.createCIDR('::1/128')
+  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
-    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
+function normalizeIp(ip: string): string | false {
+  if (net.isIP(ip) === 0) return false
+  if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
+  return ip
 }
 
-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 | null {
+  const n = normalizeIp(ip)
+  if (n === false || net.isIP(n) === 0) return false
+  try {
+    const ipVersion = net.isIPv4(n) ? 'ipv4' : 'ipv6'
+    for (const cidr of local_network_cidrs) {
+      const first = cidr.first()
+      if (first.kind() !== ipVersion) continue
+      if (cidr.contains(n)) return true
+    }
+    return null
+  } catch (err) {
+    console.log(err)
+  }
+  return false
 }

package/ts/funcs/validEmail.d.ts

@@ -1 +1 @@
-export declare function validEmail(email: string): boolean;
+export declare function validEmail(email: unknown): boolean;

package/ts/funcs/validEmail.js

@@ -13,8 +13,5 @@ function validEmail(email) {
     // taken from https://www.w3resource.com/javascript/form/email-validation.php
     // strange looking emails might be indeed valid
     // check https://www.w3resource.com/javascript/form/example-javascript-form-validation-email-REC-2822.html
-    if (typeof email === 'string')
-        email = email.toLowerCase().trim();
-    return (/(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/).test(email);
 }
 //# sourceMappingURL=validEmail.js.map

package/ts/funcs/validEmail.ts

@@ -1,6 +1,6 @@
 import validator from 'validator'
 
-export function validEmail(email:string) { 
+export function validEmail(email: unknown): boolean {
     if (typeof email==='string')
         return validator.isEmail(email) // validator needs a string
     return false
@@ -8,6 +8,4 @@ export function validEmail(email:string) {
     // taken from https://www.w3resource.com/javascript/form/email-validation.php
     // strange looking emails might be indeed valid
     // check https://www.w3resource.com/javascript/form/example-javascript-form-validation-email-REC-2822.html
-    if (typeof email==='string') email=email.toLowerCase().trim()
-    return (/(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/).test(email)
 }

package/ts/funcs/vaultFill.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.vaultFill = vaultFill;
 const debug_1 = require("debug");
 const vaultRead_1 = require("./vaultRead");
-const dbg = (0, debug_1.debug)('vaultFill');
+const dbg = (0, debug_1.debug)('mybase');
 function vaultFill(vaultInstance, inputObject, ignoreError = false, keepCache = true) {
     // v2.1
     // fills all strings with ^vault@/secret/... with proper vault values

package/ts/funcs/vaultFill.ts

@@ -1,7 +1,7 @@
 import { debug } from "debug"
 import nodeVault from "node-vault";
 import { vaultRead } from "./vaultRead";
-const dbg = debug('vaultFill')
+const dbg = debug('mybase')
 
 export function vaultFill(vaultInstance: nodeVault.client, inputObject: any, ignoreError = false, keepCache = true) {
     // v2.1

package/ts/funcs/vaultRead.js

@@ -5,18 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vaultRead = vaultRead;
 const debug_1 = require("debug");
+const chalk_1 = __importDefault(require("chalk"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
 const fileCacheIsValid_1 = require("./fileCacheIsValid");
 const global_1 = require("../global");
 const hash_sha512_1 = require("./hash_sha512");
-const dbg = (0, debug_1.debug)('vaultRead');
+const dbg = (0, debug_1.debug)('mybase');
 // need to implement it better
 function vaultRead(vaultInstance, vaultKey, cache_in_minutes = 10) {
     // v2 - supports caching
     return new Promise((resolve, reject) => {
-        let cache_file = path_1.default.join(global_1.vault_cache_folder, (0, hash_sha512_1.hash_sha512)(`${vaultInstance.endpoint}/${vaultKey}`));
+        const cacheKeyMaterial = `${vaultInstance.endpoint}/${vaultKey}`;
+        const cacheHash = (0, hash_sha512_1.hash_sha512)(cacheKeyMaterial);
+        if (cacheHash === false)
+            return reject(new Error('vault cache key hash failed'));
+        let cache_file = path_1.default.join(global_1.vault_cache_folder, cacheHash);
         if (cache_in_minutes > 0 && (0, fileCacheIsValid_1.fileCacheIsValid)(cache_file, cache_in_minutes))
             return resolve(JSON.parse((0, fs_2.readFileSync)(cache_file).toString()));
         vaultInstance.read(vaultKey).then((r) => {
@@ -33,10 +38,11 @@ function vaultRead(vaultInstance, vaultKey, cache_in_minutes = 10) {
             dbg(`vault ${vaultKey} - failed`);
             reject(r);
         }).catch(e => {
+            console.log(e);
             dbg(`exception inside vaultRead`, e);
             // we will still return latest information from cache
             try {
-                dbg(`returning vault@${vaultKey} from cache due to error`);
+                console.log(chalk_1.default.bgRed(`returning vault@${vaultKey} from cache due to error`));
                 if (fs_1.default.existsSync(cache_file))
                     return resolve(JSON.parse(fs_1.default.readFileSync(cache_file).toString()));
             }

package/ts/funcs/vaultRead.ts

@@ -1,4 +1,5 @@
 import { debug } from "debug"
+import chalk from "chalk"
 import nodeVault from "node-vault";
 import path from "path";
 import fs from "fs";
@@ -6,14 +7,17 @@ import { readFileSync } from 'fs';
 import { fileCacheIsValid } from "./fileCacheIsValid";
 import { vault_cache_folder } from "../global";
 import { hash_sha512 } from "./hash_sha512";
-const dbg = debug('vaultRead')
+const dbg = debug('mybase')
 
 // need to implement it better
 
 export function vaultRead(vaultInstance: nodeVault.client, vaultKey: string, cache_in_minutes = 10) : Promise<any> {
     // v2 - supports caching
     return new Promise((resolve, reject) => {
-        let cache_file = path.join(vault_cache_folder, hash_sha512(`${vaultInstance.endpoint}/${vaultKey}`))
+        const cacheKeyMaterial = `${vaultInstance.endpoint}/${vaultKey}`
+        const cacheHash = hash_sha512(cacheKeyMaterial)
+        if (cacheHash === false) return reject(new Error('vault cache key hash failed'))
+        let cache_file = path.join(vault_cache_folder, cacheHash)
 
         if (cache_in_minutes > 0 && fileCacheIsValid(cache_file, cache_in_minutes))
             return resolve(JSON.parse(readFileSync(cache_file as string).toString()))
@@ -28,10 +32,11 @@ export function vaultRead(vaultInstance: nodeVault.client, vaultKey: string, cac
             dbg(`vault ${vaultKey} - failed`)
             reject(r);
         }).catch(e => {
+            console.log(e)
             dbg(`exception inside vaultRead`, e)
             // we will still return latest information from cache
             try {
-                dbg(`returning vault@${vaultKey} from cache due to error`)
+                console.log(chalk.bgRed(`returning vault@${vaultKey} from cache due to error`))
                 if (fs.existsSync(cache_file))
                     return resolve(JSON.parse(fs.readFileSync(cache_file as string).toString()))
             } catch (e2) {

package/ts/models/IPAddress.d.ts

@@ -1,15 +1,15 @@
-import ip6addr, { ToStringOpts } from '@7c/node-ip6addr';
+import { CIDR, ToStringOpts } from '@7c/node-ip6addr';
 export declare class IPAddress {
     private _ip;
-    static loopback_cidrs4: ip6addr.CIDR[];
-    static loopback_cidrs6: ip6addr.CIDR[];
-    static loopback_cidrs: ip6addr.CIDR[];
-    static lan_cidrs4: ip6addr.CIDR[];
-    static lan_cidrs6: ip6addr.CIDR[];
-    static lan_cidrs: ip6addr.CIDR[];
-    static local_cidrs: ip6addr.CIDR[];
-    static local_cidrs4: ip6addr.CIDR[];
-    static local_cidrs6: ip6addr.CIDR[];
+    static loopback_cidrs4: CIDR[];
+    static loopback_cidrs6: CIDR[];
+    static loopback_cidrs: CIDR[];
+    static lan_cidrs4: CIDR[];
+    static lan_cidrs6: CIDR[];
+    static lan_cidrs: CIDR[];
+    static local_cidrs: CIDR[];
+    static local_cidrs4: CIDR[];
+    static local_cidrs6: CIDR[];
     constructor(ip: string);
     abbreviated(): string;
     toString(opts?: ToStringOpts): string;
@@ -20,13 +20,13 @@ export declare class IPAddress {
     isLoopbackIP(): boolean;
     isLANIP(): boolean;
     isLocalIP(): boolean;
-    partOfCIDR(cidr_networks: ip6addr.CIDR[]): boolean;
-    static partOfCIDR(_ip: string, cidr_networks: ip6addr.CIDR[]): boolean;
+    partOfCIDR(cidr_networks: CIDR[]): boolean;
+    static partOfCIDR(_ip: string, cidr_networks: CIDR[]): boolean;
     isPublicIP(): boolean;
     static unserialize(serializedIpString: string): IPAddress;
     static randomIP4(): IPAddress;
     static randomIP6(): IPAddress;
-    static randomCIDRIp(cidr: ip6addr.CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress;
+    static randomCIDRIp(cidr: CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress;
     serialize(): string;
     kind(): number;
     equals(secondIp: IPAddress): boolean;

package/ts/models/IPAddress.ts

@@ -1,7 +1,7 @@
 /// <reference path="./../../ip6addr.d.ts" />
 import debug from 'debug'
 import { randomIP, randomIP6, } from "./../"
-import ip6addr, { Addr, ToStringOpts } from '@7c/node-ip6addr'
+import ip6addr, { Addr, CIDR, ToStringOpts } from '@7c/node-ip6addr'
 import net from 'net'
 const ip6 = require('ip6') // "url": "https://github.com/elgs/ip6"
 const dbg = debug('_IPAddress')
@@ -103,7 +103,7 @@ export class IPAddress {
         return this.partOfCIDR(IPAddress.local_cidrs)
     }
 
-    partOfCIDR(cidr_networks: ip6addr.CIDR[]): boolean {
+    partOfCIDR(cidr_networks: CIDR[]): boolean {
         const ipNormalized = this.toString()
         let ipVersion = net.isIPv4(ipNormalized) ? 'ipv4' : 'ipv6'
         for (let cidr of cidr_networks) {
@@ -116,7 +116,7 @@ export class IPAddress {
         return false
     }
 
-    static partOfCIDR(_ip: string, cidr_networks: ip6addr.CIDR[]): boolean {
+    static partOfCIDR(_ip: string, cidr_networks: CIDR[]): boolean {
         const ip = IPAddress.try(_ip)
         if (ip === undefined) return false
         return ip.partOfCIDR(cidr_networks)
@@ -151,7 +151,7 @@ export class IPAddress {
     }
 
 
-    public static randomCIDRIp(cidr: ip6addr.CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress {
+    public static randomCIDRIp(cidr: 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

package/ts/types.d.ts

@@ -1 +1,36 @@
 export type UnixtimeShort = number;
+export type MysqlConfig = {
+    host: string;
+    port?: number;
+    login: string;
+    password: string;
+    db: string;
+};
+export type MysqlConnection = {
+    connect: (callback: (err: NodeJS.ErrnoException | null) => void) => void;
+    ping: (callback: (err?: NodeJS.ErrnoException | Error | null) => void) => void;
+};
+export type MysqlConnector = {
+    createConnection: (opts: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        database: string;
+    }) => MysqlConnection;
+};
+export type VaultClient = {
+    endpoint?: string;
+    read: (key: string) => Promise<{
+        data?: unknown;
+    }>;
+};
+export type SqlQueryable = {
+    query: (q: string, values: unknown[], callback: (err: Error | null, res?: unknown) => void) => void;
+};
+export type Geoip2PathMap = {
+    country: string | false;
+    city: string | false;
+    isp: string | false;
+    ct: string | false;
+};

package/ts/types.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//#endregion
 //# sourceMappingURL=types.js.map

package/ts/types.ts

@@ -1 +1,42 @@
-export type UnixtimeShort = number
+export type UnixtimeShort = number
+
+//#region mybase
+export type MysqlConfig = {
+  host: string
+  port?: number
+  login: string
+  password: string
+  db: string
+}
+
+export type MysqlConnection = {
+  connect: (callback: (err: NodeJS.ErrnoException | null) => void) => void
+  ping: (callback: (err?: NodeJS.ErrnoException | Error | null) => void) => void
+}
+
+export type MysqlConnector = {
+  createConnection: (opts: {
+    host: string
+    port: number
+    user: string
+    password: string
+    database: string
+  }) => MysqlConnection
+}
+
+export type VaultClient = {
+  endpoint?: string
+  read: (key: string) => Promise<{ data?: unknown }>
+}
+
+export type SqlQueryable = {
+  query: (q: string, values: unknown[], callback: (err: Error | null, res?: unknown) => void) => void
+}
+
+export type Geoip2PathMap = {
+  country: string | false
+  city: string | false
+  isp: string | false
+  ct: string | false
+}
+//#endregion

package/tsconfig.jest.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "types": ["jest", "node"],
+    "noImplicitAny": false
+  },
+  "include": ["**/*.test.ts", "mybase.ts", "ts/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
-  "compilerOptions": {        
+  "compilerOptions": {
+    // "ignoreDeprecations": "6.0",
     "target": "es2017",          
     "experimentalDecorators": true,                   
     "emitDecoratorMetadata": true,                    

package/types/third-party.d.ts

@@ -0,0 +1,21 @@
+declare module '@7c/validurl' {
+  function validURL(host: unknown): boolean
+  export = validURL
+}
+
+declare module 'ip6' {
+  export function normalize(a: string): string
+  export function abbreviate(a: string): string
+}
+
+declare module 'aes-js' {
+  const aesjs: {
+    utils: {
+      utf8: { toBytes(s: string): Uint8Array; fromBytes(b: Uint8Array): string }
+      hex: { fromBytes(b: Uint8Array): string; toBytes(s: string): Uint8Array }
+    }
+    padding: { pkcs7: { pad(b: Uint8Array, n: number): Uint8Array; strip(b: Uint8Array): Uint8Array } }
+    ModeOfOperation: { cbc: new (key: Uint8Array) => { encrypt(b: Uint8Array): Uint8Array; decrypt(b: Uint8Array): Uint8Array } }
+  }
+  export = aesjs
+}