mybase 1.2.2 → 1.2.3

package/ts/models/IPAddress.ts

@@ -1,272 +0,0 @@
-/// <reference path="./../../ip6addr.d.ts" />
-import debug from 'debug'
-import { randomIP, randomIP6, } from "./../"
-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')
-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: 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: 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: 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/Interfaces.ts

@@ -1,58 +0,0 @@
-import { networkInterfaces } from 'os';
-
-interface NetworkInterfaceInfo {
-    name: string;
-    ipv4: string[];
-    ipv6: string[];
-}
-
-
-export class Interfaces {
-
-    static findByName(name: string): NetworkInterfaceInfo | null {
-        const ifaces = this.getInterfaces()
-        const iface = ifaces.find(iface => iface.name === name)
-        return iface || null
-    }
-
-    static findByNamePrefix(prefix: string): NetworkInterfaceInfo[] {
-        const ifaces = this.getInterfaces()
-        return ifaces.filter(iface => iface.name.startsWith(prefix))
-    }
-
-    static findByIp(ip: string): NetworkInterfaceInfo | null {
-        const ifaces = this.getInterfaces()
-        const iface = ifaces.find(iface => iface.ipv4.includes(ip) || iface.ipv6.includes(ip))
-        return iface || null
-    }
-
-    static asApiServerConfig(ifaces:string[], port:number): {ip:string,port:number}[] {
-        const ret: {ip:string,port:number}[] = []
-        for (const iface of ifaces) {
-            const i = this.findByName(iface)
-            if (i) ret.push({ip:i.ipv4[0],port:port})
-        }
-        return ret
-    }
-
-    static getInterfaces(): NetworkInterfaceInfo[] {
-        const interfaces = networkInterfaces();
-        const result: NetworkInterfaceInfo[] = [];
-
-        for (const name of Object.keys(interfaces)) {
-            const networkInterface = interfaces[name];
-            if (networkInterface) {
-                const ipv4 = networkInterface.filter(info => info.family === 'IPv4').map(info => info.address);
-                const ipv6 = networkInterface.filter(info => info.family === 'IPv6').map(info => info.address);
-
-                result.push({
-                    name,
-                    ipv4,
-                    ipv6
-                });
-            }
-        }
-
-        return result;
-    }
-}

package/ts/models/OTPGenerator.test.ts

@@ -1,42 +0,0 @@
-import { OTPGenerator } from './OTPGenerator';
-import { wait } from './../funcs/wait';
-import { Timespan } from './Timespan';
-
-const passkey = 'hiowi3rmpewr34';
-describe('OTPGenerator', () => {
-    it('should generate OTP', () => {
-        const otpGenerator = new OTPGenerator(passkey, 5);
-        const otp = otpGenerator.generateOTP();
-        // length should be 5  + 13
-        expect(otp.length).toBe(18);
-        // console.log(otp);
-    })
-
-    it('should generate different OTPs in milliseconds', async () => {
-        const otpGenerator = new OTPGenerator(passkey, 5);
-        const otp1 = otpGenerator.generateOTP()
-        await wait(3/1000);
-        const otp2 = otpGenerator.generateOTP();
-        expect(otp1).not.toBe(otp2);
-    })
-
-    it('should generate different OTPs in milliseconds per password', async () => {
-        const otpGenerator1 = new OTPGenerator(passkey+'1', 5);
-        const otpGenerator2 = new OTPGenerator(passkey+'2', 5);
-        for(let i=0; i<10000; i++) {
-            const otp1 = otpGenerator1.generateOTP()
-            const otp2 = otpGenerator2.generateOTP();
-            expect(otp1).not.toBe(otp2);
-        }
-    })
-
-    it('age should be milliseconds since generation', async () => {
-        const otpGenerator = new OTPGenerator(passkey, 5);
-        const otp = otpGenerator.generateOTP();
-        await wait(1/1000);
-        const age = otpGenerator.age(otp);
-        expect(age).toBeInstanceOf(Timespan);
-        expect(age.miliseconds).toBeGreaterThan(0);
-        expect(age.miliseconds).toBeLessThan(100);
-    })
-});

package/ts/models/OTPGenerator.ts

