mybase 1.1.53 → 1.2.3

package/ts/funcs/randomTCPPort.ts

@@ -1,58 +0,0 @@
-import * as net from 'net'
-
-/**
- * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
- * this port number immediately
- * This function should be used for testing purposes only
- * This function is not suitable for production use
- * @param timeout the timeout for each port check
- * @param fromPort the first port number to check defaults to 1025
- * @param untilPort the last port number to check defaults to 65534
- * @param tries the number of tries to find a port number
- * @param host the host to bind to
- */
-export async function randomTCPPort(timeout: number = 1000, fromPort: number = 1025, untilPort: number = 65534, tries = 1000, host = '127.0.0.1'): Promise<number | false> {
-    return new Promise(async function (resolve, reject) {
-        // check if the given port range is valid
-        if (fromPort > untilPort) return resolve(false)
-        // check if the given port range is valid
-        if (fromPort < 0 || untilPort < 0) return resolve(false)
-        // check if the given port range is valid
-        if (fromPort > 65535 || untilPort > 65535) return resolve(false)
-
-        // this function shall return a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
-        // this port number immediately
-        // this function should be used for testing purposes only
-        // this function is not suitable for production use
-        while(true && tries > 0) {
-            tries--
-            let port = Math.floor(Math.random() * (untilPort - fromPort + 1) + fromPort)
-            let server = net.createServer()
-            let checkPort = new Promise((resolveInner, reject) => {
-                server.on('error', (err) => {
-                    // any error should raise problem
-                    resolveInner(false)
-                })
-                server.on('listening', () => {
-                    resolveInner(true)
-                })
-            })
-            server.listen(port, host)
-            let result = await checkPort
-            if (result) {
-                let to = setTimeout(() => {
-                    return resolve(port)
-                },1000)
-                server.on('close', () => {
-                    clearTimeout(to)
-                    return resolve(port)
-                })
-                server.close()
-                return
-            } else server.close()
-        }
-        if (tries===0) 
-            return resolve(false)
-    })
-
-}

package/ts/funcs/randomUTFString.test.ts

@@ -1,44 +0,0 @@
-import { randomUTFString } from './randomUTFString';
-
-describe('randomUTFString', () => {
-    const asciiCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    let extendedCharset =
-        'àáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿ' + // Accented Latin characters
-        'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρσςτυφχψω' + // Greek
-        'אבגדהוזחטיךכלםמןנסעפצקרשת' + // Hebrew
-        //Arabic
-        'ا ب ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ف ق ك ل م ن ه و ي' +
-        // Persian
-        'آ ا ب پ ت ث ج چ ح خ د ذ ر ز ژ س ش ص ض ط ظ ع غ ف ق ک گ ل م ن و ه ی' +
-        // Turkish
-        'a b c ç d e f g ğ h ı i j k l m n o ö p r s ş t u ü v y z' +
-        'A B C Ç D E F G Ğ H I İ J K L M N O Ö P R S Ş T U Ü V Y Z' +
-        // More Emojis
-        '🙂🤔😍😂👍🚀❤️🎉' +
-        'абвгдежзийклмнопрстуфхцчшщъыьэюя' + // Cyrillic (Russian, etc.)
-        '日本語中文한국어' + // Japanese, Chinese, Korean characters
-        '🙂🤔😍😂👍🚀❤️🎉' // Emojis
-    it('should generate a random string within the specified length range', () => {
-        const minLength = 5;
-        const maxLength = 10;
-        const result = randomUTFString(minLength, maxLength);
-        expect(result.length).toBeGreaterThanOrEqual(minLength);
-        expect(result.length).toBeLessThanOrEqual(maxLength+1); // utf8 characters can be 1-4 bytes long
-    });
-
-    it('should include ASCII characters by default', () => {
-        const result = randomUTFString(500, 400);
-        
-        expect(result).toMatch(new RegExp(`[${asciiCharacters}]`));
-    });
-
-    it('should exclude ASCII characters when includeAscii is set to false', () => {
-        const result = randomUTFString(500, 1000, false);
-        expect(result).not.toMatch(new RegExp(`[${asciiCharacters}]`));
-    });
-
-    it('should include extended characters when includeAscii is set to true', () => {
-        const result = randomUTFString(500, 1000, true);
-        expect(result).toMatch(new RegExp(`[${extendedCharset}]`));
-    });
-});

package/ts/funcs/randomUTFString.ts

