mybase 1.2.2 → 1.2.3

package/ts/index.ts

@@ -1,39 +0,0 @@
-export * from "./funcs/getWeekNumber"
-export * from "./funcs/Geoip2Paths";
-export * from "./funcs/isLocal"
-export * from "./funcs/randomString"
-export * from "./funcs/utcnow"
-export * from "./funcs/validIp"
-export * from "./funcs/wait"
-export * from "./funcs/fileCacheIsValid"
-export * from "./funcs/hash_sha512"
-export * from "./funcs/vaultRead"
-export * from "./funcs/vaultFill"
-export * from "./funcs/asJSON"
-export * from "./funcs/promiseTimeout"
-export * from "./funcs/randomIP"
-export * from "./funcs/ip2int"
-export * from "./funcs/int2ip"
-export * from "./funcs/randomIP6"
-export * from "./funcs/randomTCPPort"
-export * from "./funcs/validEmail"
-export * from "./funcs/isLoopbackIP"
-export * from "./funcs/isLANIp"
-export * from "./funcs/getMysql1"
-export * from "./funcs/getMysql2"
-export * from "./funcs/initMysql2Pool"
-export * from "./funcs/randomUTFString"
-export * from "./funcs/MaxRuntimeHours"
-export * from "./funcs/ensureFolder"
-export * from "./funcs/knexConnection"
-export * from "./funcs/deepCopy"
-
-
-
-// models
-export * from "./models/Unixtime"
-export * from "./models/Timespan"
-export * from "./models/IPAddress"
-export * from "./models/OTPGenerator"
-export * from "./models/Interfaces"
-export * from "./models/DateIterator"

package/ts/models/DateIterator.test.ts

@@ -1,149 +0,0 @@
-import { DateIterator } from './DateIterator';
-import { Unixtime } from './Unixtime';
-
-describe('DateIterator', () => {
-  const start = () => Unixtime.fromYYYYMMDD('20240110');
-  const end = () => Unixtime.fromYYYYMMDD('20240105');
-
-  it('should iterate backwards day-by-day (end-exclusive) with default separator', () => {
-    const it = new DateIterator(start(), end());
-    expect(it.toArray()).toEqual([
-      '20240110',
-      '20240109',
-      '20240108',
-      '20240107',
-      '20240106',
-    ]);
-  });
-
-  it('should honor a custom separator', () => {
-    const it = new DateIterator(start(), end(), '-');
-    expect(it.toArray()).toEqual([
-      '2024-01-10',
-      '2024-01-09',
-      '2024-01-08',
-      '2024-01-07',
-      '2024-01-06',
-    ]);
-  });
-
-  it('should honor a slash separator', () => {
-    const it = new DateIterator(start(), end(), '/');
-    expect(it.toArray()).toEqual([
-      '2024/01/10',
-      '2024/01/09',
-      '2024/01/08',
-      '2024/01/07',
-      '2024/01/06',
-    ]);
-  });
-
-  it('next() should return null when exhausted', () => {
-    const s = Unixtime.fromYYYYMMDD('20240103');
-    const e = Unixtime.fromYYYYMMDD('20240101');
-    const it = new DateIterator(s, e);
-    expect(it.next()).toEqual('20240103');
-    expect(it.next()).toEqual('20240102');
-    expect(it.next()).toBeNull();
-    expect(it.next()).toBeNull();
-  });
-
-  it('should return empty array when start equals end (end-exclusive)', () => {
-    const s = Unixtime.fromYYYYMMDD('20240105');
-    const e = Unixtime.fromYYYYMMDD('20240105');
-    const it = new DateIterator(s, e);
-    expect(it.toArray()).toEqual([]);
-    expect(it.next()).toBeNull();
-  });
-
-  it('should throw when start is older than end', () => {
-    const s = Unixtime.fromYYYYMMDD('20240101');
-    const e = Unixtime.fromYYYYMMDD('20240110');
-    expect(() => new DateIterator(s, e)).toThrow(
-      'DateIterator: `start` must be newer than or equal to `end`'
-    );
-  });
-
-  it('should not mutate the caller-supplied Unixtime instances', () => {
-    const s = Unixtime.fromYYYYMMDD('20240110');
-    const e = Unixtime.fromYYYYMMDD('20240105');
-    const sBefore = s.toLongUnixtime();
-    const eBefore = e.toLongUnixtime();
-    const it = new DateIterator(s, e);
-    it.toArray();
-    expect(s.toLongUnixtime()).toEqual(sBefore);
-    expect(e.toLongUnixtime()).toEqual(eBefore);
-  });
-
-  it('reset() should allow the iterator to be consumed again', () => {
-    const it = new DateIterator(start(), end());
-    const first = it.toArray();
-    expect(it.next()).toBeNull();
-    it.reset();
-    const second = it.toArray();
-    expect(second).toEqual(first);
-  });
-
-  it('reset() should return the iterator for chaining', () => {
-    const it = new DateIterator(start(), end());
-    expect(it.reset()).toBe(it);
-  });
-
-  it('should be iterable via for..of', () => {
-    const it = new DateIterator(start(), end(), '-');
-    const out: string[] = [];
-    for (const d of it) out.push(d);
-    expect(out).toEqual([
-      '2024-01-10',
-      '2024-01-09',
-      '2024-01-08',
-      '2024-01-07',
-      '2024-01-06',
-    ]);
-  });
-
-  it('for..of should be independent of next()/toArray() cursor', () => {
-    const it = new DateIterator(start(), end());
-    expect(it.next()).toEqual('20240110');
-    const collected: string[] = [];
-    for (const d of it) collected.push(d);
-    expect(collected).toEqual([
-      '20240110',
-      '20240109',
-      '20240108',
-      '20240107',
-      '20240106',
-    ]);
-    expect(it.next()).toEqual('20240109');
-  });
-
-  it('should support spread syntax', () => {
-    const it = new DateIterator(
-      Unixtime.fromYYYYMMDD('20240103'),
-      Unixtime.fromYYYYMMDD('20240101')
-    );
-    expect([...it]).toEqual(['20240103', '20240102']);
-  });
-
-  it('should cross month boundaries correctly', () => {
-    const s = Unixtime.fromYYYYMMDD('20240302');
-    const e = Unixtime.fromYYYYMMDD('20240227');
-    const it = new DateIterator(s, e, '-');
-    expect(it.toArray()).toEqual([
-      '2024-03-02',
-      '2024-03-01',
-      '2024-02-29',
-      '2024-02-28',
-    ]);
-  });
-
-  it('should produce N entries for a span of N+1 days (end-exclusive)', () => {
-    const s = Unixtime.fromYYYYMMDD('20240620');
-    const e = Unixtime.fromYYYYMMDD('20240610');
-    const it = new DateIterator(s, e);
-    const arr = it.toArray();
-    expect(arr.length).toEqual(10);
-    expect(arr[0]).toEqual('20240620');
-    expect(arr[arr.length - 1]).toEqual('20240611');
-  });
-});

