@20syldev/api 3.3.8 → 3.4.0

package/modules/v3/personal.js

@@ -0,0 +1,127 @@
+import { random, randomNumber } from './utils.js';
+
+/**
+ * Generate random personal information
+ *
+ * @returns {Object} Comprehensive personal profile with contact info, financial data, and more
+ */
+export default function personal() {
+    const people = [
+        { name: 'John Doe', social: 'john_doe', email: 'john@example.com', country: 'US' },
+        { name: 'Jane Martin', social: 'jane_martin', email: 'jane@example.com', country: 'FR' },
+        { name: 'Michael Johnson', social: 'mike_johnson', email: 'michael@example.com', country: 'UK' },
+        { name: 'Emily Davis', social: 'emily_davis', email: 'emily@example.com', country: 'ES' },
+        { name: 'Alexis Barbos', social: 'alexis_barbos', email: 'alexis@example.com', country: 'DE' },
+        { name: 'Sarah Williams', social: 'sarah_williams', email: 'sarah@example.com', country: 'IT' },
+        { name: 'Daniel Brown', social: 'daniel_brown', email: 'daniel@example.com', country: 'JP' },
+        { name: 'Sophia Wilson', social: 'sophia_wilson', email: 'sophia@example.com', country: 'BR' },
+        { name: 'James Taylor', social: 'james_taylor', email: 'james@example.com', country: 'CA' },
+        { name: 'Olivia Thomas', social: 'olivia_thomas', email: 'olivia@example.com', country: 'AU' }
+    ];
+
+    const countries = {
+        US: { tel: '123-456-7890', code: '1', lang: 'English' },
+        FR: { tel: '06 78 90 12 34', code: '33', lang: 'French' },
+        UK: { tel: '7911 123456', code: '44', lang: 'English' },
+        ES: { tel: '678 901 234', code: '34', lang: 'Spanish' },
+        DE: { tel: '163 555 1584', code: '49', lang: 'German' },
+        IT: { tel: '345 678 9012', code: '39', lang: 'Italian' },
+        JP: { tel: '080-1234-5678', code: '81', lang: 'Japanese' },
+        BR: { tel: '(11) 98765-4321', code: '55', lang: 'Portuguese' },
+        CA: { tel: '416-123-4567', code: '1', lang: 'English' },
+        AU: { tel: '0412 345 678', code: '61', lang: 'English' }
+    };
+
+    const jobs = ['Writer', 'Artist', 'Musician', 'Explorer', 'Scientist', 'Engineer', 'Athlete', 'Doctor'];
+    const hobbies = ['Reading', 'Traveling', 'Gaming', 'Cooking', 'Fitness', 'Music', 'Photography', 'Writing'];
+    const cities = ['New York', 'Paris', 'London', 'Madrid', 'Berlin', 'Rome', 'Tokyo', 'Los Angeles', 'Sydney', 'São Paulo', 'Toronto'];
+    const streets = ['Main St', '2nd Ave', 'Broadway', 'Park Lane', 'Elm St', 'Sunset Blvd', 'Maple St', 'Highland Rd'];
+
+    const card = Array.from({ length: 4 }, () => randomNumber(1000, 9999)).join(' ');
+    const cvc = randomNumber(100, 999);
+    const expiration = `${String(randomNumber(1, 12)).padStart(2, '0')}/${(new Date().getFullYear() + randomNumber(0, 3)).toString().slice(-2)}`;
+
+    const person = random(people);
+    const social = person.social;
+    const country = person.country;
+    const phone = countries[country].tel;
+    const lang = countries[country].lang;
+
+    const age = randomNumber(18, 67);
+    const birthday = new Date(Date.now() - randomNumber(18, 67) * 365.25 * 24 * 60 * 60 * 1000).toISOString();
+
+    let emergencyContacts = [];
+    let yearIncome = randomNumber(20000, 100000);
+    let subscriptions = [];
+    let pets = [];
+    let vehicles = [];
+    let civilStatus = 'Single';
+    let children = 0;
+
+    if (age >= 21 && Math.random() > 0.7) civilStatus = 'Married';
+
+    if (civilStatus === 'Married' && age >= 25) children = randomNumber(0, 3);
+
+    while (emergencyContacts.length < randomNumber(1, 3)) {
+        let emergencyContact = random(people);
+        while (
+            emergencyContact.email === person.email ||
+            emergencyContacts.some(e => e.email === emergencyContact.email)
+        ) {
+            emergencyContact = random(people);
+        }
+        const emergencyPhone = `${randomNumber(100, 999)}-${randomNumber(100, 999)}-${randomNumber(1000, 9999)}`;
+        emergencyContacts.push({
+            name: emergencyContact.name,
+            relationship: random(['Spouse', 'Parent', 'Sibling', 'Friend']),
+            phone: `+${countries[country].code} ${emergencyPhone}`
+        });
+    }
+
+    while (subscriptions.length < randomNumber(1, 3)) {
+        let subscription = random(['Netflix', 'Spotify', 'Amazon Prime', 'Disney+', 'Hulu']);
+        if (!subscriptions.includes(subscription)) subscriptions.push(subscription);
+    }
+
+    while (pets.length < randomNumber(1, 3)) {
+        let pet = random(['Dog', 'Cat', 'Fish', 'Bird', 'None']);
+        if (!pets.includes(pet)) pets.push(pet);
+    }
+
+    while (vehicles.length < randomNumber(1, 3)) {
+        let vehicle = random(['Car', 'Bike', 'Motorcycle', 'Bus', 'None']);
+        if (!vehicles.includes(vehicle)) vehicles.push(vehicle);
+    }
+
+    return {
+        name: person.name,
+        email: person.email,
+        localisation: country,
+        phone: `+${countries[country].code} ${phone}`,
+        job: random(jobs),
+        hobbies: random(hobbies),
+        language: lang,
+        card,
+        cvc,
+        expiration,
+        address: `${randomNumber(1, 9999)} ${random(streets)}, ${random(cities)}`,
+        birthday,
+        civil_status: civilStatus,
+        children,
+        vehicle: vehicles,
+        social_profiles: {
+            twitter: `@${social}`,
+            facebook: `facebook.com/${social}`,
+            linkedin: `linkedin.com/in/${social}`,
+            instagram: `instagram.com/${social}`
+        },
+        year_income: `${yearIncome} USD/year`,
+        month_income: `${(yearIncome / 12).toFixed(2)} USD/month`,
+        education: random(['High School', 'Bachelor\'s', 'Master\'s', 'PhD']),
+        work_experience: `${randomNumber(0, 20)} years`,
+        health_status: random(['Healthy', 'Minor Issues', 'Chronic Conditions']),
+        emergency_contacts: emergencyContacts,
+        subscriptions,
+        pets,
+    };
+}

