@20syldev/api 4.7.0 → 4.9.0

package/src/modules/v4/convert.ts

@@ -1,127 +0,0 @@
-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: (v) => (v * 9) / 5 + 32,
-        kelvin: (v) => v + 273.15,
-    },
-    fahrenheit: {
-        celsius: (v) => ((v - 32) * 5) / 9,
-        kelvin: (v) => ((v - 32) * 5) / 9 + 273.15,
-    },
-    kelvin: {
-        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 },
-};
-
-/**
- * Converts a numeric value from one unit to another.
- *
- * @param value - The numeric value to convert
- * @param from - The source unit (e.g. "km", "celsius", "kg")
- * @param to - The target unit (e.g. "mi", "fahrenheit", "lb")
- * @returns Object with source unit, target unit, original value, and converted result
- * @throws Error if the conversion pair is unsupported, the value is NaN, or the temperature is below absolute zero
- */
-export default function convert(
-    value: number,
-    from: string,
-    to: string,
-): { from: string; to: string; value: number; result: number } {
-    const fromKey = from.toLowerCase();
-    const toKey = to.toLowerCase();
-    const convertFn = conversions[fromKey]?.[toKey];
-
-    if (!convertFn) throw new Error('Invalid conversion unit');
-    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/dice.ts

@@ -1,46 +0,0 @@
-export interface DiceResult {
-    roll: string;
-    count: number;
-    sides: number;
-    modifier: number;
-    results: number[];
-    total: number;
-}
-
-/**
- * Rolls dice using standard tabletop notation and returns individual results with a total.
- *
- * @param roll - Dice notation string (e.g. "2d6+3", "d20", "4d8-1")
- * @returns Roll breakdown including count, sides, modifier, individual results, and total
- * @throws Error if the notation is missing, invalid, or out of bounds
- */
-export default function dice(roll: string): DiceResult {
-    if (!roll) throw new Error('A roll notation is required (e.g. 2d6+3)');
-    if (typeof roll !== 'string') throw new Error('Roll must be a string');
-
-    const match = /^(\d*)d(\d+)([+-]\d+)?$/i.exec(roll.trim().replace(/\s+/g, '+'));
-    if (!match) throw new Error('Invalid notation. Use NdX or NdX+M (e.g. 2d6+3)');
-
-    const count = match[1] ? parseInt(match[1], 10) : 1;
-    const sides = parseInt(match[2]!, 10);
-    const modifier = match[3] ? parseInt(match[3], 10) : 0;
-
-    if (count < 1 || count > 100) throw new Error('Number of dice must be between 1 and 100');
-    if (sides < 2 || sides > 1000) throw new Error('Number of sides must be between 2 and 1000');
-
-    const results: number[] = [];
-    for (let i = 0; i < count; i++) {
-        results.push(1 + Math.floor(Math.random() * sides));
-    }
-
-    const total = results.reduce((a, b) => a + b, 0) + modifier;
-
-    return {
-        roll: `${count}d${sides}${modifier ? (modifier > 0 ? `+${modifier}` : modifier) : ''}`,
-        count,
-        sides,
-        modifier,
-        results,
-        total,
-    };
-}

package/src/modules/v4/domain.ts

@@ -1,86 +0,0 @@
-import { genIP, random } from '../../utils/helpers.js';
-
-/**
- * Generates a randomized fictional domain profile with metadata.
- *
- * @returns Object containing domain name, IP addresses, DNS info, SEO score, and other domain attributes
- */
-export default function domain(): Record<string, unknown> {
-    const subdomains = [
-        'fr.',
-        'en.',
-        'docs.',
-        'api.',
-        'projects.',
-        'app.',
-        'web.',
-        'info.',
-        'dev.',
-        'shop.',
-        'blog.',
-        'support.',
-        'mail.',
-        'forum.',
-    ];
-    const domains = [
-        'example',
-        'site',
-        'test',
-        'demo',
-        'page',
-        'store',
-        'portfolio',
-        'platform',
-        'hub',
-        'network',
-        'service',
-        'cloud',
-        'solutions',
-        'company',
-    ];
-    const tlds = [
-        '.com',
-        '.fr',
-        '.eu',
-        '.dev',
-        '.net',
-        '.org',
-        '.io',
-        '.tech',
-        '.biz',
-        '.info',
-        '.co',
-        '.app',
-        '.store',
-        '.online',
-        '.shop',
-        '.tv',
-    ];
-
-    const domainName = `${random(domains)}${random(tlds)}`;
-    const fulldomain = `${random(subdomains)}${domainName}`;
-
-    const ips = Array.from({ length: Math.floor(Math.random() * 3) + 1 }, genIP);
-    const dns = Array.from({ length: Math.floor(Math.random() * 5) + 1 }, genIP);
-
-    return {
-        domain: domainName,
-        full_domain: fulldomain,
-        ip_address: ips,
-        ssl_certified: Math.random() > 0.5,
-        hosting_provider: random(['AWS', 'Bluehost', 'DigitalOcean', 'GitHub', 'HostGator', 'Render', 'SiteGround']),
-        dns_servers: dns,
-        dns_provider: random(['AWS Route 53', 'Cloudflare', 'GoDaddy', 'Google DNS', 'Namecheap']),
-        traffic: `${Math.floor(Math.random() * 10000)} visits/day`,
-        seo_score: Math.floor(Math.random() * 100),
-        page_rank: Math.floor(Math.random() * 10),
-        country: random(['Australia', 'Canada', 'France', 'Germany', 'India', 'Japan', 'UK', 'USA']),
-        website_type: random(['Blog', 'Community', 'Corporate', 'Educational', 'E-commerce', 'Personal', 'Portfolio']),
-        random_name: domainName.split('.')[0],
-        random_subdomain: fulldomain.split('.')[0],
-        random_tld: domainName.split('.').pop(),
-        backlinks_count: Math.floor(Math.random() * 1000),
-        creation_date: new Date(Date.now() - Math.floor(Math.random() * 10000000000)).toISOString(),
-        expiration_date: new Date(Date.now() + Math.floor(Math.random() * 10000000000)).toISOString(),
-    };
-}

package/src/modules/v4/encode.ts

@@ -1,241 +0,0 @@
-import { MAX_STRING_LENGTH } from '../../constants.js';
-
-const MORSE_TABLE: Record<string, string> = {
-    A: '.-',
-    B: '-...',
-    C: '-.-.',
-    D: '-..',
-    E: '.',
-    F: '..-.',
-    G: '--.',
-    H: '....',
-    I: '..',
-    J: '.---',
-    K: '-.-',
-    L: '.-..',
-    M: '--',
-    N: '-.',
-    O: '---',
-    P: '.--.',
-    Q: '--.-',
-    R: '.-.',
-    S: '...',
-    T: '-',
-    U: '..-',
-    V: '...-',
-    W: '.--',
-    X: '-..-',
-    Y: '-.--',
-    Z: '--..',
-    '0': '-----',
-    '1': '.----',
-    '2': '..---',
-    '3': '...--',
-    '4': '....-',
-    '5': '.....',
-    '6': '-....',
-    '7': '--...',
-    '8': '---..',
-    '9': '----.',
-    '.': '.-.-.-',
-    ',': '--..--',
-    '?': '..--..',
-    "'": '.----.',
-    '!': '-.-.--',
-    '/': '-..-.',
-    '(': '-.--.',
-    ')': '-.--.-',
-    '&': '.-...',
-    ':': '---...',
-    ';': '-.-.-.',
-    '=': '-...-',
-    '+': '.-.-.',
-    '-': '-....-',
-    _: '..--.-',
-    '"': '.-..-.',
-    $: '...-..-',
-    '@': '.--.-.',
-};
-
-const MORSE_REVERSE: Record<string, string> = Object.fromEntries(Object.entries(MORSE_TABLE).map(([k, v]) => [v, k]));
-
-function checkText(value: string): void {
-    if (!value) throw new Error('A value is required');
-    if (typeof value !== 'string') throw new Error('Value must be a string');
-    if (value.length > MAX_STRING_LENGTH)
-        throw new Error(`Value must be less than ${MAX_STRING_LENGTH} characters long`);
-}
-
-/**
- * Encodes a UTF-8 string to Base64.
- *
- * @param value - The string to encode
- * @returns Base64-encoded string
- * @throws Error if value is missing, not a string, or too long
- */
-export function base64encode(value: string): string {
-    checkText(value);
-    return Buffer.from(value, 'utf-8').toString('base64');
-}
-
-/**
- * Decodes a Base64 string to UTF-8.
- *
- * @param value - The Base64 string to decode
- * @returns Decoded UTF-8 string
- * @throws Error if value is missing, not valid Base64, or too long
- */
-export function base64decode(value: string): string {
-    checkText(value);
-    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value)) throw new Error('Invalid Base64 string');
-    return Buffer.from(value, 'base64').toString('utf-8');
-}
-
-/**
- * Percent-encodes a string for safe use in a URL.
- *
- * @param value - The string to encode
- * @returns URL-encoded string
- * @throws Error if value is missing, not a string, or too long
- */
-export function urlencode(value: string): string {
-    checkText(value);
-    return encodeURIComponent(value);
-}
-
-/**
- * Decodes a percent-encoded URL string.
- *
- * @param value - The URL-encoded string to decode
- * @returns Decoded string
- * @throws Error if value is missing, not a valid URL-encoded string, or too long
- */
-export function urldecode(value: string): string {
-    checkText(value);
-    try {
-        return decodeURIComponent(value);
-    } catch {
-        throw new Error('Invalid URL-encoded string');
-    }
-}
-
-/**
- * Converts a plain text string to Morse code.
- *
- * @param value - The text to encode in Morse code
- * @returns Morse code string where letters are separated by spaces and words by " / "
- * @throws Error if value contains unsupported characters or is too long
- */
-export function morse(value: string): string {
-    checkText(value);
-    return value
-        .toUpperCase()
-        .split(' ')
-        .map((word) =>
-            word
-                .split('')
-                .map((c) => {
-                    if (c === '\n' || c === '\t') return '';
-                    const code = MORSE_TABLE[c];
-                    if (!code) throw new Error(`Unsupported character in Morse code: '${c}'`);
-                    return code;
-                })
-                .filter(Boolean)
-                .join(' '),
-        )
-        .join(' / ');
-}
-
-/**
- * Converts a Morse code string back to plain text.
- *
- * @param value - Morse code string (letters separated by spaces, words by " / ")
- * @returns Decoded plain text string
- * @throws Error if the Morse code contains an unrecognized sequence or is too long
- */
-export function unmorse(value: string): string {
-    checkText(value);
-    return value
-        .split(' / ')
-        .map((word) =>
-            word
-                .split(' ')
-                .map((code) => {
-                    if (!code) return '';
-                    const char = MORSE_REVERSE[code];
-                    if (!char) throw new Error(`Unsupported Morse sequence: '${code}'`);
-                    return char;
-                })
-                .join(''),
-        )
-        .join(' ');
-}
-
-/**
- * Applies the ROT13 substitution cipher to a string.
- *
- * @param value - The string to encode
- * @returns ROT13-encoded string (applying it twice restores the original)
- * @throws Error if value is missing, not a string, or too long
- */
-export function rot13(value: string): string {
-    checkText(value);
-    return value.replace(/[a-zA-Z]/g, (c) => {
-        const base = c <= 'Z' ? 65 : 97;
-        return String.fromCharCode(((c.charCodeAt(0) - base + 13) % 26) + base);
-    });
-}
-
-/**
- * Applies the Caesar cipher by shifting alphabetic characters by a given amount.
- *
- * @param value - The string to encode
- * @param shift - Number of positions to shift (can be negative for left shift)
- * @returns Caesar-shifted string
- * @throws Error if value is missing or shift is not a number
- */
-export function caesar(value: string, shift: string): string {
-    checkText(value);
-    const n = Number(shift);
-    if (isNaN(n)) throw new Error('Shift must be a number');
-    const s = ((n % 26) + 26) % 26;
-    return value.replace(/[a-zA-Z]/g, (c) => {
-        const base = c <= 'Z' ? 65 : 97;
-        return String.fromCharCode(((c.charCodeAt(0) - base + s) % 26) + base);
-    });
-}
-
-/**
- * Converts a string to its binary representation, one byte per character.
- *
- * @param value - The string to convert
- * @returns Space-separated 8-bit binary groups (one per character)
- * @throws Error if value is missing, not a string, or too long
- */
-export function binary(value: string): string {
-    checkText(value);
-    return value
-        .split('')
-        .map((c) => c.charCodeAt(0).toString(2).padStart(8, '0'))
-        .join(' ');
-}
-
-/**
- * Converts a binary string back to plain text.
- *
- * @param value - Space-separated 8-bit binary groups
- * @returns Decoded string
- * @throws Error if value contains non-binary characters or groups are not 8 bits wide
- */
-export function unbinary(value: string): string {
-    checkText(value);
-    if (!/^[01\s]+$/.test(value)) throw new Error('Invalid binary string');
-    return value
-        .trim()
-        .split(/\s+/)
-        .map((b) => {
-            if (b.length !== 8) throw new Error('Each binary group must contain 8 bits');
-            return String.fromCharCode(parseInt(b, 2));
-        })
-        .join('');
-}