package/ts/models/DateIterator.ts

@@ -1,80 +0,0 @@
-import { Unixtime } from "./Unixtime"
-
-/**
- * Iterates day-by-day backwards from `start` toward `end` (end-exclusive),
- * emitting each date as a `yyyy{sep}mm{sep}dd` string.
- *
- * @example
- *   const it = new DateIterator(Unixtime.now(), Unixtime.now().addDays(-5))
- *   it.next()  // "20260417"
- *   it.next()  // "20260416"
- *   // ...
- *   it.next()  // null
- *
- * @example separator
- *   new DateIterator(start, end, "-").toArray()
- *   // ["2026-04-17", "2026-04-16", ...]
- *
- * @example for..of
- *   for (const d of new DateIterator(start, end, "/")) console.log(d)
- */
-export class DateIterator implements Iterable<string> {
-    private readonly start: Unixtime
-    private readonly end: Unixtime
-    private readonly separator: string
-    private cursor: Unixtime | null
-
-    constructor(start: Unixtime, end: Unixtime, separator: string = "") {
-        if (start.lessThan(end)) {
-            throw new Error('DateIterator: `start` must be newer than or equal to `end`')
-        }
-        // Defensive clones: callers' instances must not be mutated, and
-        // Unixtime.addDays() mutates the underlying Date.
-        this.start = start.clone()
-        this.end = end.clone()
-        this.separator = separator
-        this.cursor = this.start.clone()
-    }
-
-    /** Returns the next formatted date going backwards, or `null` when exhausted. */
-    next(): string | null {
-        if (this.cursor === null) return null
-        if (!this.cursor.greaterThan(this.end)) {
-            this.cursor = null
-            return null
-        }
-        const value = this.cursor.yyyymmdd(this.separator)
-        this.cursor.addDays(-1)
-        return value
-    }
-
-    /** Reset the iterator so it can be consumed again from `start`. */
-    reset(): this {
-        this.cursor = this.start.clone()
-        return this
-    }
-
-    /** Collect all remaining dates into an array. */
-    toArray(): string[] {
-        const out: string[] = []
-        let d: string | null
-        while ((d = this.next()) !== null) out.push(d)
-        return out
-    }
-
-    [Symbol.iterator](): Iterator<string> {
-        let cursor: Unixtime | null = this.start.clone()
-        const end = this.end
-        const sep = this.separator
-        return {
-            next(): IteratorResult<string> {
-                if (cursor === null || !cursor.greaterThan(end)) {
-                    return { value: undefined as unknown as string, done: true }
-                }
-                const value = cursor.yyyymmdd(sep)
-                cursor.addDays(-1)
-                return { value, done: false }
-            }
-        }
-    }
-}

