mybase 1.1.22 → 1.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/index.js

@@ -43,4 +43,5 @@ __exportStar(require("./funcs/MaxRuntimeHours"), exports);
 // models
 __exportStar(require("./models/Unixtime"), exports);
 __exportStar(require("./models/Timespan"), exports);
+__exportStar(require("./models/IPAddress"), exports);
 //# sourceMappingURL=index.js.map

package/ts/index.ts

@@ -30,3 +30,4 @@ export * from "./funcs/MaxRuntimeHours"
 // models
 export * from "./models/Unixtime"
 export * from "./models/Timespan"
+export * from "./models/IPAddress"

package/ts/models/IPAddress.jest.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ip6addr_1 = __importDefault(require("ip6addr"));
+const IPAddress_1 = require("./IPAddress");
+const __1 = require("../");
+describe('IPAddress', () => {
+    it('should create an instance of IPAddress', () => {
+        const ipAddress = new IPAddress_1.IPAddress('192.168.0.1');
+        expect(ipAddress).toBeInstanceOf(IPAddress_1.IPAddress);
+    });
+    it('should convert IPAddress to string', () => {
+        const ipAddress = new IPAddress_1.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_1.IPAddress.fromString('192.168.0.1');
+        expect(ipAddress).toBeInstanceOf(IPAddress_1.IPAddress);
+    });
+    it('should throw an error when creating an instance of IPAddress from invalid string', () => {
+        expect(() => IPAddress_1.IPAddress.fromString('192.168.0')).toThrow();
+        expect(() => IPAddress_1.IPAddress.fromString('0.0.0')).toThrow();
+        expect(() => IPAddress_1.IPAddress.fromString('')).toThrow();
+        //@ts-ignore
+        expect(() => IPAddress_1.IPAddress.fromString(null)).toThrow();
+        //@ts-ignore
+        expect(() => IPAddress_1.IPAddress.fromString(undefined)).toThrow();
+    });
+    it('should serialize ipv4 to string', () => {
+        expect(IPAddress_1.IPAddress.fromString('192.168.0.1').serialize()).toBe('192168000001');
+        expect(IPAddress_1.IPAddress.fromString('0.0.0.0').serialize()).toBe('000000000000');
+        expect(IPAddress_1.IPAddress.fromString('0.0.0.1').serialize()).toBe('000000000001');
+        expect(IPAddress_1.IPAddress.fromString('0.00.000.01').serialize()).toBe('000000000001');
+        expect(IPAddress_1.IPAddress.fromString('0.10.0.0').serialize()).toBe('000010000000');
+        expect(IPAddress_1.IPAddress.fromString('255.255.255.255').serialize()).toBe('255255255255');
+    });
+    it('should serialize ipv6 to string', () => {
+        expect(IPAddress_1.IPAddress.fromString('::').serialize()).toBe('00000000000000000000000000000000');
+        expect(IPAddress_1.IPAddress.fromString('::1').serialize()).toBe('00000000000000000000000000000001');
+        expect(IPAddress_1.IPAddress.fromString('::01').serialize()).toBe('00000000000000000000000000000001');
+        expect(IPAddress_1.IPAddress.fromString('::001').serialize()).toBe('00000000000000000000000000000001');
+        expect(IPAddress_1.IPAddress.fromString('::0001').serialize()).toBe('00000000000000000000000000000001');
+        expect(IPAddress_1.IPAddress.fromString('::1:1').serialize()).toBe('00000000000000000000000000010001');
+        expect(IPAddress_1.IPAddress.fromString('::2:1').serialize()).toBe('00000000000000000000000000020001');
+    });
+    // testing unserialize
+    it('should unserialize ipv4 from string', () => {
+        expect(IPAddress_1.IPAddress.unserialize('192168000001').toString()).toBe('192.168.0.1');
+        expect(IPAddress_1.IPAddress.unserialize('192168000002').toString()).toBe('192.168.0.2');
+        expect(IPAddress_1.IPAddress.unserialize('000000000000').toString()).toBe('0.0.0.0');
+    });
+    it('should throw invalid serialization string', () => {
+        expect(() => IPAddress_1.IPAddress.unserialize('92168000001')).toThrow(Error);
+        expect(() => IPAddress_1.IPAddress.unserialize('168000001')).toThrow(Error);
+        expect(() => IPAddress_1.IPAddress.unserialize('292168000002')).toThrow(Error);
+    });
+    it('randomly generated ipv4 serialization', () => {
+        for (let i = 0; i < 100; i++) {
+            const ip = (0, __1.randomIP)();
+            expect(IPAddress_1.IPAddress.unserialize(IPAddress_1.IPAddress.fromString(ip).serialize()).toString()).toBe(ip);
+        }
+    });
+    it('randomly generated ipv6 serialization and unserialization', () => {
+        for (let i = 0; i < 100; i++) {
+            const ip = (0, __1.randomIP6)();
+            let ip2 = IPAddress_1.IPAddress.unserialize(IPAddress_1.IPAddress.fromString(ip).serialize()).toString();
+            expect(ip6addr_1.default.compare(ip, ip2)).toEqual(0);
+        }
+    });
+    it('it should detect the kind of ip4', () => {
+        for (let i = 0; i < 100; i++)
+            expect(IPAddress_1.IPAddress.randomIP4().kind()).toBe(4);
+    });
+    it('should return shortened address by default toString', () => {
+        expect(new IPAddress_1.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_1.IPAddress.randomIP4();
+            const ip2 = ip1.randomPad();
+            if (ip1.toString() !== ip2) { // find ips they are padded from the original
+                compared++;
+            }
+            expect(IPAddress_1.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_1.IPAddress.randomIP4();
+            const ip2 = ip1.randomPad();
+            if (ip1.toString() !== ip2) { // find ips they are padded from the original
+                compared++;
+            }
+            expect(ip1.equals(IPAddress_1.IPAddress.fromString(ip2))).toBe(true);
+        }
+    });
+});
+describe('IPAddress IPv6', () => {
+    it('should work with any form of valid ipv6, prefixed or not', () => {
+        expect(new IPAddress_1.IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress_1.IPAddress);
+        expect(new IPAddress_1.IPAddress('2605:2700:0000:003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress_1.IPAddress);
+        expect(new IPAddress_1.IPAddress('2605:2700:000:003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress_1.IPAddress);
+        expect(new IPAddress_1.IPAddress('2605:2700:0:003:a800:00ff:fe10:f0d3')).toBeInstanceOf(IPAddress_1.IPAddress);
+        expect(new IPAddress_1.IPAddress('2605:2700:0:003:a800:0ff:fe10:f0d3')).toBeInstanceOf(IPAddress_1.IPAddress);
+    });
+    it('should return shortened address by default toString', () => {
+        expect(new IPAddress_1.IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
+        expect(new IPAddress_1.IPAddress('2605:2700:0000:003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
+        expect(new IPAddress_1.IPAddress('2605:2700:0000:03:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
+        expect(new IPAddress_1.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_1.IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
+        expect(new IPAddress_1.IPAddress('2605:2700:0000:003:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
+        expect(new IPAddress_1.IPAddress('2605:2700:0000:03:a800:00ff:fe10:f0d3').toString()).toBe('2605:2700::3:a800:ff:fe10:f0d3');
+        expect(new IPAddress_1.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_1.IPAddress('2605:2700:0000:0003:a800:00ff:fe10:f0d3').kind()).toBe(6);
+        for (let i = 0; i < 100; i++)
+            expect(IPAddress_1.IPAddress.randomIP6().kind()).toBe(6);
+    });
+    it('randomPad return valid ipv6 results be compareable with equals', () => {
+        let compared = 0;
+        while (compared < 500) {
+            const ip1 = IPAddress_1.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_1.IPAddress.validate(ip2)).toBe(true);
+            expect(ip1.equals(IPAddress_1.IPAddress.fromString(ip2))).toBe(true);
+        }
+    });
+});
+describe('IPAddress asciiChecksum', () => {
+    it('should return the correct checksum for ipv4', () => {
+        expect(new IPAddress_1.IPAddress('1.2.3.4').asciiChecksum()).toBe('e');
+        expect(new IPAddress_1.IPAddress('1.2.3.6').asciiChecksum()).toBe('i');
+    });
+    it('should return the correct checksum for ipv6', () => {
+        expect(new IPAddress_1.IPAddress('::').asciiChecksum()).toBe('a');
+        expect(new IPAddress_1.IPAddress('::1').asciiChecksum()).toBe('a');
+        expect(new IPAddress_1.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_1.IPAddress((0, __1.randomIP)()).asciiChecksum().length).toBe(1);
+            expect(new IPAddress_1.IPAddress((0, __1.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_1.IPAddress((0, __1.randomIP)()).asciiChecksum());
+            expect('abcdefghijklmnopqrstuvwxyz0123456789').toContain(new IPAddress_1.IPAddress((0, __1.randomIP6)()).asciiChecksum());
+        }
+    });
+});
+//# sourceMappingURL=IPAddress.jest.js.map

package/ts/models/IPAddress.js

@@ -0,0 +1,167 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _IPAddress_instances, _IPAddress_padIp6, _IPAddress_padIp4;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPAddress = void 0;
+const __1 = require("./../");
+const ip6addr_1 = __importDefault(require("ip6addr"));
+const ip6 = require('ip6'); // "url": "https://github.com/elgs/ip6"
+// need version "ip6": "0.2.7",!!
+class IPAddress {
+    constructor(ip) {
+        _IPAddress_instances.add(this);
+        if (ip === '-')
+            ip = '0.0.0.0';
+        try {
+            this._ip = ip6addr_1.default.parse(ip);
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new Error(`IPAddress: '${ip}' Error: ${err.message}`);
+            throw err;
+        }
+    }
+    toString(opts = { format: 'auto', zeroElide: false, zeroPad: false }) {
+        return this._ip.toString();
+    }
+    static validate(ip) {
+        try {
+            new IPAddress(ip);
+            return true;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    static try(ip) {
+        try {
+            return new IPAddress(ip);
+        }
+        catch (_) {
+            return undefined;
+        }
+    }
+    static fromString(ip) {
+        return new IPAddress(ip);
+    }
+    static get Empty() {
+        //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');
+    }
+    isLoopbackIP() {
+        return (0, __1.isLoopbackIP)(this._ip.toString());
+    }
+    isLANIP() {
+        return (0, __1.isLANIp)(this._ip.toString());
+    }
+    isPublicIP() {
+        return !this.isLoopbackIP() && !this.isLANIP() && this.toString() !== '0.0.0.0';
+    }
+    static unserialize(serializedIpString) {
+        var _a, _b;
+        if (serializedIpString.length === 32) {
+            // we have possible ipv6
+            let ip = (_a = serializedIpString.match(/.{1,4}/g)) === null || _a === void 0 ? void 0 : _a.join(':');
+            if (ip)
+                return new IPAddress(ip);
+        }
+        // we have possible ipv4
+        let ip = (_b = serializedIpString.match(/.{1,3}/g)) === null || _b === void 0 ? void 0 : _b.join('.');
+        if (ip)
+            try {
+                return new IPAddress(ip);
+            }
+            catch (_) { }
+        throw new Error(`Invalid SerializationString: ${serializedIpString}`);
+    }
+    static randomIP4() {
+        return new IPAddress((0, __1.randomIP)());
+    }
+    static randomIP6() {
+        return new IPAddress((0, __1.randomIP6)());
+    }
+    serialize() {
+        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) => {
+            return hextet.padStart(4, '0');
+        }).join(':').replace(/:/g, '');
+    }
+    kind() {
+        return this._ip.kind() === 'ipv6' ? 6 : 4;
+    }
+    equals(secondIp) {
+        return this._ip.compare(secondIp._ip) === 0;
+    }
+    randomPad() {
+        if (this.kind() === 4)
+            return __classPrivateFieldGet(this, _IPAddress_instances, "m", _IPAddress_padIp4).call(this);
+        return __classPrivateFieldGet(this, _IPAddress_instances, "m", _IPAddress_padIp6).call(this);
+    }
+    normalized() {
+        if (this.kind() === 4)
+            return this._ip.toString();
+        return ip6.normalize(this._ip.toString());
+    }
+    abbreviated() {
+        if (this.kind() === 4)
+            return this._ip.toString();
+        return ip6.abbreviate(this._ip.toString());
+    }
+    asciiChecksum() {
+        // 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() {
+        // 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() || '-';
+    }
+}
+exports.IPAddress = IPAddress;
+_IPAddress_instances = new WeakSet(), _IPAddress_padIp6 = function _IPAddress_padIp6() {
+    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(':');
+}, _IPAddress_padIp4 = function _IPAddress_padIp4() {
+    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('.');
+};
+//# sourceMappingURL=IPAddress.js.map

package/ts/models/IPAddress.test.ts

@@ -0,0 +1,188 @@
+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)
+    }
+  })
+
+});
+
+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())
+    }
+  })
+})

package/ts/models/IPAddress.ts

@@ -0,0 +1,172 @@
+import { randomIP, randomIP6, isLoopbackIP, isLANIp } from "./../"
+import ip6addr, { Addr, ToStringOpts } from 'ip6addr'
+const ip6 = require('ip6') // "url": "https://github.com/elgs/ip6"
+// need version "ip6": "0.2.7",!!
+
+export class IPAddress {
+    private _ip: Addr
+
+    constructor(ip: string) { // may throw
+        if (ip === '-') ip = '0.0.0.0'
+
+        try {
+            this._ip = ip6addr.parse(ip)
+        } catch (err) {
+            if (err instanceof Error)
+                throw new Error(`IPAddress: '${ip}' Error: ${err.message}`)
+            throw err
+        }
+    }
+
+    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 isLoopbackIP(this._ip.toString())
+    }
+
+    public isLANIP(): boolean {
+        return isLANIp(this._ip.toString())
+    }
+
+    public isPublicIP(): boolean {
+        return !this.isLoopbackIP() && !this.isLANIP() && this.toString() !== '0.0.0.0'
+    }
+
+    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 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())
+    }
+
+    public abbreviated(): string {
+        if (this.kind() === 4) return this._ip.toString()
+        return ip6.abbreviate(this._ip.toString())
+    }
+
+    #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(':')
+    }
+
+    #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/Unixtime.js