@@ -1,43 +0,0 @@
-import * as crypto from 'crypto';
-import { Timespan } from './Timespan';
-
-
-export class OTPGenerator {
-    constructor(private passkey: string, private length: number = 4) {}
-
-    // Generate OTP with the current timestamp as nonce
-    public generateOTP(): string {
-        return this.generateOTPWithNonce(Date.now());
-    }
-
-    // Validate if the OTP matches by extracting the nonce and regenerating OTP
-    public validateOTP(otp: string): boolean {
-        if (!this.isValid(otp)) return false; // Validate plausibility of OTP
-        const nonce = this.extractNonce(otp);
-        return otp === this.generateOTPWithNonce(nonce);
-    }
-
-    // Get the age of the OTP compared to now
-    public age(otp: string): Timespan {
-        if (!this.isValid(otp)) throw new Error('Invalid OTP');
-        const nonce = this.extractNonce(otp);
-        return new Timespan(Date.now() - nonce)
-    }
-
-    public generateOTPWithNonce(nonce: number): string { // lets keep it public for testing
-        const hash = crypto.createHmac('sha256', this.passkey).update(nonce.toString()).digest('hex');
-        const otp = [...hash.slice(0, this.length)].map(char => String.fromCharCode((parseInt(char, 16) % 26) + 97)).join('');
-        return `${otp}${nonce.toString(16).padStart(13, '0')}`;
-    }
-
-    // Private helper to validate plausibility of OTP
-    private isValid(otp: string): boolean {
-        return otp.length === this.length + 13;
-    }
-
-    // Private helper to extract the nonce from the OTP
-    private extractNonce(otp: string): number {
-        const nonceHex = otp.slice(-13);
-        return parseInt(nonceHex, 16);
-    }
-}

package/ts/models/Timespan.ts

@@ -1,80 +0,0 @@
-export class Timespan {
-    constructor(private readonly ms: number){
-    }
-
-    get miliseconds() : number {
-        return this.ms
-    }
-
-    get seconds() : number {
-        return this.ms / 1000
-    }
-
-    get minutes() : number {
-        return this.ms / 1000 / 60
-    }
-
-    get hours() : number {
-        return this.ms / 1000 / 60 / 60
-    }
-
-    get days() : number {
-        return this.ms / 1000 / 60 / 60 / 24
-    }
-
-    get weeks() : number {
-        return this.ms / 1000 / 60 / 60 / 24 / 7
-    }
-
-    get months() : number {
-        return this.ms / 1000 / 60 / 60 / 24 / 30
-    }
-
-    static miliseconds(amount: number): Timespan {
-        return new Timespan(amount)
-    }
-
-    static seconds(amount: number): Timespan {
-        return new Timespan(amount * 1000)
-    }
-
-    static minutes(mins: number): Timespan {
-        return new Timespan(mins * 60 * 1000)
-    }
-
-    static hours(hours: number): Timespan {
-        return new Timespan(hours * 60 * 60 * 1000)
-    }
-
-    static days(days: number): Timespan {
-        return new Timespan(days * 24 * 60 * 60 * 1000)
-    }
-
-    static weeks(weeks: number): Timespan {
-        return new Timespan(weeks * 7 * 24 * 60 * 60 * 1000)
-    }
-
-    static months(months: number): Timespan {
-        return new Timespan(months * 30 * 24 * 60 * 60 * 1000)
-    }
-
-    static years(years: number): Timespan {
-        return new Timespan(years * 365 * 24 * 60 * 60 * 1000)
-    }
-
-    add(timespan: Timespan): Timespan {
-        return new Timespan(this.ms + timespan.ms)
-    }
-
-    subtract(timespan: Timespan): Timespan {
-        return new Timespan(this.ms - timespan.ms)
-    }
-
-
-    toJSON() {
-        return {
-            __type:'Timespan',
-            value:this.ms
-        }
-    }
-}

package/ts/models/Unixtime.test.ts