package/modules/v3/qrcode.js

@@ -0,0 +1,20 @@
+import { toDataURL } from 'qrcode';
+
+/**
+ * Generate a QR code for the provided URL.
+ *
+ * @param {string} url - The URL to encode in the QR code
+ * @returns {Promise<string>} - Base64 encoded QR code image
+ * @throws {Error} - If URL is invalid or QR code generation fails
+ */
+export default async function qrcode(url) {
+    // Input validation
+    if (!url || typeof url !== 'string') throw new Error('Please provide a valid URL');
+
+    try {
+        // Generate QR code
+        return await toDataURL(url);
+    } catch (error) {
+        throw new Error(`Failed to generate QR code: ${error.message}`);
+    }
+}

package/modules/v3/tic_tac_toe.js

@@ -0,0 +1,167 @@
+import { randomBytes } from 'crypto';
+
+/**
+ * Manages a Tic-Tac-Toe game session
+ *
+ * @param {string} action - The action to perform ('play' or 'fetch')
+ * @param {Object} params - The parameters for the action
+ * @returns {Object} - The result of the action
+ * @throws {Error} - If parameters are invalid
+ */
+export default function tic_tac_toe(action, params = {}) {
+    // In-memory storage
+    const storage = params.storage || {};
+
+    // Initialize storage
+    storage.games ??= {};
+    storage.sessions ??= {};
+    storage.rateLimits ??= {};
+
+    // Reference the storage properties
+    const { games, sessions, rateLimits } = storage;
+
+    // Input validation for common parameters
+    if (!params.username) throw new Error('Please provide a username');
+
+    const u = params.username.toLowerCase();
+    const now = Date.now();
+
+    // Rate limiting
+    rateLimits[u] = (rateLimits[u] || []).filter(ts => now - ts < 10000);
+    if (rateLimits[u].length > 50) {
+        const remainingTime = Math.ceil((rateLimits[u][0] + 10000 - now) / 1000);
+        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
+    }
+    rateLimits[u].push(now);
+
+    // Handle different actions
+    if (action === 'play') {
+        return playMove(params, games, sessions, u, now);
+    } else if (action === 'fetch') {
+        return fetchGame(params, games, u);
+    } else {
+        throw new Error('Invalid action. Use "play" or "fetch"');
+    }
+}
+
+/**
+ * Process a player's move
+ */
+function playMove(params, games, sessions, u, now) {
+    const { move, session, game } = params;
+    const validMoves = ['1-1', '1-2', '1-3', '2-1', '2-2', '2-3', '3-1', '3-2', '3-3'];
+
+    // Input validation for play action
+    if (!move) throw new Error('Please provide a valid move');
+    if (!session) throw new Error('Please provide a valid session ID');
+    if (!game) throw new Error('Please provide a valid game ID');
+    if (!validMoves.includes(move)) throw new Error('Invalid move. Please provide a valid move (e.g., 1-1, 2-2, 3-3).');
+
+    // Session validation
+    if (sessions[u] && sessions[u].user !== session) {
+        throw new Error('Session ID mismatch');
+    }
+
+    // Initialize game if needed
+    games[game] = games[game] || [];
+
+    // Check if game is full
+    const players = [...new Set(games[game].map(play => play.username))];
+    if (players.length >= 2 && !players.includes(params.username)) {
+        throw new Error('Game is full, you can only watch.');
+    }
+
+    // Check if it's player's turn
+    if (games[game].length > 0 && games[game][games[game].length - 1].username === params.username) {
+        throw new Error('Please wait for the other player to make a move.');
+    }
+
+    // Check if move is already made
+    if (games[game].some(play => play.move === move)) {
+        throw new Error('Move already made. Please choose a different move.');
+    }
+
+    // Add move to game
+    const play = { username: params.username, move, session };
+    games[game].push(play);
+
+    // Check game result
+    const result = checkGame(games[game]);
+    if (result.winner || result.tie) {
+        setTimeout(() => delete games[game], 600000);
+        return {
+            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : 'It\'s a tie.'}`,
+            ...result
+        };
+    }
+
+    // Set cleanup timeout
+    setTimeout(() => delete games[game], 3600000);
+
+    // Update session
+    sessions[u] = sessions[u] || { user: session, last: now };
+    sessions[u].last = now;
+    setTimeout(() => { if (now - sessions[u].last >= 3600000) delete sessions[u]; }, 3600000);
+
+    return { message: 'Move sent successfully' };
+}
+
+/**
+ * Fetch a game state
+ */
+function fetchGame(params, games, u) {
+    const ID = params.game || generateGameId();
+
+    // Initialize game if needed
+    if (!games[ID]) games[ID] = [];
+
+    const data = games[ID];
+    const last = data.length ? data[data.length - 1].username : null;
+    const players = [...new Set(data.map(p => p.username))];
+    const turn = players.find(p => p !== last);
+    const result = data.length ? checkGame(data) : {};
+
+    return { game: data, turn, ID, ...result };
+}
+
+/**
+ * Generate a random game ID
+ */
+function generateGameId() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    return Array.from(randomBytes(5)).map(b => chars[b % chars.length]).join('');
+}
+
+/**
+ * Check the game result
+ */
+function checkGame(moves) {
+    let board = Array(3).fill().map(() => Array(3).fill(null));
+    let playerSymbols = {};
+    let playersOrder = [];
+
+    moves.forEach(({ username, move }) => {
+        if (!playerSymbols[username]) {
+            playersOrder.push(username);
+            playerSymbols[username] = playersOrder.length === 1 ? 'X' : 'O';
+        }
+        let [row, col] = move.split('-').map(Number);
+        board[row - 1][col - 1] = playerSymbols[username];
+    });
+
+    const checkWinner = (symbol) => {
+        for (let i = 0; i < 3; i++) {
+            if (board[i][0] === symbol && board[i][1] === symbol && board[i][2] === symbol) return true;
+            if (board[0][i] === symbol && board[1][i] === symbol && board[2][i] === symbol) return true;
+        }
+        if (board[0][0] === symbol && board[1][1] === symbol && board[2][2] === symbol) return true;
+        if (board[0][2] === symbol && board[1][1] === symbol && board[2][0] === symbol) return true;
+        return false;
+    };
+
+    let winner = Object.keys(playerSymbols).find(player => checkWinner(playerSymbols[player]));
+    let isTie = !winner && moves.length === 9;
+    let loser = winner && playersOrder.length === 2 ? playersOrder.find(player => player !== winner) : null;
+
+    return { winner, loser, tie: isTie };
+}

package/modules/v3/time.js

@@ -0,0 +1,87 @@
+/**
+ * Generate time information based on specified parameters.
+ *
+ * @param {string} type - The type of time information ('live' or 'random')
+ * @param {string} start - Start date for random generation (ISO format)
+ * @param {string} end - End date for random generation (ISO format)
+ * @param {string} format - Specific time format to return
+ * @param {string} timezone - Timezone to use
+ * @returns {object} - Time information in various formats
+ * @throws {Error} - If inputs are invalid
+ */
+export default function time(type = 'live', start, end, format, timezone) {
+    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'
+    ];
+
+    // Input validation
+    if (type !== 'live' && type !== 'random') {
+        throw new Error('Please provide a valid type (live or random)');
+    }
+
+    if (start && !Date.parse(start)) {
+        throw new Error('Please provide a valid start date (YYYY-MM-DD)');
+    }
+
+    if (end && !Date.parse(end)) {
+        throw new Error('Please provide a valid end date (YYYY-MM-DD)');
+    }
+
+    if (format && !validFormats.includes(format)) {
+        throw new Error(`Please provide a valid format. Options: ${validFormats.join(', ')}`);
+    }
+
+    if (timezone && !validTimezones.includes(timezone)) {
+        throw new Error(`Please provide a valid timezone. Options: ${validTimezones.join(', ')}`);
+    }
+
+    // Helper function to get all time formats for a date
+    const getTimeFormats = (date, tz) => {
+        return {
+            iso: date.toISOString(),
+            utc: date.toUTCString(),
+            timestamp: date.getTime(),
+            locale: date.toLocaleString('en-US', { timeZone: tz, timeZoneName: 'long' }),
+            date: date.toLocaleDateString('en-US', { timeZone: tz }),
+            time: date.toLocaleTimeString('en-US', { timeZone: tz }),
+            year: date.getFullYear(),
+            month: date.getMonth() + 1,
+            day: date.getDate(),
+            hour: date.getHours(),
+            minute: date.getMinutes(),
+            second: date.getSeconds(),
+            ms: date.getMilliseconds(),
+            dayOfWeek: date.getDay(),
+            dayOfYear: Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 86400000),
+            weekNumber: Math.ceil((((date - new Date(date.getFullYear(), 0, 0)) / 86400000) + 1) / 7),
+            timezone: tz,
+            timezoneOffset: date.getTimezoneOffset()
+        };
+    };
+
+    // Generate time information based on type
+    if (type === 'random') {
+        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 formats = getTimeFormats(randomDate, tz);
+
+        return format ? { date: formats[format] } : formats;
+    }
+
+    // Live time information
+    const now = new Date();
+    const tz = timezone || 'UTC';
+    const formats = getTimeFormats(now, tz);
+
+    return format ? { date: formats[format] } : formats;
+}

package/modules/v3/token.js

@@ -0,0 +1,48 @@
+import { randomBytes } from 'crypto';
+import { v4 } from 'uuid';
+
+/**
+ * Generate a random token of specified length and type.
+ *
+ * @param {number} len - Length of the token
+ * @param {string} type - Type of token to generate
+ * @returns {string} - The generated token
+ * @throws {Error} - If inputs are invalid
+ */
+export default function token(len, type = 'alphanum') {
+    // Input validation
+    if (isNaN(len) || len < 12) {
+        throw new Error('Length must be a number greater than or equal to 12');
+    }
+
+    if (len > 4096) {
+        throw new Error('Length cannot exceed 4096');
+    }
+
+    // Helper function to generate token from character set
+    const genToken = (chars, length) => {
+        return Array.from({ length }, () => {
+            return chars[Math.floor(Math.random() * chars.length)];
+        }).join('');
+    }
+
+    // Token type definitions
+    const tokenTypes = {
+        alpha: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', len),
+        alphanum: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', len),
+        base64: () => randomBytes(Math.ceil(len * 0.75)).toString('base64').slice(0, len),
+        hex: () => randomBytes(Math.ceil(len * 0.5)).toString('hex').slice(0, len),
+        num: () => genToken('0123456789', len),
+        punct: () => genToken('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~', len),
+        urlsafe: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_', len),
+        uuid: () => v4().replace(/-/g, '').slice(0, len)
+    };
+
+    // Generate token based on type or default to alphanum
+    if (!tokenTypes[type.toLowerCase()]) {
+        throw new Error(`Invalid token type. Valid types: ${Object.keys(tokenTypes).join(', ')}`);
+    }
+
+    // Generate token based on type or default to alphanum
+    return (tokenTypes[type.toLowerCase()] || tokenTypes.alphanum)();
+}

package/modules/v3/username.js

@@ -0,0 +1,32 @@
+import { random, randomNumber } from './utils.js';
+
+/**
+ * Generate a random username with related information
+ *
+ * @returns {Object} Object containing username and component parts
+ */
+export default function username() {
+    const adj = ['Happy', 'Silly', 'Clever', 'Creative', 'Brave', 'Gentle', 'Kind', 'Funny', 'Wise', 'Charming', 'Sincere', 'Resourceful', 'Patient', 'Energetic', 'Adventurous', 'Ambitious', 'Courageous', 'Courteous', 'Determined'];
+    const ani = ['Cat', 'Dog', 'Tiger', 'Elephant', 'Monkey', 'Penguin', 'Dolphin', 'Lion', 'Bear', 'Fox', 'Owl', 'Giraffe', 'Zebra', 'Koala', 'Rabbit', 'Squirrel', 'Panda', 'Horse', 'Wolf', 'Eagle'];
+    const job = ['Writer', 'Artist', 'Musician', 'Explorer', 'Scientist', 'Engineer', 'Athlete', 'Chef', 'Doctor', 'Teacher', 'Lawyer', 'Entrepreneur', 'Actor', 'Dancer', 'Photographer', 'Architect', 'Pilot', 'Designer', 'Journalist', 'Veterinarian'];
+
+    const nombre = randomNumber(0, 99);
+    const choix = {
+        adj_num: () => random(adj) + nombre,
+        ani_num: () => random(ani) + nombre,
+        pro_num: () => random(job) + nombre,
+        adj_ani: () => random(adj) + random(ani),
+        adj_ani_num: () => random(adj) + random(ani) + nombre,
+        adj_pro: () => random(adj) + random(job),
+        pro_ani: () => random(job) + random(ani),
+        pro_ani_num: () => random(job) + random(ani) + nombre
+    };
+
+    return {
+        username: choix[random(Object.keys(choix))](),
+        number: nombre,
+        adjective: random(adj),
+        animal: random(ani),
+        job: random(job)
+    };
+}

package/modules/v3/utils.js

@@ -0,0 +1,66 @@
+/**
+ * Shared utility functions for the API modules
+ */
+
+/**
+ * Return a random element from an array.
+ *
+ * @param {Array} arr - The array to choose from.
+ * @returns {*} - A random element from the array.
+ */
+export function random(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * Return a random number between min and max (inclusive).
+ *
+ * @param {number} min - The minimum number.
+ * @param {number} max - The maximum number.
+ * @returns {number} - A random number between min and max.
+ */
+export function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * Generate a random IP address.
+ *
+ * @returns {string} - A random IP address in the format "X.X.X.X".
+ */
+export function genIP() {
+    return `${randomNumber(0, 255)}.${randomNumber(0, 255)}.${randomNumber(0, 255)}.${randomNumber(0, 255)}`;
+}
+
+/**
+ * Format a JavaScript Date object to ISO format without timezone.
+ *
+ * @param {Date} date - Date object to format
+ * @returns {string} - Formatted date string
+ */
+export function formatDate(date) {
+    return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().replace('Z', '');
+}
+
+/**
+ * Manage rate limiting for users
+ *
+ * @param {Object} rateLimits - Rate limits object
+ * @param {string} userId - User ID
+ * @param {number} timestamp - Current timestamp
+ * @param {number} window - Time window in milliseconds
+ * @param {number} limit - Maximum requests in window
+ * @returns {boolean} - True if rate limit is exceeded
+ * @throws {Error} - If rate limit is exceeded
+ */
+export function checkRateLimit(rateLimits, userId, timestamp, window = 10000, limit = 50) {
+    rateLimits[userId] = (rateLimits[userId] || []).filter(ts => timestamp - ts < window);
+
+    if (rateLimits[userId].length > limit) {
+        const remainingTime = Math.ceil((rateLimits[userId][0] + window - timestamp) / 1000);
+        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
+    }
+
+    rateLimits[userId].push(timestamp);
+    return false;
+}

package/modules/v3.js

@@ -0,0 +1,15 @@
+export * as algorithms from './v3/algorithms.js';
+export { default as chat } from './v3/chat.js';
+export { default as captcha } from './v3/captcha.js';
+export { default as color } from './v3/color.js';
+export { default as convert } from './v3/convert.js';
+export { default as domain } from './v3/domain.js';
+export { default as hash } from './v3/hash.js';
+export { default as hyperplanning } from './v3/hyperplanning.js';
+export { default as levenshtein } from './v3/levenshtein.js';
+export { default as personal } from './v3/personal.js';
+export { default as qrcode } from './v3/qrcode.js';
+export { default as tic_tac_toe } from './v3/tic_tac_toe.js';
+export { default as time } from './v3/time.js';
+export { default as token } from './v3/token.js';
+export { default as username } from './v3/username.js';

package/package.json

@@ -1,49 +1,53 @@
-{
-    "version": "3.3.8",
-    "name": "@20syldev/api",
-    "description": "Node.js API with multiple features. Check the documentation at https://docs.sylvain.pro",
-    "main": "app.js",
-    "type": "module",
-    "scripts": {
-        "start": "node app.js",
-        "dev": "nodemon app.js",
-        "build": "npm install && node app.js",
-        "lint": "prettier --write .",
-        "upgrade:minor": "npm upgrade",
-        "upgrade:major": "npx npm-check-updates -u && npm install",
-        "upgrade:build": "npm upgrade && npm install && node app.js"
-    },
-    "dependencies": {
-        "canvas": "latest",
-        "cors": "latest",
-        "dotenv": "latest",
-        "express": "latest",
-        "ical.js": "latest",
-        "mathjs": "latest",
-        "node-fetch": "latest",
-        "qrcode": "latest",
-        "random": "latest",
-        "uuid": "latest"
-    },
-    "devDependencies": {
-        "nodemon": "latest",
-        "npm-check-updates": "latest",
-        "prettier": "latest"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/20syldev/api.git"
-    },
-    "keywords": [
-        "api",
-        "express",
-        "utility",
-        "math"
-    ],
-    "author": "Sylvain L.",
-    "license": "BSD 3-Clause",
-    "bugs": {
-        "url": "https://github.com/20syldev/api/issues"
-    },
-    "homepage": "https://api.sylvain.pro"
-}
+{
+    "version": "3.4.0",
+    "name": "@20syldev/api",
+    "description": "Node.js API with multiple features. Check the documentation at https://docs.sylvain.pro",
+    "main": "app.js",
+    "type": "module",
+    "scripts": {
+        "start": "node app.js",
+        "dev": "nodemon app.js",
+        "build": "npm install && node app.js",
+        "lint": "prettier --write .",
+        "upgrade:minor": "npm upgrade",
+        "upgrade:major": "npx npm-check-updates -u && npm install",
+        "upgrade:build": "npm upgrade && npm install && node app.js"
+    },
+    "exports": {
+        "./v1": "./modules/v1.js",
+        "./v2": "./modules/v2.js",
+        "./v3": "./modules/v3.js"
+    },
+    "dependencies": {
+        "canvas": "latest",
+        "cors": "latest",
+        "dotenv": "latest",
+        "express": "latest",
+        "ical.js": "latest",
+        "node-fetch": "latest",
+        "qrcode": "latest",
+        "random": "latest",
+        "uuid": "latest"
+    },
+    "devDependencies": {
+        "nodemon": "latest",
+        "npm-check-updates": "latest",
+        "prettier": "latest"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/20syldev/api.git"
+    },
+    "keywords": [
+        "api",
+        "express",
+        "utility",
+        "math"
+    ],
+    "author": "Sylvain L.",
+    "license": "BSD 3-Clause",
+    "bugs": {
+        "url": "https://github.com/20syldev/api/issues"
+    },
+    "homepage": "https://api.sylvain.pro"
+}