@@ -1,33 +0,0 @@
-
-
-
-export function randomUTFString(minLength: number, maxLength: number, includeAscii:boolean=true): string {
-    // Extended characters set including various languages and symbols
-    let characters = 
-        'àáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿ' + // Accented Latin characters
-        'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρσςτυφχψω' + // Greek
-        'אבגדהוזחטיךכלםמןנסעפצקרשת' + // Hebrew
-        //Arabic
-        'ا ب ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ف ق ك ل م ن ه و ي' +
-        // Persian
-        'آ ا ب پ ت ث ج چ ح خ د ذ ر ز ژ س ش ص ض ط ظ ع غ ف ق ک گ ل م ن و ه ی' +
-        // Turkish
-        'ğıöşü' +
-        'ĞİÖŞÜ ' +
-        // More Emojis
-        '🙂🤔😍😂👍🚀❤️🎉' +
-        'бвгдежзийклмнопрстуфхцчшщъыьэюя' + // Cyrillic (Russian, etc.)
-        '日本語中文한국어' + // Japanese, Chinese, Korean characters
-        '🙂🤔😍😂👍🚀❤️🎉' // Emojis
-
-    if (includeAscii) characters += 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
-
-    const charactersLength = Array.from(characters).length
-    const length = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength
-    let result = ''
-
-    for (let i = 0; i < length; i++) 
-        result += Array.from(characters)[Math.floor(Math.random() * charactersLength)]
-    
-    return result
-}

package/ts/funcs/utcnow.ts

@@ -1,5 +0,0 @@
-import { UnixtimeShort } from '../types'
-
-export function utcnow() : UnixtimeShort  {
-    return Math.floor(Date.now() / 1000)
-}

package/ts/funcs/validEmail.test.js

@@ -1,31 +0,0 @@
-const { validEmail } = require('./validEmail')
-
-// since we use validator, we do not need to test it further
-// detailed tests with millions of emails are in tests/ folder which is .gitignored
-
-describe('validEmail', () => {
-    test('should return true for a valid email', () => {
-        const email = 'test@example.com'
-        expect(validEmail(email)).toBe(true)
-    })
-
-    test('should return false for an invalid email', () => {
-        const email = 'invalidemail'
-        expect(validEmail(email)).toBe(false)
-    })
-
-    test('should return false for an empty email', () => {
-        const email = ''
-        expect(validEmail(email)).toBe(false)
-    })
-
-    test('should return false for a null email', () => {
-        const email = null
-        expect(validEmail(email)).toBe(false)
-    })
-
-    test('should return false for a non-string email', () => {
-        const email = 12345
-        expect(validEmail(email)).toBe(false)
-    })
-})

package/ts/funcs/validEmail.ts

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

package/ts/funcs/validIp.test.ts

@@ -1,33 +0,0 @@
-import { validIp } from './validIp';
-
-describe('validIp', () => {
-  it('should return true for a valid IP address', () => {
-    const ipAddress = '192.168.0.1';
-    const result = validIp(ipAddress);
-    expect(result).toBe(4);
-  });
-
-  it('should return false for an invalid IP address', () => {
-    const ipAddress = '256.0.0.1';
-    const result = validIp(ipAddress);
-    expect(result).toBe(0);
-  });
-
-  it('should support IPv6', () => {
-    const ipAddress = '2001:0db8:85a3:0000:0000:8a2e:0370:7334';
-    const result = validIp(ipAddress);
-    expect(result).toBe(6);
-  })
-
-  it('invalid IPv6', () => {
-    const ipAddress = '2001:0db8:85a3:0000:0000:8a2e:0370:7334:0000';
-    const result = validIp(ipAddress);
-    expect(result).toBe(0);
-  })
-
-  it('should support IPv6 shorthand', () => {
-    const ipAddress = '2001:db8:85a3::8a2e:370:7334';
-    const result = validIp(ipAddress);
-    expect(result).toBe(6);
-  })
-})

package/ts/funcs/validIp.ts

@@ -1,5 +0,0 @@
-import * as net from 'net'
-
-export function validIp(IPAddress: string): number {
-    return net.isIP(IPAddress)
-}

package/ts/funcs/vaultFill.ts