@@ -1,168 +0,0 @@
-import { Timespan } from './Timespan';
-import { Unixtime } from './Unixtime';
-
-describe('Unixtime', () => {
-  it('should create Unixtime object from Date', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    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);
-    const unixtime = new Unixtime(dateString);
-    expect(unixtime.toDate()).toEqual(date);
-  });
-
-  it('should create Unixtime object from number (short form)', () => {
-    const timestamp = 1640995200; // January 1, 2022 00:00:00 UTC
-    const date = new Date(timestamp * 1000);
-    const unixtime = new Unixtime(timestamp);
-    expect(unixtime.toDate()).toEqual(date);
-  });
-
-  it('should create Unixtime object from number (long form)', () => {
-    const timestamp = 1640995200000; // January 1, 2022 00:00:00 UTC
-    const date = new Date(timestamp);
-    const unixtime = new Unixtime(timestamp);
-    expect(unixtime.toDate()).toEqual(date);
-  });
-
-  it('should convert Unixtime to short Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const shortUnixtime = Math.round(date.getTime() / 1000);
-    expect(unixtime.toShortUnixtime()).toEqual(shortUnixtime);
-  });
-
-  it('should convert Unixtime to long Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    expect(unixtime.toLongUnixtime()).toEqual(date.getTime());
-  });
-
-  it('should convert Unixtime to ISO string', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    expect(unixtime.toISOString()).toEqual(date.toISOString());
-  });
-
-  it('should add miliseconds to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addMiliseconds(1000);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 1000));
-  });
-
-  it('should add seconds to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addSeconds(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 1000));
-  });
-
-  it('should add minutes to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addMinutes(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 60000));
-  });
-
-  it('should add hours to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addHours(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 3600000));
-  });
-
-  it('should add days to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addDays(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 86400000));
-  });
-
-  it('should add months to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addMonths(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.setMonth(date.getMonth() + 1)));
-  });
-
-  it('should add years to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addYears(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.setFullYear(date.getFullYear() + 1)));
-  });
-
-  it('clone should create brand new object', () => {
-    const unixtime0 = new Unixtime(new Date())
-    const unixtime1 = unixtime0.clone();
-    expect(unixtime1).not.toBe(unixtime0);
-    expect(unixtime0.toDate()).toEqual(unixtime1.toDate());
-  });
-
-
-  it('day,month,year should return correct values', () => {
-    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
-    expect(unixtime.day).toEqual(11);
-    expect(unixtime.month).toEqual(10);
-    expect(unixtime.year).toEqual(2024);
-    expect(unixtime.minutes).toEqual(13);
-    expect(unixtime.seconds).toEqual(14);
-    expect(unixtime.hours).toEqual(12);
-  })
-
-  it('fromYYYYMMDD should create Unixtime object from string', () => {
-    const unixtime = Unixtime.fromYYYYMMDD('20241011');
-    expect(unixtime.toISOString()).toEqual('2024-10-11T00:00:00.000Z');
-  })
-
-  it('yyyymmddhh should return correct values',() => {
-    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
-    expect(unixtime.yyyymmdd()).toEqual('20241011');
-    expect(unixtime.yyyymmddhh()).toEqual('2024101112');
-    // should also work with optional seperators
-    expect(unixtime.yyyymmddhh('-')).toEqual('2024-10-11-12');
-  })
-
-  it('randomPast should return random time in the past', () => {
-    const end = Unixtime.now()
-    const begin = end.clone().addYears(-1)
-    for(let i=0;i<100000;i++) {
-      const rand = Unixtime.randomPast(Timespan.years(1))
-      expect(rand.toLongUnixtime()).toBeGreaterThan(begin.toLongUnixtime());
-      expect(rand.toLongUnixtime()).toBeLessThan(end.toLongUnixtime());
-    }
-  })
-
-  it('randomFuture should return random time in the future within given timespan of 1 year', () => {
-    const begin = Unixtime.now()
-    const end = begin.clone().addYears(1)
-    for(let i=0;i<100000;i++) {
-      const rand = Unixtime.randomFuture(Timespan.years(1))
-      expect(rand.toLongUnixtime()).toBeGreaterThan(begin.toLongUnixtime());
-      expect(rand.toLongUnixtime()).toBeLessThan(end.toLongUnixtime());
-    }
-  })
-
-  it('yyyymmdd should work as designed',() => {
-    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
-    expect(unixtime.yyyymmdd()).toEqual('20241011');
-    expect(unixtime.yyyymmdd('-')).toEqual('2024-10-11');
-  })
-
-  it('fromYYYYMMDD should throw error when invalid date', () => {
-    expect(() => Unixtime.fromYYYYMMDD('20243131')).toThrow('Invalid month');
-    expect(() => Unixtime.fromYYYYMMDD('20241233')).toThrow('Invalid day');
-    expect(() => Unixtime.fromYYYYMMDD('xx')).toThrow('Invalid yyyymmdd value');
-    //@ts-ignore
-    expect(() => Unixtime.fromYYYYMMDD([])).toThrow('Invalid yyyymmdd value');
-  })
-});