package/src/modules/v4/geo.ts

@@ -1,63 +0,0 @@
-export interface GeoResult {
-    distance: { km: number; miles: number; nauticalMiles: number };
-    bearing: { degrees: number; cardinal: string };
-    from: { lat: number; lon: number };
-    to: { lat: number; lon: number };
-}
-
-const EARTH_RADIUS_KM = 6371;
-const CARDINALS = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
-
-function toRad(deg: number): number {
-    return (deg * Math.PI) / 180;
-}
-
-function toDeg(rad: number): number {
-    return (rad * 180) / Math.PI;
-}
-
-function parseCoord(value: string, name: string, min: number, max: number): number {
-    const n = Number(value);
-    if (isNaN(n)) throw new Error(`${name} must be a number`);
-    if (n < min || n > max) throw new Error(`${name} must be between ${min} and ${max}`);
-    return n;
-}
-
-/**
- * Calculates the great-circle distance and bearing between two geographic coordinates.
- *
- * @param lat1 - Latitude of the first point (-90 to 90)
- * @param lon1 - Longitude of the first point (-180 to 180)
- * @param lat2 - Latitude of the second point (-90 to 90)
- * @param lon2 - Longitude of the second point (-180 to 180)
- * @returns Distance in km/miles/nautical miles, compass bearing, and both coordinates
- * @throws Error if any coordinate is out of range or not a number
- */
-export default function geo(lat1: string, lon1: string, lat2: string, lon2: string): GeoResult {
-    const a = parseCoord(lat1, 'lat1', -90, 90);
-    const b = parseCoord(lon1, 'lon1', -180, 180);
-    const c = parseCoord(lat2, 'lat2', -90, 90);
-    const d = parseCoord(lon2, 'lon2', -180, 180);
-
-    const dLat = toRad(c - a);
-    const dLon = toRad(d - b);
-    const sa = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a)) * Math.cos(toRad(c)) * Math.sin(dLon / 2) ** 2;
-    const distance = 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(sa));
-
-    const y = Math.sin(toRad(d - b)) * Math.cos(toRad(c));
-    const x =
-        Math.cos(toRad(a)) * Math.sin(toRad(c)) - Math.sin(toRad(a)) * Math.cos(toRad(c)) * Math.cos(toRad(d - b));
-    const bearing = (toDeg(Math.atan2(y, x)) + 360) % 360;
-    const cardinal = CARDINALS[Math.round(bearing / 22.5) % 16]!;
-
-    return {
-        distance: {
-            km: +distance.toFixed(3),
-            miles: +(distance * 0.621371).toFixed(3),
-            nauticalMiles: +(distance * 0.539957).toFixed(3),
-        },
-        bearing: { degrees: +bearing.toFixed(2), cardinal },
-        from: { lat: a, lon: b },
-        to: { lat: c, lon: d },
-    };
-}

