@20syldev/api 4.3.0 → 4.5.0

package/src/modules/v4/convert.ts

@@ -1,38 +1,118 @@
-import { MIN_TEMPERATURE, MAX_TEMPERATURE } from '../../constants.js';
-
 type ConversionFn = (val: number) => number;
 
+const TEMPERATURE_UNITS = new Set(['celsius', 'fahrenheit', 'kelvin']);
+const ABSOLUTE_ZERO: Record<string, number> = { celsius: -273.15, fahrenheit: -459.67, kelvin: 0 };
+
 const conversions: Record<string, Record<string, ConversionFn>> = {
+    // Temperature
     celsius: {
-        fahrenheit: (val) => (val * 9) / 5 + 32,
-        kelvin: (val) => val + 273.15,
+        fahrenheit: (v) => (v * 9) / 5 + 32,
+        kelvin: (v) => v + 273.15,
     },
     fahrenheit: {
-        celsius: (val) => ((val - 32) * 5) / 9,
-        kelvin: (val) => ((val - 32) * 5) / 9 + 273.15,
+        celsius: (v) => ((v - 32) * 5) / 9,
+        kelvin: (v) => ((v - 32) * 5) / 9 + 273.15,
     },
     kelvin: {
-        celsius: (val) => val - 273.15,
-        fahrenheit: (val) => ((val - 273.15) * 9) / 5 + 32,
+        celsius: (v) => v - 273.15,
+        fahrenheit: (v) => ((v - 273.15) * 9) / 5 + 32,
+    },
+
+    // Length
+    km: {
+        mi: (v) => v * 0.621371,
+        m: (v) => v * 1000,
+        ft: (v) => v * 3280.84,
+        cm: (v) => v * 100000,
+        in: (v) => v * 39370.1,
+        yd: (v) => v * 1093.61,
+    },
+    mi: {
+        km: (v) => v * 1.60934,
+        m: (v) => v * 1609.34,
+        ft: (v) => v * 5280,
+        cm: (v) => v * 160934,
+        in: (v) => v * 63360,
+        yd: (v) => v * 1760,
+    },
+    m: {
+        km: (v) => v / 1000,
+        mi: (v) => v * 0.000621371,
+        ft: (v) => v * 3.28084,
+        cm: (v) => v * 100,
+        in: (v) => v * 39.3701,
+        yd: (v) => v * 1.09361,
+    },
+    ft: {
+        km: (v) => v * 0.0003048,
+        mi: (v) => v / 5280,
+        m: (v) => v * 0.3048,
+        cm: (v) => v * 30.48,
+        in: (v) => v * 12,
+        yd: (v) => v / 3,
+    },
+    cm: {
+        km: (v) => v / 100000,
+        mi: (v) => v / 160934,
+        m: (v) => v / 100,
+        ft: (v) => v / 30.48,
+        in: (v) => v / 2.54,
+        yd: (v) => v / 91.44,
     },
+    in: {
+        km: (v) => v / 39370.1,
+        mi: (v) => v / 63360,
+        m: (v) => v * 0.0254,
+        ft: (v) => v / 12,
+        cm: (v) => v * 2.54,
+        yd: (v) => v / 36,
+    },
+    yd: {
+        km: (v) => v * 0.0009144,
+        mi: (v) => v / 1760,
+        m: (v) => v * 0.9144,
+        ft: (v) => v * 3,
+        cm: (v) => v * 91.44,
+        in: (v) => v * 36,
+    },
+
+    // Weight
+    kg: { lb: (v) => v * 2.20462, oz: (v) => v * 35.274, g: (v) => v * 1000, ton: (v) => v / 1000 },
+    lb: { kg: (v) => v * 0.453592, oz: (v) => v * 16, g: (v) => v * 453.592, ton: (v) => v * 0.000453592 },
+    oz: { kg: (v) => v * 0.0283495, lb: (v) => v / 16, g: (v) => v * 28.3495, ton: (v) => v * 0.0000283495 },
+    g: { kg: (v) => v / 1000, lb: (v) => v * 0.00220462, oz: (v) => v * 0.035274, ton: (v) => v / 1000000 },
+    ton: { kg: (v) => v * 1000, lb: (v) => v * 2204.62, oz: (v) => v * 35274, g: (v) => v * 1000000 },
+
+    // Data
+    b: { kb: (v) => v / 1024, mb: (v) => v / 1048576, gb: (v) => v / 1073741824, tb: (v) => v / 1099511627776 },
+    kb: { b: (v) => v * 1024, mb: (v) => v / 1024, gb: (v) => v / 1048576, tb: (v) => v / 1073741824 },
+    mb: { b: (v) => v * 1048576, kb: (v) => v * 1024, gb: (v) => v / 1024, tb: (v) => v / 1048576 },
+    gb: { b: (v) => v * 1073741824, kb: (v) => v * 1048576, mb: (v) => v * 1024, tb: (v) => v / 1024 },
+    tb: { b: (v) => v * 1099511627776, kb: (v) => v * 1073741824, mb: (v) => v * 1048576, gb: (v) => v * 1024 },
+
+    // Speed
+    'km/h': { mph: (v) => v * 0.621371, 'm/s': (v) => v / 3.6, knots: (v) => v * 0.539957 },
+    mph: { 'km/h': (v) => v * 1.60934, 'm/s': (v) => v * 0.44704, knots: (v) => v * 0.868976 },
+    'm/s': { 'km/h': (v) => v * 3.6, mph: (v) => v * 2.23694, knots: (v) => v * 1.94384 },
+    knots: { 'km/h': (v) => v * 1.852, mph: (v) => v * 1.15078, 'm/s': (v) => v * 0.514444 },
 };
 
 export default function convert(
-    value: string | number,
+    value: number,
     from: string,
     to: string,
 ): { from: string; to: string; value: number; result: number } {
-    const convertFn = conversions[from.toLowerCase()]?.[to.toLowerCase()];
+    const fromKey = from.toLowerCase();
+    const toKey = to.toLowerCase();
+    const convertFn = conversions[fromKey]?.[toKey];
 
     if (!convertFn) throw new Error('Invalid conversion unit');
-    if (isNaN(Number(value))) throw new Error('Value must be a number');
-    if (Number(value) < MIN_TEMPERATURE) throw new Error('Value must be greater than absolute zero');
-    if (Number(value) > MAX_TEMPERATURE) throw new Error('Value must be less than 1,000,000');
-
-    return {
-        from,
-        to,
-        value: parseFloat(String(value)),
-        result: convertFn(parseFloat(String(value))),
-    };
+    if (isNaN(value)) throw new Error('Value must be a number');
+
+    if (TEMPERATURE_UNITS.has(fromKey)) {
+        const minValue = ABSOLUTE_ZERO[fromKey]!;
+        if (value < minValue) throw new Error('Value must be greater than absolute zero');
+    }
+
+    return { from, to, value, result: convertFn(value) };
 }