@@ -1,89 +0,0 @@
-import { debug } from "debug"
-import nodeVault from "node-vault";
-import { vaultRead } from "./vaultRead";
-const dbg = debug('vaultFill')
-
-export function vaultFill(vaultInstance: nodeVault.client, inputObject: any, ignoreError = false, keepCache = true) {
-    // v2.1
-    // fills all strings with ^vault@/secret/... with proper vault values
-    // if you call it again, it does reload the configuration
-    // v2.2 
-    // supports keepCache - if vault fails, we will keep previous values instead of filling with false
-    return new Promise(async function (resolve, reject) {
-        let vaultKeys = Array<string>()
-        let vaultResults: any = {}
-        findVaultKeyMappings(inputObject, vaultKeys)
-
-        // read these keys from vault
-        for (let idx in vaultKeys) {
-            const val = vaultKeys[idx]
-            if (typeof val !== "string") continue
-
-            try {
-                let got = await vaultRead(vaultInstance, vaultKeys[idx])
-                got['__vaultkey'] = val
-                got['__vaultfilled'] = Date.now()
-                vaultResults[val]=got
-            }
-            catch (err) {
-
-                dbg(`Could not read vaultKey '${val}'`, err)
-                if (!ignoreError) vaultResults[val]=false
-            }
-        }
-
-        fillVaultKeyMappings(inputObject, vaultResults, keepCache)
-
-        resolve(true)
-    })
-}
-
-
-function findVaultKeyMappings(config: any, keys = Array<string>()) {
-    for (var i in config) {
-        if (config[i] !== null) {
-            if (typeof config[i] === 'object' && (config[i].constructor.name === 'Array' || config[i].constructor.name === 'Object'))
-                findVaultKeyMappings(config[i], keys)
-
-            // detect previously read vaultKey
-            if (i === '__vaultkey') {
-                if (!keys.includes(vaultKey)) keys.push(config[i])
-                continue
-            }
-            // --
-            if (typeof config[i] === 'string' && config[i].search(/^vault@/) == 0) {
-                var splitted = config[i].split(/vault@/)
-                if (splitted.length == 2) {
-                    var vaultKey = splitted[1]
-                    if (!keys.includes(vaultKey)) keys.push(vaultKey)
-                }
-            }
-        }
-    }
-}
-
-function fillVaultKeyMappings(config: any, vaultResults:any, keepCache = true) {
-    for (var i in config) {
-        if (config[i] !== null) {
-
-            if (config[i] && config[i].constructor.name === 'Object' && config[i].hasOwnProperty('__vaultkey')) {
-                if (keepCache) {
-                    if (vaultResults[config[i]['__vaultkey']]) config[i] = vaultResults[config[i]['__vaultkey']]
-                }
-
-                else
-                    config[i] = vaultResults[config[i]['__vaultkey']]
-                continue
-            }
-            if (typeof config[i] === 'object' && (config[i].constructor.name === 'Array' || config[i].constructor.name === 'Object'))
-                fillVaultKeyMappings(config[i], vaultResults)
-            if (typeof config[i] === 'string' && config[i].search(/^vault@/) == 0) {
-                var splitted = config[i].split(/vault@/)
-                if (splitted.length == 2) {
-                    var vaultKey = splitted[1]
-                    config[i] = vaultResults[vaultKey]
-                }
-            }
-        }
-    }
-}

package/ts/funcs/vaultRead.ts

@@ -1,45 +0,0 @@
-import { debug } from "debug"
-import nodeVault from "node-vault";
-import path from "path";
-import fs from "fs";
-import { readFileSync } from 'fs';
-import { fileCacheIsValid } from "./fileCacheIsValid";
-import { vault_cache_folder } from "../global";
-import { hash_sha512 } from "./hash_sha512";
-const dbg = debug('vaultRead')
-
-// need to implement it better
-
-export function vaultRead(vaultInstance: nodeVault.client, vaultKey: string, cache_in_minutes = 10) : Promise<any> {
-    // v2 - supports caching
-    return new Promise((resolve, reject) => {
-        let cache_file = path.join(vault_cache_folder, hash_sha512(`${vaultInstance.endpoint}/${vaultKey}`))
-
-        if (cache_in_minutes > 0 && fileCacheIsValid(cache_file, cache_in_minutes))
-            return resolve(JSON.parse(readFileSync(cache_file as string).toString()))
-
-        vaultInstance.read(vaultKey).then((r) => {
-            if (r.data) {
-                dbg(`vault ${vaultKey} - success`)
-                if (cache_in_minutes > 0)
-                    try { fs.writeFileSync(cache_file, JSON.stringify(r.data)); fs.chmodSync(cache_file, 0o600); } catch (_) { }
-                return resolve(r.data);
-            }
-            dbg(`vault ${vaultKey} - failed`)
-            reject(r);
-        }).catch(e => {
-            dbg(`exception inside vaultRead`, e)
-            // we will still return latest information from cache
-            try {
-                dbg(`returning vault@${vaultKey} from cache due to error`)
-                if (fs.existsSync(cache_file))
-                    return resolve(JSON.parse(fs.readFileSync(cache_file as string).toString()))
-            } catch (e2) {
-                // content of the file is invalid
-                console.log(e2)
-            }
-
-            reject(e);
-        })
-    })
-}

package/ts/funcs/wait.ts

@@ -1,7 +0,0 @@
-
-
-export function wait(seconds=1) : Promise<void> {
-    return new Promise((resolve,reject)=>{
-      setTimeout(resolve,seconds*1000)
-    })
-}

package/ts/global.ts

@@ -1,10 +0,0 @@
-import fs from 'fs'
-
-export let vault_cache_folder = '/var/tmp/vault-cache'
-
-try {
-    if (!fs.existsSync(vault_cache_folder)) 
-    fs.mkdirSync(vault_cache_folder)
-} catch(e) {
-    console.log(e)
-}

package/ts/index.test.ts

@@ -1,7 +0,0 @@
-import * as IMPORTS from "./index";
-
-test('exports', () => {
-    for(let fn of Object.values(IMPORTS)) {
-        expect(typeof fn=='function' || typeof fn==='object').toBe(true)
-    }
-})

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 }
-            }
-        }
-    }
-}