package/src/modules/v4/hash.ts

@@ -1,32 +0,0 @@
-import { createHash, getHashes } from 'crypto';
-
-export interface HashResult {
-    method: string;
-    hash: string;
-    encoding: string;
-}
-
-const ENCODINGS = new Set(['hex', 'base64']);
-
-/**
- * Hashes a text string using the specified algorithm and encoding.
- *
- * @param text - The text to hash
- * @param method - Hashing algorithm (e.g. "sha256", "md5")
- * @param encoding - Output encoding: "hex" (default) or "base64"
- * @returns Object containing the method, hash result, and encoding used
- * @throws Error if text is missing, the method is unsupported, or the encoding is invalid
- */
-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)) 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(encoding as 'hex' | 'base64');
-    return { method, hash: result, encoding };
-}

package/src/modules/v4/hyperplanning.ts

@@ -1,93 +0,0 @@
-import ical from 'ical.js';
-
-import { formatDate } from '../../utils/helpers.js';
-
-interface CalendarEvent {
-    summary: string[] | string;
-    subject?: string;
-    teacher?: string;
-    classes?: string[];
-    type?: string;
-    start: string;
-    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;
-}
-
-/**
- * Fetches and parses an ICS calendar from a Hyperplanning URL, filtering out past events.
- *
- * @param url - HTTPS URL to the ICS calendar
- * @param detail - Level of detail: "full" (subject/teacher/classes), "list" (summary/times), or default (summary only)
- * @returns Array of calendar events sorted by start time, excluding past events
- * @throws Error if the URL is invalid, uses HTTP, points to a private host, or does not return a valid ICS file
- */
-export default async function hyperplanning(url: string, detail?: string): Promise<CalendarEvent[]> {
-    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.');
-    }
-
-    const events: CalendarEvent[] = new ical.Component(ical.parse(await response.text()))
-        .getAllSubcomponents('vevent')
-        .map((e: ical.Component) => {
-            const evt = new ical.Event(e);
-            const summary = (evt.summary || '').split(' ').filter((part: string) => part !== '-');
-            const start = formatDate(evt.startDate.toJSDate());
-            const end = formatDate(evt.endDate.toJSDate());
-
-            if (detail === 'full') {
-                const desc = (evt.description || '').split('\n').map((l: string) => l.trim());
-                const extract = (p: string) => (desc.find((l: string) => l.startsWith(p)) || '').replace(p, '').trim();
-
-                return {
-                    summary,
-                    subject: extract('Matière :'),
-                    teacher: extract('Enseignant :'),
-                    classes: extract('Promotions :')
-                        .split(', ')
-                        .map((c: string) => c.trim()),
-                    type: extract('Salle :') || undefined,
-                    start,
-                    end,
-                };
-            }
-
-            if (detail === 'list') return { summary, start, end };
-
-            return {
-                summary: evt.summary || '',
-                start,
-                end,
-            };
-        })
-        .sort((a: CalendarEvent, b: CalendarEvent) => new Date(a.start).getTime() - new Date(b.start).getTime())
-        .filter((e: CalendarEvent) => new Date(e.end) >= new Date());
-
-    return events;
-}