package/ts/models/IPAddress.test.ts

@@ -1,393 +0,0 @@
-import ip6addr from '@7c/node-ip6addr'
-import { IPAddress } from './IPAddress'
-import { randomIP, randomIP6 } from '../'
-
-describe('IPAddress', () => {
-  it('should create an instance of IPAddress', () => {
-    const ipAddress = new IPAddress('192.168.0.1');
-    expect(ipAddress).toBeInstanceOf(IPAddress);
-  });
-
-
-  it('should convert IPAddress to string', () => {
-    const ipAddress = new IPAddress('192.168.0.1');
-    const result = ipAddress.toString();
-    expect(result).toBe('192.168.0.1');
-  });
-
-  it('should create an instance of IPAddress from string', () => {
-    const ipAddress = IPAddress.fromString('192.168.0.1');
-    expect(ipAddress).toBeInstanceOf(IPAddress);
-  });
-
-  it('should throw an error when creating an instance of IPAddress from invalid string', () => {
-    expect(() => IPAddress.fromString('192.168.0')).toThrow()
-    expect(() => IPAddress.fromString('0.0.0')).toThrow()
-    expect(() => IPAddress.fromString('')).toThrow()
-    //@ts-ignore
-    expect(() => IPAddress.fromString(null)).toThrow()
-    //@ts-ignore
-    expect(() => IPAddress.fromString(undefined)).toThrow()
-  })
-
-  it('should serialize ipv4 to string', () => {
-    expect(IPAddress.fromString('192.168.0.1').serialize()).toBe('192168000001')
-    expect(IPAddress.fromString('0.0.0.0').serialize()).toBe('000000000000')
-    expect(IPAddress.fromString('0.0.0.1').serialize()).toBe('000000000001')
-    expect(IPAddress.fromString('0.00.000.01').serialize()).toBe('000000000001')
-    expect(IPAddress.fromString('0.10.0.0').serialize()).toBe('000010000000')
-    expect(IPAddress.fromString('255.255.255.255').serialize()).toBe('255255255255')
-  });
-
-  it('should serialize ipv6 to string', () => {
-    expect(IPAddress.fromString('::').serialize()).toBe('00000000000000000000000000000000')
-    expect(IPAddress.fromString('::1').serialize()).toBe('00000000000000000000000000000001')
-    expect(IPAddress.fromString('::01').serialize()).toBe('00000000000000000000000000000001')
-    expect(IPAddress.fromString('::001').serialize()).toBe('00000000000000000000000000000001')
-    expect(IPAddress.fromString('::0001').serialize()).toBe('00000000000000000000000000000001')
-    expect(IPAddress.fromString('::1:1').serialize()).toBe('00000000000000000000000000010001')
-    expect(IPAddress.fromString('::2:1').serialize()).toBe('00000000000000000000000000020001')
-  })
-
-  // testing unserialize
-  it('should unserialize ipv4 from string', () => {
-    expect(IPAddress.unserialize('192168000001').toString()).toBe('192.168.0.1')
-    expect(IPAddress.unserialize('192168000002').toString()).toBe('192.168.0.2')
-    expect(IPAddress.unserialize('000000000000').toString()).toBe('0.0.0.0')
-  })
-
-  it('should throw invalid serialization string', () => {
-    expect(() => IPAddress.unserialize('92168000001')).toThrow(Error)
-    expect(() => IPAddress.unserialize('168000001')).toThrow(Error)
-    expect(() => IPAddress.unserialize('292168000002')).toThrow(Error)
-  })
-
-  it('randomly generated ipv4 serialization', () => {
-    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++) {
-      const ip = randomIP6()
-      let ip2 = IPAddress.unserialize(IPAddress.fromString(ip).serialize()).toString()
-      expect(ip6addr.compare(ip, ip2)).toEqual(0)
-    }
-  })
-
-  it('it should detect the kind of ip4', () => {
-    for (let i = 0; i < 100; i++)
-      expect(IPAddress.randomIP4().kind()).toBe(4)
-  })
-
-  it('should return shortened address by default toString', () => {
-    expect(new IPAddress('001.02.3.004').toString()).toBe('1.2.3.4');
-  });
-
-  it('randomPad return valid ipv4 results', () => {
-    let compared = 0
-    while (compared < 100) {
-      const ip1 = IPAddress.randomIP4()
-      const ip2 = ip1.randomPad()
-      if (ip1.toString() !== ip2) { // find ips they are padded from the original
-        compared++
-      }
-      expect(IPAddress.validate(ip2)).toBe(true)
-    }
-  })
-
-  it('compare ipv4 should detect equality even if they are padded', () => {
-    let compared = 0
-    while (compared < 100) {
-      const ip1 = IPAddress.randomIP4()
-      const ip2 = ip1.randomPad()
-      if (ip1.toString() !== ip2) { // find ips they are padded from the original
-        compared++
-      }
-      expect(ip1.equals(IPAddress.fromString(ip2))).toBe(true)
-    }
-  })
-
-  it('normalized should normalize ipv4 ips properly', () => {
-    expect(new IPAddress('127.0.0.1').normalized()).toBe('127.0.0.1')
-    expect(new IPAddress('127.00.0.1').normalized()).toBe('127.0.0.1')
-    expect(new IPAddress('127.000.00.1').normalized()).toBe('127.0.0.1')
-    expect(new IPAddress('127.0.00.00001').normalized()).toBe('127.0.0.1')
-  })
-
-  it('normalized should normalize ipv6 ips properly', () => {
-    expect(new IPAddress('::1').normalized()).toBe('0000:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('::01').normalized()).toBe('0000:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('::001').normalized()).toBe('0000:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('::0001').normalized()).toBe('0000:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('::000001').normalized()).toBe('0000:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('::1:1').normalized()).toBe('0000:0000:0000:0000:0000:0000:0001:0001')
-    expect(new IPAddress('::2:1').normalized()).toBe('0000:0000:0000:0000:0000:0000:0002:0001')
-
-
-    expect(new IPAddress('1::1').normalized()).toBe('0001:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('2::01').normalized()).toBe('0002:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('3::001').normalized()).toBe('0003:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('4::0001').normalized()).toBe('0004:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('5::000001').normalized()).toBe('0005:0000:0000:0000:0000:0000:0000:0001')
-    expect(new IPAddress('6::1:1').normalized()).toBe('0006:0000:0000:0000:0000:0000:0001:0001')
-    expect(new IPAddress('7::2:1').normalized()).toBe('0007:0000:0000:0000:0000:0000:0002:0001')
-  })
-
-
-  it('abbreviated should abbreviate ipv6 ips properly', () => {
-    expect(new IPAddress('::1').abbreviated()).toBe('::1')
-    expect(new IPAddress('::01').abbreviated()).toBe('::1')
-    expect(new IPAddress('::001').abbreviated()).toBe('::1')
-    expect(new IPAddress('::0001').abbreviated()).toBe('::1')
-    expect(new IPAddress('::000001').abbreviated()).toBe('::1')
-    expect(new IPAddress('0000:0000:0000:0000:0000:0000:0001:0001').abbreviated()).toBe('::1:1')
-    expect(new IPAddress('0000:0000:0000:0000:0000:0000:0002:0001').abbreviated()).toBe('::2:1')
-
-    expect(new IPAddress('2001:0db8:0001:0002:0003:0004:0005:0006').abbreviated()).toBe('2001:db8:1:2:3:4:5:6')
-    expect(new IPAddress('1:0000:0000::0000:0000:0000:0001').abbreviated()).toBe('1::1')
-    expect(new IPAddress('0001:0000:0000:0000:0000:0000:0000:0001').abbreviated()).toBe('1::1')
-    expect(new IPAddress('0002:0000:0000:0000:0000::0000:0001').abbreviated()).toBe('2::1')
-    expect(new IPAddress('0003:0000:0000:0000:0000:0000:0000:0001').abbreviated()).toBe('3::1')
-    expect(new IPAddress('0004::0000:0000:0000:0000:0000:0001').abbreviated()).toBe('4::1')
-    expect(new IPAddress('0005:0000:0000:0000:0000:0000:0000:0001').abbreviated()).toBe('5::1')
-    expect(new IPAddress('0006:0000:0000::0000:0000:0001:0001').abbreviated()).toBe('6::1:1')
-    expect(new IPAddress('0007:0000:0000:0000:0000::0002:0001').abbreviated()).toBe('7::2:1')
-  })
-
-  it('abbreviated should abbreviate ipv4 ips properly', () => {
-    expect(new IPAddress('127.00.000.1').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('127.0.00.00001').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('127.0000.0.00001').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('0.0000.0.00000').abbreviated()).toBe('0.0.0.0')
-  })
-  it('abbreviated should abbreviate ipv4-mapped ips properly', () => {
-    expect(new IPAddress('::ffff:127.00.000.1').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('::ffff:127.0.00.00001').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('::ffff:127.0000.0.00001').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('0::ffff:127.0000.0.00001').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('0:0:0::ffff:127.0000.0.00001').abbreviated()).toBe('127.0.0.1')
-    expect(new IPAddress('::ffff:0.0000.0.00000').abbreviated()).toBe('0.0.0.0')
-  })
-
-  it('toString() IPv4-mapped IPv6 address should be returned as ipv4', () => {
-    expect(new IPAddress('::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('0::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('00::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('0:00::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('0:0:0::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-  })
-
-  it('kind() IPv4-mapped IPv6 address should be returned as ipv4', () => {
-    expect(new IPAddress('::ffff:127.0.00.00001').kind()).toBe(4)
-    expect(new IPAddress('0::ffff:127.0.00.00001').kind()).toBe(4)
-    expect(new IPAddress('00::ffff:127.0.00.00001').kind()).toBe(4)
-    expect(new IPAddress('0:00::ffff:127.0.00.00001').kind()).toBe(4)
-    expect(new IPAddress('0:0:0::ffff:127.0.00.00001').kind()).toBe(4)
-  })
-
-  it('IPv4-mapps Addresses should be converted to Ipv4 at constructor', () => {  
-    expect(new IPAddress('::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('0::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('00::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('0:00::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-    expect(new IPAddress('0:0:0::ffff:127.0.00.00001').toString()).toBe('127.0.0.1')
-  })
-
-});
-
-describe('IPAddress IPv6', () => {
-  it('should work with any form of valid ipv6, prefixed or not', () => {
-    expect(new IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress);
-    expect(new IPAddress('2605:2700:0000:003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress);
-    expect(new IPAddress('2605:2700:000:003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress);
-    expect(new IPAddress('2605:2700:0:003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress);
-    expect(new IPAddress('2605:2700:0:003:a800:0ff:fe10:f0d3')).toBeInstanceOf(IPAddress);
-  })
-
-  it('should return shortened address by default toString', () => {
-    expect(new IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-    expect(new IPAddress('2605:2700:0000:003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-    expect(new IPAddress('2605:2700:0000:03:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-    expect(new IPAddress('2605:2700:0000:03:a800:ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-  });
-
-  it('ip6 addresses should be lowercased', () => {
-    expect(new IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-    expect(new IPAddress('2605:2700:0000:003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-    expect(new IPAddress('2605:2700:0000:03:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-    expect(new IPAddress('2605:2700:0000:03:a800:ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
-  });
-
-  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++)
-      expect(IPAddress.randomIP6().kind()).toBe(6)
-  })
-
-  it('randomPad return valid ipv6 results be compareable with equals', () => {
-    let compared = 0
-    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
-        compared++
-      }
-
-      expect(IPAddress.validate(ip2)).toBe(true)
-      expect(ip1.equals(IPAddress.fromString(ip2))).toBe(true)
-    }
-  })
-
-})
-
-
-
-describe('IPAddress asciiChecksum', () => {
-  it('should return the correct checksum for ipv4', () => {
-    expect(new IPAddress('1.2.3.4').asciiChecksum()).toBe('e')
-    expect(new IPAddress('1.2.3.6').asciiChecksum()).toBe('i')
-  })
-
-  it('should return the correct checksum for ipv6', () => {
-    expect(new IPAddress('::').asciiChecksum()).toBe('a')
-    expect(new IPAddress('::1').asciiChecksum()).toBe('a')
-    expect(new IPAddress('::f').asciiChecksum()).toBe('s')
-  })
-
-  it('it should always return a single character ipv4/v6', () => {
-    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++) {
-      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)
-    }
-  })
-})