@20syldev/api 4.7.0 → 4.8.0

package/src/modules/v4/cron.ts

@@ -0,0 +1,221 @@
+import { MAX_CRON_ITERATIONS, MAX_CRON_RESULTS } from '../../constants.js';
+import { VALID_TIMEZONES } from './time.js';
+
+type Timezone = (typeof VALID_TIMEZONES)[number];
+
+const FIELD_RANGES = [
+    { min: 0, max: 59 }, // minute
+    { min: 0, max: 23 }, // hour
+    { min: 1, max: 31 }, // day of month
+    { min: 1, max: 12 }, // month
+    { min: 0, max: 7 }, // day of week (0 and 7 = Sunday)
+] as const;
+
+const DOW_NAMES: Record<string, number> = {
+    Sunday: 0,
+    Monday: 1,
+    Tuesday: 2,
+    Wednesday: 3,
+    Thursday: 4,
+    Friday: 5,
+    Saturday: 6,
+};
+
+const DOW_DISPLAY = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+export interface CronResult {
+    expression: string;
+    description: string;
+    next: string[];
+    timezone: string;
+}
+
+function parseField(field: string, range: { min: number; max: number }): Set<number> {
+    const result = new Set<number>();
+
+    for (const part of field.split(',')) {
+        if (part === '*') {
+            for (let i = range.min; i <= range.max; i++) result.add(i);
+        } else if (part.startsWith('*/')) {
+            const step = parseInt(part.slice(2), 10);
+            if (isNaN(step) || step < 1) throw new Error(`Invalid step in "${part}"`);
+            for (let i = range.min; i <= range.max; i += step) result.add(i);
+        } else if (part.includes('-')) {
+            const [s, e] = part.split('-');
+            const start = parseInt(s!, 10);
+            const end = parseInt(e!, 10);
+            if (isNaN(start) || isNaN(end) || start < range.min || end > range.max || start > end) {
+                throw new Error(`Invalid range "${part}" (valid: ${range.min}-${range.max})`);
+            }
+            for (let i = start; i <= end; i++) result.add(i);
+        } else {
+            const val = parseInt(part, 10);
+            if (isNaN(val) || val < range.min || val > range.max) {
+                throw new Error(`Invalid value "${part}" (valid: ${range.min}-${range.max})`);
+            }
+            result.add(val);
+        }
+    }
+
+    return result;
+}
+
+function getComponents(
+    date: Date,
+    formatter: Intl.DateTimeFormat,
+): { minute: number; hour: number; dom: number; month: number; dow: number } {
+    const parts = Object.fromEntries(formatter.formatToParts(date).map((p) => [p.type, p.value]));
+    return {
+        minute: parseInt(parts.minute!, 10),
+        hour: parseInt(parts.hour!, 10) % 24,
+        dom: parseInt(parts.day!, 10),
+        month: parseInt(parts.month!, 10),
+        dow: DOW_NAMES[parts.weekday!] ?? 0,
+    };
+}
+
+function pad(n: number): string {
+    return String(n).padStart(2, '0');
+}
+
+function formatDow(field: string): string {
+    if (field === '1-5') return 'Monday through Friday';
+    if (field === '0' || field === '7') return 'Sunday';
+    if (field === '6') return 'Saturday';
+    const n = parseInt(field, 10);
+    if (!isNaN(n)) return DOW_DISPLAY[n % 7] ?? field;
+    return field;
+}
+
+function describe(fields: string[]): string {
+    const [mF, hF, domF, monthF, dowF] = fields as [string, string, string, string, string];
+
+    const isAll = (f: string) => f === '*';
+    const isFixed = (f: string) => /^\d+$/.test(f);
+    const isStep = (f: string) => /^\*\/\d+$/.test(f);
+
+    // Every minute
+    if (isAll(mF) && isAll(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
+        return 'Every minute';
+    }
+
+    // Every N minutes (whole day, every day)
+    if (isStep(mF) && isAll(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
+        const n = mF.slice(2);
+        return `Every ${n} minute${n === '1' ? '' : 's'}`;
+    }
+
+    // Every hour at minute 0
+    if (mF === '0' && isAll(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
+        return 'Every hour';
+    }
+
+    // Every N hours at minute 0
+    if (mF === '0' && isStep(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
+        const n = hF.slice(2);
+        return `Every ${n} hour${n === '1' ? '' : 's'}`;
+    }
+
+    // At specific time daily
+    if (isFixed(mF) && isFixed(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
+        return `At ${pad(parseInt(hF))}:${pad(parseInt(mF))} daily`;
+    }
+
+    // At specific time on specific weekday(s)
+    if (isFixed(mF) && isFixed(hF) && isAll(domF) && isAll(monthF) && !isAll(dowF)) {
+        return `At ${pad(parseInt(hF))}:${pad(parseInt(mF))}, ${formatDow(dowF)}`;
+    }
+
+    // At specific time on specific day of month
+    if (isFixed(mF) && isFixed(hF) && isFixed(domF) && isAll(monthF) && isAll(dowF)) {
+        return `At ${pad(parseInt(hF))}:${pad(parseInt(mF))}, on day ${domF} of the month`;
+    }
+
+    // Every N minutes, within hour range, optionally filtered by weekday
+    if (isStep(mF) && !isAll(hF) && isAll(domF) && isAll(monthF)) {
+        const n = mF.slice(2);
+        const parts = [`Every ${n} minute${n === '1' ? '' : 's'}`];
+        if (hF.includes('-')) {
+            const [h1, h2] = hF.split('-');
+            parts.push(`between ${pad(parseInt(h1!))}:00 and ${pad(parseInt(h2!))}:59`);
+        }
+        if (!isAll(dowF)) parts.push(formatDow(dowF));
+        return parts.join(', ');
+    }
+
+    return `At cron schedule: ${fields.join(' ')}`;
+}
+
+/**
+ * Parses a cron expression and returns the next scheduled execution dates.
+ *
+ * @param expr - Cron expression with 5 space-separated fields (minute hour dom month dow)
+ * @param count - Number of next executions to return (1–20, default 5)
+ * @param from - Starting date in ISO 8601 format (defaults to now)
+ * @param timezone - Timezone to evaluate the expression in (default "UTC")
+ * @returns Parsed expression with description and list of next execution timestamps
+ * @throws Error if the expression is invalid, count is out of range, or timezone is unsupported
+ */
+export default function cron(expr: string, count: number = 5, from?: string, timezone: string = 'UTC'): CronResult {
+    if (!expr) throw new Error('Please provide a cron expression (?expr=* * * * *)');
+
+    if (!VALID_TIMEZONES.includes(timezone as Timezone)) {
+        throw new Error(`Please provide a valid timezone. Options: ${VALID_TIMEZONES.join(', ')}`);
+    }
+
+    const fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5) {
+        throw new Error('Cron expression must have exactly 5 fields (minute hour dom month dow)');
+    }
+
+    if (count < 1 || count > MAX_CRON_RESULTS) {
+        throw new Error(`Count must be between 1 and ${MAX_CRON_RESULTS}`);
+    }
+
+    const fromMs = from ? new Date(from).getTime() : Date.now();
+    if (from && isNaN(fromMs)) throw new Error('Please provide a valid from date (ISO 8601)');
+
+    const sets = fields.map((f, i) => parseField(f, FIELD_RANGES[i]!));
+    const [minuteSet, hourSet, domSet, monthSet, dowSet] = sets as [
+        Set<number>,
+        Set<number>,
+        Set<number>,
+        Set<number>,
+        Set<number>,
+    ];
+
+    // Normalize DOW: treat 7 as Sunday (0)
+    if (dowSet.has(7)) {
+        dowSet.add(0);
+        dowSet.delete(7);
+    }
+
+    const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        month: 'numeric',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        weekday: 'long',
+        hour12: false,
+    });
+
+    // Always start from the next minute (never include the current minute)
+    let currentMs = (Math.floor(fromMs / 60000) + 1) * 60000;
+
+    const next: string[] = [];
+    let iterations = 0;
+
+    while (next.length < count && iterations < MAX_CRON_ITERATIONS) {
+        const { minute, hour, dom, month, dow } = getComponents(new Date(currentMs), formatter);
+
+        if (minuteSet.has(minute) && hourSet.has(hour) && domSet.has(dom) && monthSet.has(month) && dowSet.has(dow)) {
+            next.push(new Date(currentMs).toISOString());
+        }
+
+        currentMs += 60000;
+        iterations++;
+    }
+
+    return { expression: expr.trim(), description: describe(fields), next, timezone };
+}

package/src/modules/v4/geo.ts

@@ -5,7 +5,8 @@ export interface GeoResult {
     to: { lat: number; lon: number };
 }
 
-const EARTH_RADIUS_KM = 6371;
+import { EARTH_RADIUS_KM } from '../../constants.js';
+
 const CARDINALS = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
 
 function toRad(deg: number): number {

package/src/modules/v4/password.ts

@@ -1,8 +1,6 @@
 import { randomInt } from 'crypto';
 
-const MIN_LENGTH = 8;
-const MAX_LENGTH = 128;
-const MAX_COUNT = 20;
+import { MAX_PASSWORD_COUNT, MAX_PASSWORD_LENGTH, MIN_PASSWORD_LENGTH } from '../../constants.js';
 
 const UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
 const LOWER = 'abcdefghijklmnopqrstuvwxyz';
@@ -327,8 +325,8 @@ export default function password(
         separator = '-',
     } = options;
 
-    if (count < 1 || count > MAX_COUNT) {
-        throw new Error(`Count must be between 1 and ${MAX_COUNT}`);
+    if (count < 1 || count > MAX_PASSWORD_COUNT) {
+        throw new Error(`Count must be between 1 and ${MAX_PASSWORD_COUNT}`);
     }
 
     if (type === 'passphrase') {
@@ -348,8 +346,8 @@ export default function password(
         throw new Error('Type must be "random" or "passphrase"');
     }
 
-    if (isNaN(length) || length < MIN_LENGTH || length > MAX_LENGTH) {
-        throw new Error(`Length must be between ${MIN_LENGTH} and ${MAX_LENGTH}`);
+    if (isNaN(length) || length < MIN_PASSWORD_LENGTH || length > MAX_PASSWORD_LENGTH) {
+        throw new Error(`Length must be between ${MIN_PASSWORD_LENGTH} and ${MAX_PASSWORD_LENGTH}`);
     }
 
     let charset = '';

package/src/modules/v4/qrcode.ts

@@ -1,6 +1,7 @@
 import { createCanvas, loadImage } from 'canvas';
 import { toBuffer, toCanvas as qrToCanvas, toDataURL } from 'qrcode';
 
+import { MAX_QRCODE_LOGO_BYTES } from '../../constants.js';
 import { normalizeColor } from '../../utils/colors.js';
 
 export interface QRCodeOptions {
@@ -24,7 +25,6 @@ export interface QRCodeResult {
 
 const CORRECTIONS = new Set(['L', 'M', 'Q', 'H']);
 const FORMATS = new Set(['png', 'base64']);
-const MAX_LOGO_BYTES = 2 * 1024 * 1024;
 
 function clamp(value: number | undefined, name: string, def: number, min: number, max: number): number {
     if (value === undefined) return def;
@@ -44,7 +44,7 @@ async function fetchIcon(url: string): Promise<Buffer> {
     if (!contentType.startsWith('image/')) throw new Error('Icon URL must point to an image');
 
     const buffer = Buffer.from(await response.arrayBuffer());
-    if (buffer.length > MAX_LOGO_BYTES) throw new Error('Icon must be under 2MB');
+    if (buffer.length > MAX_QRCODE_LOGO_BYTES) throw new Error('Icon must be under 2MB');
 
     return buffer;
 }

package/src/modules/v4/regex.ts

@@ -0,0 +1,67 @@
+import { MAX_PATTERN_LENGTH, MAX_REGEX_MATCHES, MAX_STRING_LENGTH } from '../../constants.js';
+
+const VALID_FLAGS = new Set(['g', 'i', 'm', 's', 'u']);
+
+export interface RegexMatch {
+    match: string;
+    index: number;
+    groups: string[];
+    namedGroups: Record<string, string>;
+}
+
+export interface RegexResult {
+    valid: boolean;
+    pattern: string;
+    flags: string;
+    matches: RegexMatch[];
+    count: number;
+}
+
+/**
+ * Tests a regular expression pattern against a text and returns structured match results.
+ *
+ * @param pattern - The regex pattern to test (max 200 characters)
+ * @param text - The text to match against (max 1000 characters)
+ * @param flags - Optional regex flags; only g, i, m, s, u are accepted (g is always forced)
+ * @returns Match results with groups and named groups, or { valid: false } if the pattern is invalid
+ * @throws Error if pattern or text is missing or exceeds the maximum length
+ */
+export default function regex(pattern: string, text: string, flags: string = 'g'): RegexResult {
+    if (!pattern) {
+        throw new Error('Please provide a pattern (?pattern={regex})');
+    }
+    if (!text) {
+        throw new Error('Please provide a text (&text={string})');
+    }
+    if (pattern.length > MAX_PATTERN_LENGTH) {
+        throw new Error(`Pattern must be under ${MAX_PATTERN_LENGTH} characters`);
+    }
+    if (text.length > MAX_STRING_LENGTH) {
+        throw new Error(`Text must be under ${MAX_STRING_LENGTH} characters`);
+    }
+
+    const cleanedFlags = [...new Set(['g', ...flags.split('').filter((f) => VALID_FLAGS.has(f))])].join('');
+
+    let re: RegExp;
+    try {
+        re = new RegExp(pattern, cleanedFlags);
+    } catch {
+        return { valid: false, pattern, flags: cleanedFlags, matches: [], count: 0 };
+    }
+
+    const matches: RegexMatch[] = [];
+    let result: RegExpExecArray | null;
+
+    while ((result = re.exec(text)) !== null && matches.length < MAX_REGEX_MATCHES) {
+        matches.push({
+            match: result[0],
+            index: result.index,
+            groups: result.slice(1).map((g) => g ?? ''),
+            namedGroups: result.groups ? { ...result.groups } : {},
+        });
+        // Prevent infinite loop on zero-length matches
+        if (result[0].length === 0) re.lastIndex++;
+    }
+
+    return { valid: true, pattern, flags: cleanedFlags, matches, count: matches.length };
+}

package/src/modules/v4/time.ts

@@ -1,4 +1,6 @@
-const validFormats = [
+import { MAX_COUNTDOWN_YEARS } from '../../constants.js';
+
+const VALID_FORMATS = [
     'iso',
     'utc',
     'timestamp',
@@ -19,21 +21,23 @@ const validFormats = [
     'timezoneOffset',
 ] as const;
 
-const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'] as const;
+export const VALID_TIMEZONES = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'] as const;
 
-type TimeFormat = (typeof validFormats)[number];
-type Timezone = (typeof validTimezones)[number];
+type TimeFormat = (typeof VALID_FORMATS)[number];
+type Timezone = (typeof VALID_TIMEZONES)[number];
 
 /**
- * Returns the current or a random date/time in various formats and timezones.
+ * Returns the current or a random date/time in various formats and timezones,
+ * or computes a countdown/elapsed time to/from a target date.
  *
- * @param type - "live" for the current time or "random" for a random date within a range
+ * @param type - "live" for the current time, "random" for a random date, or "countdown" for a time diff
  * @param start - Optional start date for random mode (YYYY-MM-DD)
  * @param end - Optional end date for random mode (YYYY-MM-DD)
  * @param format - Optional specific format to return (e.g. "iso", "timestamp", "year")
  * @param timezone - Optional timezone (e.g. "UTC", "Europe/Paris")
- * @returns Object containing all time formats, or a single format if specified
- * @throws Error if type, format, or timezone is invalid
+ * @param target - Required for countdown mode: target date in ISO 8601 or YYYY-MM-DD format
+ * @returns Object containing all time formats, a single format, or a countdown result
+ * @throws Error if type, format, timezone, or target is invalid
  */
 export default function time(
     type: string = 'live',
@@ -41,9 +45,55 @@ export default function time(
     end?: string,
     format?: string,
     timezone?: string,
+    target?: string,
 ): Record<string, unknown> {
-    if (type !== 'live' && type !== 'random') {
-        throw new Error('Please provide a valid type (live or random)');
+    if (type !== 'live' && type !== 'random' && type !== 'countdown') {
+        throw new Error('Please provide a valid type (live, random or countdown)');
+    }
+
+    if (timezone && !VALID_TIMEZONES.includes(timezone as Timezone)) {
+        throw new Error(`Please provide a valid timezone. Options: ${VALID_TIMEZONES.join(', ')}`);
+    }
+
+    if (type === 'countdown') {
+        if (!target) {
+            throw new Error('Please provide a target date (?target=YYYY-MM-DD)');
+        }
+
+        const targetDate = new Date(target);
+        if (isNaN(targetDate.getTime())) {
+            throw new Error('Please provide a valid target date (ISO 8601 or YYYY-MM-DD)');
+        }
+
+        const now = new Date();
+        const maxMs = MAX_COUNTDOWN_YEARS * 365.25 * 24 * 3600 * 1000;
+
+        if (Math.abs(targetDate.getTime() - now.getTime()) > maxMs) {
+            throw new Error(`Target date must be within ${MAX_COUNTDOWN_YEARS} years from now`);
+        }
+
+        const direction: 'future' | 'past' = targetDate > now ? 'future' : 'past';
+        const diffMs = Math.abs(targetDate.getTime() - now.getTime());
+        const total_seconds = Math.floor(diffMs / 1000);
+
+        const days = Math.floor(total_seconds / 86400);
+        const hours = Math.floor((total_seconds % 86400) / 3600);
+        const minutes = Math.floor((total_seconds % 3600) / 60);
+        const seconds = total_seconds % 60;
+
+        const parts: string[] = [];
+        if (days > 0) parts.push(`${days} day${days !== 1 ? 's' : ''}`);
+        if (hours > 0) parts.push(`${hours} hour${hours !== 1 ? 's' : ''}`);
+        if (minutes > 0) parts.push(`${minutes} minute${minutes !== 1 ? 's' : ''}`);
+        if (seconds > 0) parts.push(`${seconds} second${seconds !== 1 ? 's' : ''}`);
+
+        return {
+            target: targetDate.toISOString(),
+            now: now.toISOString(),
+            direction,
+            remaining: { total_seconds, days, hours, minutes, seconds },
+            human: parts.length > 0 ? parts.join(', ') : '0 seconds',
+        };
     }
 
     if (start && !Date.parse(start)) {
@@ -54,12 +104,8 @@ export default function time(
         throw new Error('Please provide a valid end date (YYYY-MM-DD)');
     }
 
-    if (format && !validFormats.includes(format as TimeFormat)) {
-        throw new Error(`Please provide a valid format. Options: ${validFormats.join(', ')}`);
-    }
-
-    if (timezone && !validTimezones.includes(timezone as Timezone)) {
-        throw new Error(`Please provide a valid timezone. Options: ${validTimezones.join(', ')}`);
+    if (format && !VALID_FORMATS.includes(format as TimeFormat)) {
+        throw new Error(`Please provide a valid format. Options: ${VALID_FORMATS.join(', ')}`);
     }
 
     const getTimeFormats = (date: Date, tz: string): Record<string, unknown> => {
@@ -89,7 +135,7 @@ export default function time(
         const startDate = start ? new Date(start).getTime() : new Date('1900-01-01').getTime();
         const endDate = end ? new Date(end).getTime() : new Date('2100-12-31').getTime();
         const randomDate = new Date(startDate + Math.random() * (endDate - startDate));
-        const tz = timezone || validTimezones[Math.floor(Math.random() * validTimezones.length)]!;
+        const tz = timezone || VALID_TIMEZONES[Math.floor(Math.random() * VALID_TIMEZONES.length)]!;
         const formats = getTimeFormats(randomDate, tz);
 
         return format ? { date: formats[format] } : formats;

package/src/modules/v4.ts

@@ -5,6 +5,7 @@ export { default as captcha } from './v4/captcha.js';
 export { default as chat } from './v4/chat.js';
 export { default as color } from './v4/color.js';
 export { default as convert } from './v4/convert.js';
+export { default as cron } from './v4/cron.js';
 export { default as dice } from './v4/dice.js';
 export { default as domain } from './v4/domain.js';
 export * as encode from './v4/encode.js';
@@ -18,6 +19,7 @@ export { default as password } from './v4/password.js';
 export { default as personal } from './v4/personal.js';
 export { default as placeholder } from './v4/placeholder.js';
 export { default as qrcode } from './v4/qrcode.js';
+export { default as regex } from './v4/regex.js';
 export { default as statistics } from './v4/statistics.js';
 export * as text from './v4/text.js';
 export { default as tic_tac_toe } from './v4/tic_tac_toe.js';

package/src/routes/get.ts

@@ -257,6 +257,34 @@ router.get('/:version/domain', (req: Request, res: Response) => {
     }
 });
 
+// Parse a cron expression and compute next execution dates
+router.get('/:version/cron', (req: Request, res: Response) => {
+    const { expr, count, from, timezone } = req.query;
+    const { version } = req.params;
+
+    const cronFn = (req.module as { cron?: (e: string, n?: number, f?: string, tz?: string) => unknown }).cron;
+    if (!cronFn) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/cron`);
+        return;
+    }
+    if (!expr) {
+        error(res, 400, 'Please provide a cron expression (?expr=* * * * *)', `${version}/cron`);
+        return;
+    }
+
+    try {
+        const result = cronFn(
+            expr as string,
+            count !== undefined ? parseInt(count as string, 10) : 5,
+            from as string | undefined,
+            (timezone as string) ?? 'UTC',
+        );
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/cron`);
+    }
+});
+
 // RPG Dice roller
 router.get('/:version/dice', (req: Request, res: Response) => {
     const { roll } = req.query;
@@ -509,6 +537,33 @@ router.get('/:version/qrcode', async (req: Request, res: Response) => {
     }
 });
 
+// Test a regex pattern against a text
+router.get('/:version/regex', (req: Request, res: Response) => {
+    const { pattern, text, flags } = req.query;
+    const { version } = req.params;
+
+    const regexFn = (req.module as { regex?: (p: string, t: string, f?: string) => unknown }).regex;
+    if (!regexFn) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/regex`);
+        return;
+    }
+    if (!pattern) {
+        error(res, 400, 'Please provide a pattern (?pattern={regex})', `${version}/regex`);
+        return;
+    }
+    if (!text) {
+        error(res, 400, 'Please provide a text (&text={string})', `${version}/regex`);
+        return;
+    }
+
+    try {
+        const result = regexFn(pattern as string, text as string, flags as string | undefined);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/regex`);
+    }
+});
+
 // Statistics on a list of numbers
 router.get('/:version/statistics', (req: Request, res: Response) => {
     const { values } = req.query;
@@ -609,60 +664,26 @@ router.get('/:version/tic-tac-toe/list', (_req: Request, res: Response) => {
     error(res, 405, 'This endpoint only supports POST requests.');
 });
 
-// Display or generate time informations
+// Display or generate time informations, or compute a countdown
 router.get('/:version/time', (req: Request, res: Response) => {
-    const { type = 'live', start, end, format, timezone } = req.query;
-
-    const validFormats = [
-        'iso',
-        'utc',
-        'timestamp',
-        'locale',
-        'date',
-        'time',
-        'year',
-        'month',
-        'day',
-        'hour',
-        'minute',
-        'second',
-        'ms',
-        'dayOfWeek',
-        'dayOfYear',
-        'weekNumber',
-        'timezone',
-        'timezoneOffset',
-    ];
-    const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'];
-
-    if (type !== 'live' && type !== 'random') {
-        error(res, 400, 'Please provide a valid type (?type={type})', `${req.version}/time`);
-        return;
-    }
-    if (start && !Date.parse(start as string)) {
-        error(res, 400, 'Please provide a valid start date (?start={YYYY-MM-DD})', `${req.version}/time`);
-        return;
-    }
-    if (end && !Date.parse(end as string)) {
-        error(res, 400, 'Please provide a valid end date (?end={YYYY-MM-DD})', `${req.version}/time`);
-        return;
-    }
-    if (format && !validFormats.includes(format as string)) {
-        error(res, 400, 'Please provide a valid format (?format={format})', `${req.version}/time`);
-        return;
-    }
-    if (timezone && !validTimezones.includes(timezone as string)) {
-        error(res, 400, 'Please provide a valid timezone (?timezone={timezone})', `${req.version}/time`);
-        return;
-    }
+    const { type = 'live', start, end, format, timezone, target } = req.query;
 
     try {
-        const time = req.module.time(
+        const timeFn = req.module.time as (
+            t: string,
+            s?: string,
+            e?: string,
+            f?: string,
+            tz?: string,
+            target?: string,
+        ) => Record<string, unknown>;
+        const time = timeFn(
             type as string,
             start as string,
             end as string,
             format as string,
             timezone as string,
+            target as string,
         );
         res.jsonResponse(time);
     } catch (err) {