package/src/modules/v4/domain.ts

@@ -1,4 +1,4 @@
-import { random, genIP } from './utils.js';
+import { random, genIP } from '../../utils/helpers.js';
 
 export default function domain(): Record<string, unknown> {
     const subdomains = [

package/src/modules/v4/hash.ts

@@ -1,9 +1,23 @@
 import { getHashes, createHash } from 'crypto';
 
-export default function hash(text: string, method: string): { method: string; hash: string } | { error: string } {
+export interface HashResult {
+    method: string;
+    hash: string;
+    encoding: string;
+}
+
+const ENCODINGS = new Set(['hex', 'base64']);
+
+export default function hash(text: string, method: string, encoding: string = 'hex'): HashResult {
+    if (!text) throw new Error('Text is required');
+
     const methods = getHashes();
-    if (!methods.includes(method)) return { error: `Unsupported method. Use one of: ${methods.join(', ')}` };
+    if (!methods.includes(method)) throw new Error(`Unsupported method. Use one of: ${methods.join(', ')}`);
+
+    if (!ENCODINGS.has(encoding)) throw new Error('Encoding must be one of: hex, base64');
 
-    const result = createHash(method).update(text).digest('hex');
-    return { method, hash: result };
+    const result = createHash(method)
+        .update(text)
+        .digest(encoding as 'hex' | 'base64');
+    return { method, hash: result, encoding };
 }

package/src/modules/v4/hyperplanning.ts

@@ -1,4 +1,4 @@
-import { formatDate } from './utils.js';
+import { formatDate } from '../../utils/helpers.js';
 import ical from 'ical.js';
 
 interface CalendarEvent {
@@ -11,8 +11,34 @@ interface CalendarEvent {
     end: string;
 }
 
+function blocked(hostname: string): boolean {
+    const list = ['localhost', '127.0.0.1', '0.0.0.0', '[::1]', 'metadata.google.internal'];
+    if (list.includes(hostname)) return true;
+
+    const parts = hostname.split('.').map(Number);
+    if (parts.length === 4 && parts.every((n) => !isNaN(n))) {
+        if (parts[0] === 10) return true;
+        if (parts[0] === 172 && parts[1]! >= 16 && parts[1]! <= 31) return true;
+        if (parts[0] === 192 && parts[1] === 168) return true;
+        if (parts[0] === 169 && parts[1] === 254) return true;
+        if (parts[0] === 0) return true;
+    }
+
+    return false;
+}
+
 export default async function hyperplanning(url: string, detail?: string): Promise<CalendarEvent[]> {
-    const response = await fetch(url);
+    let parsed: URL;
+    try {
+        parsed = new URL(url);
+    } catch {
+        throw new Error('Invalid URL.');
+    }
+
+    if (parsed.protocol !== 'https:') throw new Error('Only HTTPS URLs are allowed.');
+    if (blocked(parsed.hostname)) throw new Error('Access to private/internal hosts is not allowed.');
+
+    const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
 
     if (!response.ok || !(response.headers.get('content-type') || '').includes('text/calendar')) {
         throw new Error('Invalid ICS file format.');

package/src/modules/v4/palette.ts

@@ -1,3 +1,5 @@
+import { hexToRgb, rgbToHsl, hslToRgb, rgbToHex } from '../../utils/colors.js';
+
 export interface PaletteColor {
     hex: string;
     rgb: string;
@@ -10,52 +12,10 @@ export interface PaletteResult {
     colors: PaletteColor[];
 }
 
-function hexToRgb(hex: string): [number, number, number] {
-    const clean = hex.replace('#', '');
-    if (!/^[0-9a-fA-F]{6}$/.test(clean)) throw new Error('Invalid HEX color (use #RRGGBB)');
-    return [parseInt(clean.slice(0, 2), 16), parseInt(clean.slice(2, 4), 16), parseInt(clean.slice(4, 6), 16)];
-}
-
-function rgbToHsl(r: number, g: number, b: number): [number, number, number] {
-    const r1 = r / 255,
-        g1 = g / 255,
-        b1 = b / 255;
-    const max = Math.max(r1, g1, b1),
-        min = Math.min(r1, g1, b1);
-    const l = (max + min) / 2;
-
-    if (max === min) return [0, 0, l];
-
-    const d = max - min;
-    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    let h = 0;
-    if (max === r1) h = (g1 - b1) / d + (g1 < b1 ? 6 : 0);
-    else if (max === g1) h = (b1 - r1) / d + 2;
-    else h = (r1 - g1) / d + 4;
-
-    return [(h * 60 + 360) % 360, s, l];
-}
-
-function hslToRgb(h: number, s: number, l: number): [number, number, number] {
-    const c = (1 - Math.abs(2 * l - 1)) * s;
-    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-    const m = l - c / 2;
-    let r1 = 0,
-        g1 = 0,
-        b1 = 0;
-    if (h < 60) [r1, g1, b1] = [c, x, 0];
-    else if (h < 120) [r1, g1, b1] = [x, c, 0];
-    else if (h < 180) [r1, g1, b1] = [0, c, x];
-    else if (h < 240) [r1, g1, b1] = [0, x, c];
-    else if (h < 300) [r1, g1, b1] = [x, 0, c];
-    else [r1, g1, b1] = [c, 0, x];
-    return [Math.round((r1 + m) * 255), Math.round((g1 + m) * 255), Math.round((b1 + m) * 255)];
-}
-
 function format(r: number, g: number, b: number): PaletteColor {
     const [h, s, l] = rgbToHsl(r, g, b);
     return {
-        hex: `#${[r, g, b].map((x) => x.toString(16).padStart(2, '0')).join('')}`,
+        hex: rgbToHex(r, g, b),
         rgb: `rgb(${r}, ${g}, ${b})`,
         hsl: `hsl(${h.toFixed(1)}, ${(s * 100).toFixed(1)}%, ${(l * 100).toFixed(1)}%)`,
     };

package/src/modules/v4/personal.ts

@@ -1,4 +1,4 @@
-import { random, randomNumber } from './utils.js';
+import { random, randomNumber } from '../../utils/helpers.js';
 
 interface Person {
     name: string;

package/src/modules/v4/placeholder.ts

@@ -1,3 +1,5 @@
+import { normalizeColor } from '../../utils/colors.js';
+
 type AvatarShape = 'circle' | 'rounded' | 'square';
 type AnimateMode = 'shimmer' | 'pulse' | 'none';
 
@@ -23,13 +25,6 @@ function parseSize(value: string | undefined, name: string, def: number): number
     return Math.floor(n);
 }
 
-function normalizeColor(value: string | undefined, def: string): string {
-    if (!value) return def;
-    const clean = value.startsWith('#') ? value : `#${value}`;
-    if (!/^#([0-9a-fA-F]{3}){1,2}$/.test(clean)) throw new Error('Invalid color (use hex like #ff6600)');
-    return clean;
-}
-
 function escapeXml(str: string): string {
     return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 }
@@ -88,8 +83,10 @@ function generateSkeleton(opts: PlaceholderOptions): string {
     const rx = opts.radius ?? 4;
 
     const pad = Math.round(width * 0.06);
-    const gap = Math.round(Math.max(6, Math.min(14, height * 0.04)));
-    const lineH = Math.round(Math.max(8, Math.min(16, ((height - pad * 2) / (rows + (avatar ? 4 : 0))) * 0.65)));
+    const slots = rows + (avatar ? 4 : 0);
+    const available = height - pad * 2;
+    const lineH = Math.round(Math.max(8, (available / Math.max(1, slots)) * 0.65));
+    const gap = Math.round(Math.max(6, (available / Math.max(1, slots)) * 0.35));
 
     const shapes: string[] = [];
     let y = pad;

package/src/modules/v4/qrcode.ts

@@ -1,11 +1,113 @@
-import { toDataURL } from 'qrcode';
+import { toBuffer, toDataURL, toCanvas as qrToCanvas } from 'qrcode';
+import { createCanvas, loadImage } from 'canvas';
+import { normalizeColor } from '../../utils/colors.js';
 
-export default async function qrcode(url: string): Promise<string> {
+export interface QRCodeOptions {
+    url: string;
+    size?: number;
+    margin?: number;
+    correction?: 'L' | 'M' | 'Q' | 'H';
+    dark?: string;
+    light?: string;
+    icon?: string;
+    iconSize?: number;
+    iconPadding?: number;
+    iconRadius?: number;
+    format?: 'png' | 'base64';
+}
+
+export interface QRCodeResult {
+    contentType: string;
+    body: Buffer | string;
+}
+
+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;
+    if (isNaN(value)) throw new Error(`${name} must be a number`);
+    if (value < min || value > max) throw new Error(`${name} must be between ${min} and ${max}`);
+    return Math.floor(value);
+}
+
+async function fetchIcon(url: string): Promise<Buffer> {
+    if (!/^https:\/\//i.test(url)) throw new Error('Icon URL must use HTTPS');
+
+    const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+
+    if (!response.ok) throw new Error(`Failed to fetch icon: HTTP ${response.status}`);
+
+    const contentType = response.headers.get('content-type') ?? '';
+    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');
+
+    return buffer;
+}
+
+export default async function qrcode(options: QRCodeOptions): Promise<QRCodeResult> {
+    const { url } = options;
     if (!url || typeof url !== 'string') throw new Error('Please provide a valid URL');
 
-    try {
-        return await toDataURL(url);
-    } catch (error) {
-        throw new Error(`Failed to generate QR code: ${(error as Error).message}`);
+    const format = options.format ?? 'png';
+    if (!FORMATS.has(format)) throw new Error('format must be one of: png, base64');
+
+    const size = clamp(options.size, 'size', 200, 50, 2000);
+    const margin = clamp(options.margin, 'margin', 4, 0, 10);
+    const dark = normalizeColor(options.dark, '#000000');
+    const light = normalizeColor(options.light, '#ffffff');
+
+    let correction = options.correction ?? 'M';
+    if (!CORRECTIONS.has(correction)) throw new Error('correction must be one of: L, M, Q, H');
+    if (options.icon) correction = 'H';
+
+    const qrOpts = {
+        width: size,
+        margin,
+        errorCorrectionLevel: correction as 'L' | 'M' | 'Q' | 'H',
+        color: { dark, light },
+    };
+
+    if (!options.icon) {
+        if (format === 'base64') {
+            return { contentType: 'application/json', body: await toDataURL(url, qrOpts) };
+        }
+        return { contentType: 'image/png', body: await toBuffer(url, qrOpts) };
+    }
+
+    const canvas = createCanvas(size, size);
+    await qrToCanvas(canvas as unknown as HTMLCanvasElement, url, qrOpts);
+
+    const iconBuffer = await fetchIcon(options.icon);
+    const iconImg = await loadImage(iconBuffer);
+
+    const iconSize = clamp(options.iconSize, 'iconSize', Math.round(size * 0.2), 10, Math.round(size * 0.4));
+    const iconPadding = clamp(options.iconPadding, 'iconPadding', 5, 0, 50);
+    const maxRadius = Math.floor((iconSize + iconPadding * 2) / 2);
+    const iconRadius = clamp(options.iconRadius, 'iconRadius', 0, 0, maxRadius);
+
+    const ctx = canvas.getContext('2d');
+    const totalSize = iconSize + iconPadding * 2;
+    const x = (canvas.width - totalSize) / 2;
+    const y = (canvas.height - totalSize) / 2;
+
+    ctx.beginPath();
+    ctx.roundRect(x, y, totalSize, totalSize, iconRadius);
+    ctx.fillStyle = light;
+    ctx.fill();
+
+    ctx.save();
+    ctx.beginPath();
+    ctx.roundRect(x + iconPadding, y + iconPadding, iconSize, iconSize, Math.max(0, iconRadius - iconPadding));
+    ctx.clip();
+    ctx.drawImage(iconImg, x + iconPadding, y + iconPadding, iconSize, iconSize);
+    ctx.restore();
+
+    if (format === 'base64') {
+        return { contentType: 'application/json', body: canvas.toDataURL('image/png') };
     }
+    return { contentType: 'image/png', body: canvas.toBuffer('image/png') };
 }

package/src/modules/v4/username.ts

@@ -1,4 +1,4 @@
-import { random, randomNumber } from './utils.js';
+import { random, randomNumber } from '../../utils/helpers.js';
 
 export default function username(): Record<string, unknown> {
     const adj = [

package/src/routes/get.ts

@@ -5,6 +5,10 @@ import { ipLimits } from '../storage/index.js';
 import { chatStorage } from '../storage/index.js';
 import { DOCS_URL, GITHUB_CACHE_TTL } from '../constants.js';
 import { error } from '../utils/response.js';
+import { since } from '../utils/helpers.js';
+import type { QRCodeOptions, QRCodeResult } from '../modules/v4/qrcode.js';
+import type { CaptchaOptions, CaptchaResult } from '../modules/v4/captcha.js';
+import type { ColorResult } from '../modules/v4/color.js';
 
 const router = Router();
 
@@ -57,7 +61,7 @@ router.get('/:version/algorithms', (req: Request, res: Response) => {
     const { version } = req.params;
 
     const algorithms = req.module.algorithms as Record<string, (v: string, v2?: string) => unknown>;
-    if (!algorithms || !algorithms[method as string]) {
+    if (!algorithms || !method || !Object.hasOwn(algorithms, method as string)) {
         error(res, 400, 'Please provide a valid algorithm (?method={algorithm})', `${version}/algorithms`);
         return;
     }
@@ -72,16 +76,29 @@ router.get('/:version/algorithms', (req: Request, res: Response) => {
 
 // Generate captcha
 router.get('/:version/captcha', (req: Request, res: Response) => {
-    const text = req.query.text as string;
-
-    if (!text) {
-        error(res, 400, 'Please provide a valid argument (?text={text})', `${req.version}/captcha`);
-        return;
-    }
-
     try {
-        const result = req.module.captcha(text);
-        res.type('png').send(result);
+        if (since(req.version, 4)) {
+            const captchaFn = req.module.captcha as (o: CaptchaOptions) => CaptchaResult;
+            const result = captchaFn({
+                text: req.query.text as string | undefined,
+                length: req.query.length ? Number(req.query.length) : undefined,
+                width: req.query.width ? Number(req.query.width) : undefined,
+                height: req.query.height ? Number(req.query.height) : undefined,
+                noise: req.query.noise as CaptchaOptions['noise'],
+                bg: req.query.bg as string | undefined,
+                color: req.query.color as string | undefined,
+            });
+            res.set('X-Captcha-Text', result.text);
+            res.type('png').send(result.body);
+        } else {
+            const text = req.query.text as string;
+            if (!text) {
+                error(res, 400, 'Please provide a valid argument (?text={text})', `${req.version}/captcha`);
+                return;
+            }
+            const result = (req.module.captcha as (t: string) => Buffer)(text);
+            res.type('png').send(result);
+        }
     } catch (err) {
         error(res, 400, (err as Error).message, `${req.version}/captcha`);
     }
@@ -108,8 +125,15 @@ router.get('/:version/chat/private', (_req: Request, res: Response) => {
 // Generate color
 router.get('/:version/color', (req: Request, res: Response) => {
     try {
-        const result = req.module.color();
-        res.jsonResponse(result);
+        if (since(req.version, 4)) {
+            const colorFn = req.module.color as (hex?: string) => ColorResult;
+            const hex = req.query.hex as string | undefined;
+            const result = colorFn(hex || undefined);
+            res.jsonResponse(result);
+        } else {
+            const result = (req.module.color as () => Record<string, string>)();
+            res.jsonResponse(result);
+        }
     } catch (err) {
         error(res, 400, (err as Error).message, `${req.version}/color`);
     }
@@ -133,8 +157,18 @@ router.get('/:version/convert', (req: Request, res: Response) => {
     }
 
     try {
-        const result = req.module.convert(value as string, from as string, to as string);
-        res.jsonResponse(result);
+        if (since(req.version, 4)) {
+            const convertFn = req.module.convert as (v: number, f: string, t: string) => Record<string, unknown>;
+            const result = convertFn(Number(value), from as string, to as string);
+            res.jsonResponse(result);
+        } else {
+            const result = (req.module.convert as (v: string, f: string, t: string) => Record<string, unknown>)(
+                value as string,
+                from as string,
+                to as string,
+            );
+            res.jsonResponse(result);
+        }
     } catch (err) {
         error(res, 400, (err as Error).message, `${req.version}/convert`);
     }
@@ -183,7 +217,7 @@ router.get('/:version/encode', (req: Request, res: Response) => {
         error(res, 404, `Endpoint not available in ${version}.`, `${version}/encode`);
         return;
     }
-    if (!method || !encode[method as string]) {
+    if (!method || !Object.hasOwn(encode, method as string)) {
         error(res, 400, 'Please provide a valid method (?method={method})', `${version}/encode`);
         return;
     }
@@ -338,8 +372,30 @@ router.get('/:version/qrcode', async (req: Request, res: Response) => {
     }
 
     try {
-        const result = await req.module.qrcode(url as string);
-        res.jsonResponse(result);
+        if (since(req.version, 4)) {
+            const qrcodeFn = req.module.qrcode as (o: QRCodeOptions) => Promise<QRCodeResult>;
+            const result = await qrcodeFn({
+                url: url as string,
+                size: req.query.size ? Number(req.query.size) : undefined,
+                margin: req.query.margin ? Number(req.query.margin) : undefined,
+                correction: req.query.correction as QRCodeOptions['correction'],
+                dark: req.query.dark as string | undefined,
+                light: req.query.light as string | undefined,
+                icon: req.query.icon as string | undefined,
+                iconSize: req.query.iconSize ? Number(req.query.iconSize) : undefined,
+                iconPadding: req.query.iconPadding ? Number(req.query.iconPadding) : undefined,
+                iconRadius: req.query.iconRadius ? Number(req.query.iconRadius) : undefined,
+                format: req.query.format as QRCodeOptions['format'],
+            });
+            if (result.contentType === 'application/json') {
+                res.jsonResponse(result.body);
+            } else {
+                res.type(result.contentType).send(result.body);
+            }
+        } else {
+            const result = await (req.module.qrcode as (u: string) => Promise<string>)(url as string);
+            res.jsonResponse(result);
+        }
     } catch (err) {
         error(res, 400, (err as Error).message, `${req.version}/qrcode`);
     }
@@ -378,7 +434,7 @@ router.get('/:version/text', (req: Request, res: Response) => {
         error(res, 404, `Endpoint not available in ${version}.`, `${version}/text`);
         return;
     }
-    if (!method || !textMod[method as string]) {
+    if (!method || !Object.hasOwn(textMod, method as string)) {
         error(res, 400, 'Please provide a valid method (?method={slug|stats|lorem|number})', `${version}/text`);
         return;
     }
@@ -415,7 +471,7 @@ router.get('/:version/validate', (req: Request, res: Response) => {
         error(res, 404, `Endpoint not available in ${version}.`, `${version}/validate`);
         return;
     }
-    if (!type || !validate[type as string]) {
+    if (!type || !Object.hasOwn(validate, type as string)) {
         error(res, 400, 'Please provide a valid type (?type={luhn|iban|email})', `${version}/validate`);
         return;
     }

package/src/routes/post.ts

@@ -2,6 +2,8 @@ import { Router, type Request, type Response } from 'express';
 import { chatStorage, ticTacToeStorage } from '../storage/index.js';
 import { MIN_TOKEN_LENGTH, MAX_TOKEN_LENGTH } from '../constants.js';
 import { error } from '../utils/response.js';
+import { since } from '../utils/helpers.js';
+import type { HashResult } from '../modules/v4/hash.js';
 
 const router = Router();
 
@@ -64,7 +66,7 @@ router.post('/:version/chat/private', (req: Request, res: Response) => {
 
 // Generate hash
 router.post('/:version/hash', (req: Request, res: Response) => {
-    const { text, method } = (req.body as Record<string, string>) || {};
+    const { text, method, encoding } = (req.body as Record<string, string>) || {};
 
     if (!text) {
         error(res, 400, 'Please provide a text (?text={text})', `${req.version}/hash`);
@@ -76,8 +78,14 @@ router.post('/:version/hash', (req: Request, res: Response) => {
     }
 
     try {
-        const result = req.module.hash(text, method);
-        res.jsonResponse(result);
+        if (since(req.version, 4)) {
+            const hashFn = req.module.hash as (t: string, m: string, e?: string) => HashResult;
+            const result = hashFn(text, method, encoding);
+            res.jsonResponse(result);
+        } else {
+            const result = (req.module.hash as (t: string, m: string) => Record<string, string>)(text, method);
+            res.jsonResponse(result);
+        }
     } catch (err) {
         error(res, 400, (err as Error).message, `${req.version}/hash`);
     }