mybase 1.1.33 → 1.1.34

package/ts/models/IPAddress.test.ts

@@ -1,393 +0,0 @@
-import ip6addr from '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)
-    }
-  })
-})

package/ts/models/IPAddress.ts

@@ -1,271 +0,0 @@
-import debug from 'debug'
-import { randomIP, randomIP6, } from "./../"
-import ip6addr, { Addr, ToStringOpts } from 'ip6addr'
-import net from 'net'
-const ip6 = require('ip6') // "url": "https://github.com/elgs/ip6"
-const dbg = debug('_IPAddress')
-dbg.enabled = true
-// need version "ip6": "0.2.7",!!
-
-export class IPAddress {
-    private _ip: Addr
-
-    public static loopback_cidrs4 = [
-        ip6addr.createCIDR('127.0.0.0/8'),
-    ]
-
-    public static loopback_cidrs6 = [
-        ip6addr.createCIDR('::1/128') // yes ipv6 has single address
-    ]
-
-    public static loopback_cidrs = IPAddress.loopback_cidrs4.concat(IPAddress.loopback_cidrs6)
-
-    public static lan_cidrs4 = [
-        ip6addr.createCIDR('10.0.0.0/8'),
-        ip6addr.createCIDR('172.16.0.0/12'),
-        ip6addr.createCIDR('192.168.0.0/16'),
-    ]
-
-    public static lan_cidrs6 = [
-        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.
-    ]
-
-    public static lan_cidrs = IPAddress.lan_cidrs4.concat(IPAddress.lan_cidrs6)
-
-    public static local_cidrs = IPAddress.loopback_cidrs.concat(IPAddress.lan_cidrs)
-    public static local_cidrs4 = IPAddress.loopback_cidrs4.concat(IPAddress.lan_cidrs4)
-    public static local_cidrs6 = IPAddress.loopback_cidrs6.concat(IPAddress.lan_cidrs6)
-
-
-    constructor(ip: string) { // may throw
-        if (ip === '-') ip = '0.0.0.0' // is this really required?
-        try {
-            this._ip = ip6addr.parse(ip)
-            if (this._ip._attrs.ipv4Mapped) {
-                // we wany to convert it to ipv4
-                this._ip = ip6addr.parse(this._ip.toString({ format: 'v4' }))
-            }
-        } catch (err) {
-            if (err instanceof Error)
-                throw new Error(`IPAddress: '${ip}' Error: ${err.message}`)
-            throw err
-        }
-    }
-
-
-    public abbreviated(): string {
-        return this.toString() // default behaviour of ip6addr
-    }
-
-    public toString(opts: ToStringOpts = { format: 'auto', zeroElide: false, zeroPad: false }): string {        
-        return this._ip.toString()
-    }
-
-    public static validate(ip: string): boolean {
-        try {
-            new IPAddress(ip)
-            return true
-        } catch (_) {
-            return false
-        }
-    }
-
-    public static try(ip: string): IPAddress | undefined {
-        try {
-            return new IPAddress(ip)
-        } catch (_) {
-            return undefined
-        }
-    }
-
-    public static fromString(ip: string): IPAddress {
-        return new IPAddress(ip)
-    }
-
-    public static get Empty(): IPAddress {
-        //The IP address 0.0.0.0 is a non-routable meta-address used to denote an invalid, unknown, 
-        // or non-applicable target. It's not assigned to any individual device. 
-        // It is used in different contexts to mean "any IPv4-enabled network interface" or as a default route
-        return new IPAddress('0.0.0.0')
-    }
-
-    public isLoopbackIP(): boolean {
-        return this.partOfCIDR(IPAddress.loopback_cidrs)
-    }
-
-    public isLANIP(): boolean {
-        return this.partOfCIDR(IPAddress.lan_cidrs)
-    }
-
-    public isLocalIP(): boolean {
-        return this.partOfCIDR(IPAddress.local_cidrs)
-    }
-
-    partOfCIDR(cidr_networks: ip6addr.CIDR[]): boolean {
-        const ipNormalized = this.toString()
-        let ipVersion = net.isIPv4(ipNormalized) ? 'ipv4' : 'ipv6'
-        for (let cidr of cidr_networks) {
-            if (!cidr) continue
-            let first = cidr.first()
-            if (first.kind() !== ipVersion) continue
-            if (cidr.contains(ipNormalized))
-                return true
-        }
-        return false
-    }
-
-    static partOfCIDR(_ip: string, cidr_networks: ip6addr.CIDR[]): boolean {
-        const ip = IPAddress.try(_ip)
-        if (ip === undefined) return false
-        return ip.partOfCIDR(cidr_networks)
-    }
-
-    public isPublicIP(): boolean {
-        return this.toString() !== '0.0.0.0' && !this.isLoopbackIP() && !this.isLANIP()
-    }
-
-    public static unserialize(serializedIpString: string): IPAddress {
-        if (serializedIpString.length === 32) {
-            // we have possible ipv6
-            let ip = serializedIpString.match(/.{1,4}/g)?.join(':')
-            if (ip) return new IPAddress(ip)
-        }
-        // we have possible ipv4
-        let ip = serializedIpString.match(/.{1,3}/g)?.join('.')
-        if (ip)
-            try { return new IPAddress(ip) } catch (_) { }
-
-        throw new Error(`Invalid SerializationString: ${serializedIpString}`)
-
-    }
-
-    public static randomIP4(): IPAddress {
-        return new IPAddress(randomIP())
-    }
-
-
-    public static randomIP6(): IPAddress {
-        return new IPAddress(randomIP6())
-    }
-
-
-    public static randomCIDRIp(cidr: ip6addr.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
-        if (cidr === 'lan') cidr = IPAddress.lan_cidrs
-        if (cidr === 'lan4') cidr = IPAddress.lan_cidrs4
-        if (cidr === 'lan6') cidr = IPAddress.lan_cidrs6
-        if (cidr === 'local') cidr = IPAddress.local_cidrs
-        if (cidr === 'local4') cidr = IPAddress.local_cidrs4
-        if (cidr === 'local6') cidr = IPAddress.local_cidrs6
-        // dbg('randomCIDRIp', cidr)
-        if (cidr.length === 0) throw new Error('CIDR array is empty')
-        // Pick a random CIDR network
-        const network = cidr[Math.floor(Math.random() * cidr.length)];
-        // dbg('randomCIDRIp:network', network)
-        // Get the range of IPs in this CIDR
-        const start = network.first().toBigInt()
-        // dbg('randomCIDRIp:first', network.first().toString(),start)
-        const end = network.last().toBigInt();
-        // dbg('randomCIDRIp:last', network.last().toString(),end)
-        let range : any = end-start
-        // dbg('randomCIDRIp:first:last', start, end)
-
-        
-        // Generate a random Long between the start and end
-        // if start-end > Maximum integer number
-        // we need to use BigInt
-        if (range > BigInt(Number.MAX_SAFE_INTEGER)) range=(Number.MAX_SAFE_INTEGER)
-        
-        const randomBigInt = BigInt(Math.floor(Math.random() * (Number(range) + 1))) + start;
-        // dbg('randomBigInt', randomBigInt)
-
-        // Convert the BigInt back to an IP address
-        const randomIp = ip6addr.parse(randomBigInt)
-        // dbg('randomCIDRIp', randomIp.toString())
-
-        return new IPAddress(randomIp.toString())
-    }
-
-    public serialize(): string {
-        if (this.kind() === 4) {
-            // zero pad ipv4
-            return this._ip.toString().split('.').map((octet) => {
-                return octet.padStart(3, '0')
-            }).join('.').replace(/\./g, '')
-        }
-
-        // zero pad ipv6 
-        return ip6.normalize(this._ip.toString()).split(':').map((hextet: string) => {
-            return hextet.padStart(4, '0')
-        }).join(':').replace(/:/g, '')
-    }
-
-    public kind(): number {
-        return this._ip.kind() === 'ipv6' ? 6 : 4
-    }
-
-    public equals(secondIp: IPAddress): boolean {
-        return this._ip.compare(secondIp._ip) === 0
-    }
-
-    public randomPad(): string {
-        if (this.kind() === 4) return this.padIp4()
-        return this.padIp6()
-    }
-
-    public normalized(): string {
-        if (this.kind() === 4) return this._ip.toString()
-        return ip6.normalize(this._ip.toString())
-    }
-
-
-    private padIp6(): string {
-        const hextets = this.normalized().split(':') // we need to have the full form
-        const paddedHextets = hextets.map(hextet => {
-            const cleanHextet = Number(`0x${hextet}`).toString(16)
-            const padLength = Math.floor(Math.random() * (4 - cleanHextet.length))
-            return cleanHextet.padStart(padLength + cleanHextet.length, '0')
-        })
-
-        return paddedHextets.join(':')
-    }
-
-    private padIp4(): string {
-        const octets = this._ip.toString().split('.')
-        const paddedOctets = octets.map(octet => {
-            const cleanOctet = String(Number(octet))
-            const padLength = Math.floor(Math.random() * (3 - cleanOctet.length))
-            return cleanOctet.padStart(padLength + cleanOctet.length, '0')
-        });
-        return paddedOctets.join('.')
-    }
-
-    asciiChecksum(): string {
-        // support ipv4 and ipv6
-        // FNV-1a hash parameters
-        const FNV_PRIME = 0x01000193;
-        const FNV_OFFSET_BASIS = 0x811c9dc5;
-        const CHAR_SET = 'abcdefghijklmnopqrstuvwxyz0123456789';
-
-        let hash = FNV_OFFSET_BASIS;
-        const ip = this.normalized()
-        for (let i = 0; i < ip.length; i++) {
-            hash ^= ip.charCodeAt(i);
-            hash *= FNV_PRIME;
-            hash >>>= 0; // Ensure hash is always a positive 32-bit integer
-        }
-
-        // Map the hash to a character in the CHAR_SET
-        const index = hash % CHAR_SET.length;
-        return CHAR_SET.charAt(index);
-    }
-
-    checksum1(): string {
-        // this shall check that the ip is ipv4 and return the last octet as checksum
-        if (this.kind() !== 4) return 'x'
-        return this._ip.toString().split('.').pop() || '-'
-    }
-}

package/ts/models/Timespan.d.ts

@@ -1,18 +0,0 @@
-export declare class Timespan {
-    private readonly ms;
-    constructor(ms: number);
-    get miliseconds(): number;
-    get seconds(): number;
-    get minutes(): number;
-    get hours(): number;
-    get days(): number;
-    get weeks(): number;
-    get months(): number;
-    static miliseconds(amount: number): Timespan;
-    static seconds(amount: number): Timespan;
-    static minutes(mins: number): Timespan;
-    static hours(hours: number): Timespan;
-    static days(days: number): Timespan;
-    static weeks(weeks: number): Timespan;
-    static months(months: number): Timespan;
-}