@@ -35,9 +35,15 @@ class Unixtime {
             // set the value
             this.value = new Date(value);
         }
-        else {
+        else if (value instanceof Date) {
             this.value = value;
         }
+        else {
+            throw new Error('Invalid value');
+        }
+        if (isNaN(this.value.getTime())) {
+            throw new Error('Invalid date');
+        }
     }
     addTimespan(timespan) {
         this.value = new Date(this.value.getTime() + timespan.miliseconds);
@@ -93,6 +99,9 @@ class Unixtime {
             (hh > 9 ? '' : '0') + hh
         ].join('');
     }
+    getDay() {
+        return this.value.getDay();
+    }
     static from(value) {
         return new Unixtime(value);
     }
@@ -114,6 +123,14 @@ class Unixtime {
     elapsedMinutes() {
         return Math.round(this.elapsedSeconds() / 60);
     }
+    static try(value) {
+        try {
+            return new Unixtime(value);
+        }
+        catch (e) {
+            return null;
+        }
+    }
 }
 exports.Unixtime = Unixtime;
 Unixtime.EMPTY = new Unixtime(new Date(0));

package/ts/models/Unixtime.test.ts

@@ -7,6 +7,10 @@ describe('Unixtime', () => {
     expect(unixtime.toDate()).toEqual(date);
   });
 
+  it('create invalid date should throw error', () => {
+    expect(() => new Unixtime('invalid date')).toThrow();
+  })
+
   it('should create Unixtime object from string', () => {
     const dateString = '2022-01-01T00:00:00Z';
     const date = new Date(dateString);

package/ts/models/Unixtime.ts

@@ -42,8 +42,16 @@ export class Unixtime {
                 value = Math.round(value)
             // set the value
             this.value = new Date(value)
-        } else {
+        }
+        else if (value instanceof Date) {
             this.value = value
+        } 
+        else {
+            throw new Error('Invalid value')
+        }
+
+        if (isNaN(this.value.getTime())) {
+            throw new Error('Invalid date')
         }
     }
 
@@ -113,6 +121,10 @@ export class Unixtime {
     }
 
 
+    public getDay() : number {
+        return this.value.getDay()
+    }
+
     static from(value: Date | string | number) {
         return new Unixtime(value)
     }
@@ -141,4 +153,12 @@ export class Unixtime {
         return Math.round(this.elapsedSeconds() / 60)
     }
 
+
+    static try(value: Date | string | number): Unixtime | null {
+        try {
+            return new Unixtime(value)
+        } catch (e) {
+            return null
+        }
+    }
 }