@20syldev/api 3.4.3 → 3.4.5

package/modules/v3/algorithms.js

@@ -1,218 +1,218 @@
-/**
- * Check if two strings are anagrams of each other
- *
- * @param {string} value - First string to compare
- * @param {string} value2 - Second string to compare
- * @returns {boolean} - True if strings are anagrams, false otherwise
- * @throws {Error} - If inputs are invalid
- */
-export function anagram(value, value2) {
-    if (!value) throw new Error('First value is required');
-    if (!value2) throw new Error('Second value is required');
-
-    if (typeof value !== 'string') throw new Error('First value must be a string');
-    if (typeof value2 !== 'string') throw new Error('Second value must be a string');
-
-    if (value.length < 2) throw new Error('First value must be at least two characters long');
-    if (value.length > 1000) throw new Error('First value must be less than 1000 characters long');
-
-    if (value2.length < 2) throw new Error('Second value must be at least two characters long');
-    if (value2.length > 1000) throw new Error('Second value must be less than 1000 characters long');
-
-    return value.split('').sort().join('') === value2.split('').sort().join('');
-}
-
-/**
- * Sort an array using bubble sort algorithm
- *
- * @param {string} value - Comma-separated list of numbers
- * @returns {number[]} - Sorted array of numbers
- * @throws {Error} - If input is invalid
- */
-export function bubblesort(value) {
-    if (!value) throw new Error('A value is required');
-
-    if (typeof value !== 'string') throw new Error('Value must be a string');
-
-    const arr = value.split(',').map(Number);
-
-    if (arr.some(isNaN)) throw new Error('Array must contain only numbers');
-    if (arr.length < 2) throw new Error('Array must contain at least two numbers');
-    if (arr.length > 1000) throw new Error('Array must contain less than 1000 numbers');
-
-    for (let i = 0; i < arr.length - 1; i++) {
-        for (let j = 0; j < arr.length - i - 1; j++) {
-            if (arr[j] > arr[j + 1]) [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
-        }
-    }
-
-    return arr;
-}
-
-/**
- * Calculate the factorial of a number
- *
- * @param {number} value - Number to calculate factorial for
- * @returns {number} - Factorial result
- * @throws {Error} - If input is invalid or out of range
- */
-export function factorial(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 0) throw new Error('Number must be positive');
-    if (value > 170) throw new Error('Number must be between 0 and 170');
-
-    return value <= 1 ? 1 : value * factorial(value - 1);
-}
-
-/**
- * Generate a Fibonacci sequence up to the specified length
- *
- * @param {number} value - Length of Fibonacci sequence to generate
- * @returns {number[]} - Array of Fibonacci numbers
- * @throws {Error} - If input is invalid or out of range
- */
-export function fibonacci(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 0) throw new Error('Number must be positive');
-    if (value > 1000) throw new Error('Number must be between 0 and 1000');
-
-    let fib = [0, 1];
-
-    for (let i = 2; i < parseInt(value); i++) {
-        fib.push(fib[i - 1] + fib[i - 2]);
-    }
-
-    return fib.slice(0, parseInt(value));
-}
-
-/**
- * Calculate the greatest common divisor (GCD) of two numbers
- *
- * @param {number} value - First number
- * @param {number} value2 - Second number
- * @returns {number} - Greatest common divisor
- * @throws {Error} - If inputs are invalid or out of range
- */
-export function gcd(value, value2) {
-    if (isNaN(value)) throw new Error('First value must be a number');
-    if (isNaN(value2)) throw new Error('Second value must be a number');
-
-    if (value <= 0) throw new Error('First number must be strictly positive');
-    if (value2 <= 0) throw new Error('Second number must be strictly positive');
-
-    if (value > 100000) throw new Error('First number must be between 0 and 100000');
-    if (value2 > 100000) throw new Error('Second number must be between 0 and 100000');
-
-    value = Math.abs(value);
-    value2 = Math.abs(value2);
-
-    while (value2) [value, value2] = [value2, value % value2];
-
-    return value;
-}
-
-/**
- * Check if a number is prime
- *
- * @param {number} value - Number to check
- * @returns {boolean} - True if the number is prime, false otherwise
- * @throws {Error} - If input is invalid or out of range
- */
-export function isprime(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 1) throw new Error('Number must be positive');
-    if (value > 100000) throw new Error('Number must be between 1 and 100000');
-
-    for (let i = 2; i <= Math.sqrt(value); i++) {
-        if (value % i === 0) return false;
-    }
-
-    return true;
-}
-
-/**
- * Check if a string is a palindrome
- *
- * @param {string} value - String to check
- * @returns {boolean} - True if the string is a palindrome, false otherwise
- * @throws {Error} - If input is invalid
- */
-export function palindrome(value) {
-    if (!value) throw new Error('A value is required');
-
-    if (typeof value !== 'string') throw new Error('Value must be a string');
-
-    if (value.length < 2) throw new Error('Value must be at least two characters long');
-    if (value.length > 1000) throw new Error('Value must be less than 1000 characters long');
-
-    return value === value.split('').reverse().join('');
-}
-
-/**
- * Find all prime factors of a number
- *
- * @param {number} value - Number to factorize
- * @returns {number[]} - Array of prime factors
- * @throws {Error} - If input is invalid or out of range
- */
-export function primefactors(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 2) throw new Error('Number must be positive and greater than 1');
-    if (value > 100000) throw new Error('Number must be between 2 and 100000');
-
-    const factors = [];
-
-    for (let i = 2; i <= value; i++) {
-        while (value % i === 0) {
-            factors.push(i);
-            value /= i;
-        }
-    }
-
-    return factors;
-}
-
-/**
- * Generate a list of all prime numbers up to the specified limit
- *
- * @param {number} value - Upper limit to check for primes
- * @returns {number[]} - Array of prime numbers
- * @throws {Error} - If input is invalid or out of range
- */
-export function primelist(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 2) throw new Error('Number must be positive and greater than 1');
-    if (value > 10000) throw new Error('Number must be between 2 and 10000');
-
-    const primes = [];
-
-    for (let i = 2; i <= value; i++) {
-        let isPrime = true;
-
-        for (let j = 2; j <= Math.sqrt(i); j++) {
-            if (i % j === 0) {
-                isPrime = false;
-                break;
-            }
-        }
-
-        if (isPrime) primes.push(i);
-    }
-
-    return primes;
-}
-
-/**
- * Reverse a string
- *
- * @param {string} value - String to reverse
- * @returns {string} - Reversed string
- * @throws {Error} - If input is invalid
- */
-export function reverse(value) {
-    if (!value) throw new Error('A value is required');
-
-    if (typeof value !== 'string') throw new Error('Value must be a string');
-
-    return value.split('').reverse().join('');
+/**
+ * Check if two strings are anagrams of each other
+ *
+ * @param {string} value - First string to compare
+ * @param {string} value2 - Second string to compare
+ * @returns {boolean} - True if strings are anagrams, false otherwise
+ * @throws {Error} - If inputs are invalid
+ */
+export function anagram(value, value2) {
+    if (!value) throw new Error('First value is required');
+    if (!value2) throw new Error('Second value is required');
+
+    if (typeof value !== 'string') throw new Error('First value must be a string');
+    if (typeof value2 !== 'string') throw new Error('Second value must be a string');
+
+    if (value.length < 2) throw new Error('First value must be at least two characters long');
+    if (value.length > 1000) throw new Error('First value must be less than 1000 characters long');
+
+    if (value2.length < 2) throw new Error('Second value must be at least two characters long');
+    if (value2.length > 1000) throw new Error('Second value must be less than 1000 characters long');
+
+    return value.split('').sort().join('') === value2.split('').sort().join('');
+}
+
+/**
+ * Sort an array using bubble sort algorithm
+ *
+ * @param {string} value - Comma-separated list of numbers
+ * @returns {number[]} - Sorted array of numbers
+ * @throws {Error} - If input is invalid
+ */
+export function bubblesort(value) {
+    if (!value) throw new Error('A value is required');
+
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+
+    const arr = value.split(',').map(Number);
+
+    if (arr.some(isNaN)) throw new Error('Array must contain only numbers');
+    if (arr.length < 2) throw new Error('Array must contain at least two numbers');
+    if (arr.length > 1000) throw new Error('Array must contain less than 1000 numbers');
+
+    for (let i = 0; i < arr.length - 1; i++) {
+        for (let j = 0; j < arr.length - i - 1; j++) {
+            if (arr[j] > arr[j + 1]) [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
+        }
+    }
+
+    return arr;
+}
+
+/**
+ * Calculate the factorial of a number
+ *
+ * @param {number} value - Number to calculate factorial for
+ * @returns {number} - Factorial result
+ * @throws {Error} - If input is invalid or out of range
+ */
+export function factorial(value) {
+    if (isNaN(value)) throw new Error('Value must be a number');
+    if (value < 0) throw new Error('Number must be positive');
+    if (value > 170) throw new Error('Number must be between 0 and 170');
+
+    return value <= 1 ? 1 : value * factorial(value - 1);
+}
+
+/**
+ * Generate a Fibonacci sequence up to the specified length
+ *
+ * @param {number} value - Length of Fibonacci sequence to generate
+ * @returns {number[]} - Array of Fibonacci numbers
+ * @throws {Error} - If input is invalid or out of range
+ */
+export function fibonacci(value) {
+    if (isNaN(value)) throw new Error('Value must be a number');
+    if (value < 0) throw new Error('Number must be positive');
+    if (value > 1000) throw new Error('Number must be between 0 and 1000');
+
+    let fib = [0, 1];
+
+    for (let i = 2; i < parseInt(value); i++) {
+        fib.push(fib[i - 1] + fib[i - 2]);
+    }
+
+    return fib.slice(0, parseInt(value));
+}
+
+/**
+ * Calculate the greatest common divisor (GCD) of two numbers
+ *
+ * @param {number} value - First number
+ * @param {number} value2 - Second number
+ * @returns {number} - Greatest common divisor
+ * @throws {Error} - If inputs are invalid or out of range
+ */
+export function gcd(value, value2) {
+    if (isNaN(value)) throw new Error('First value must be a number');
+    if (isNaN(value2)) throw new Error('Second value must be a number');
+
+    if (value <= 0) throw new Error('First number must be strictly positive');
+    if (value2 <= 0) throw new Error('Second number must be strictly positive');
+
+    if (value > 100000) throw new Error('First number must be between 0 and 100000');
+    if (value2 > 100000) throw new Error('Second number must be between 0 and 100000');
+
+    value = Math.abs(value);
+    value2 = Math.abs(value2);
+
+    while (value2) [value, value2] = [value2, value % value2];
+
+    return value;
+}
+
+/**
+ * Check if a number is prime
+ *
+ * @param {number} value - Number to check
+ * @returns {boolean} - True if the number is prime, false otherwise
+ * @throws {Error} - If input is invalid or out of range
+ */
+export function isprime(value) {
+    if (isNaN(value)) throw new Error('Value must be a number');
+    if (value < 1) throw new Error('Number must be positive');
+    if (value > 100000) throw new Error('Number must be between 1 and 100000');
+
+    for (let i = 2; i <= Math.sqrt(value); i++) {
+        if (value % i === 0) return false;
+    }
+
+    return true;
+}
+
+/**
+ * Check if a string is a palindrome
+ *
+ * @param {string} value - String to check
+ * @returns {boolean} - True if the string is a palindrome, false otherwise
+ * @throws {Error} - If input is invalid
+ */
+export function palindrome(value) {
+    if (!value) throw new Error('A value is required');
+
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+
+    if (value.length < 2) throw new Error('Value must be at least two characters long');
+    if (value.length > 1000) throw new Error('Value must be less than 1000 characters long');
+
+    return value === value.split('').reverse().join('');
+}
+
+/**
+ * Find all prime factors of a number
+ *
+ * @param {number} value - Number to factorize
+ * @returns {number[]} - Array of prime factors
+ * @throws {Error} - If input is invalid or out of range
+ */
+export function primefactors(value) {
+    if (isNaN(value)) throw new Error('Value must be a number');
+    if (value < 2) throw new Error('Number must be positive and greater than 1');
+    if (value > 100000) throw new Error('Number must be between 2 and 100000');
+
+    const factors = [];
+
+    for (let i = 2; i <= value; i++) {
+        while (value % i === 0) {
+            factors.push(i);
+            value /= i;
+        }
+    }
+
+    return factors;
+}
+
+/**
+ * Generate a list of all prime numbers up to the specified limit
+ *
+ * @param {number} value - Upper limit to check for primes
+ * @returns {number[]} - Array of prime numbers
+ * @throws {Error} - If input is invalid or out of range
+ */
+export function primelist(value) {
+    if (isNaN(value)) throw new Error('Value must be a number');
+    if (value < 2) throw new Error('Number must be positive and greater than 1');
+    if (value > 10000) throw new Error('Number must be between 2 and 10000');
+
+    const primes = [];
+
+    for (let i = 2; i <= value; i++) {
+        let isPrime = true;
+
+        for (let j = 2; j <= Math.sqrt(i); j++) {
+            if (i % j === 0) {
+                isPrime = false;
+                break;
+            }
+        }
+
+        if (isPrime) primes.push(i);
+    }
+
+    return primes;
+}
+
+/**
+ * Reverse a string
+ *
+ * @param {string} value - String to reverse
+ * @returns {string} - Reversed string
+ * @throws {Error} - If input is invalid
+ */
+export function reverse(value) {
+    if (!value) throw new Error('A value is required');
+
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+
+    return value.split('').reverse().join('');
 }

package/modules/v3/captcha.js

@@ -1,55 +1,55 @@
-import { createCanvas } from 'canvas';
-
-/**
- * Generate a captcha image from the provided text
- *
- * @param {string} text - Text to render in the captcha image
- * @returns {Buffer} - PNG image buffer of the rendered captcha
- * @throws {Error} - If text is not provided
- */
-export default function captcha(text) {
-    if (!text) throw new Error('Text is required to generate a captcha.');
-
-    const size = 60, font = '60px Comic Sans Ms', width = text.length * size, height = 120;
-    const canvas = createCanvas(width, height), ctx = canvas.getContext('2d');
-
-    // Set white background
-    ctx.fillStyle = 'white';
-    ctx.fillRect(0, 0, width, height);
-
-    // Add random lines for noise
-    for (let i = 0; i < 20; i++) {
-        ctx.strokeStyle = 'rgba(0, 0, 0, 0.3)';
-        ctx.beginPath();
-        ctx.moveTo(Math.random() * width, Math.random() * height);
-        ctx.lineTo(Math.random() * width, Math.random() * height);
-        ctx.lineWidth = Math.random() * 2;
-        ctx.stroke();
-    }
-
-    let x = (canvas.width + 20 - width) / 2;
-
-    // Draw each character with random rotation and color
-    for (let i = 0; i < text.length; i++) {
-        const offsetX = Math.cos(i * 0.3) * 10, y = height / 2.5 + Math.floor(Math.random() * (height / 2));
-
-        ctx.font = font;
-        ctx.fillStyle = `rgb(${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)})`;
-
-        ctx.save();
-        ctx.translate(x + size / 2, y);
-        ctx.rotate((Math.random() - 0.5) * 0.5);
-        ctx.fillText(text[i], -size / 2 + offsetX, 0);
-        ctx.restore();
-
-        x += size;
-    }
-
-    // Add noise dots
-    for (let i = 0; i < 200; i++) {
-        ctx.fillStyle = 'black';
-        ctx.fillRect(Math.floor(Math.random() * width), Math.floor(Math.random() * height), 1.2, 1.2);
-    }
-
-    return canvas.toBuffer('image/png');
+import { createCanvas } from 'canvas';
+
+/**
+ * Generate a captcha image from the provided text
+ *
+ * @param {string} text - Text to render in the captcha image
+ * @returns {Buffer} - PNG image buffer of the rendered captcha
+ * @throws {Error} - If text is not provided
+ */
+export default function captcha(text) {
+    if (!text) throw new Error('Text is required to generate a captcha.');
+
+    const size = 60, font = '60px Comic Sans Ms', width = text.length * size, height = 120;
+    const canvas = createCanvas(width, height), ctx = canvas.getContext('2d');
+
+    // Set white background
+    ctx.fillStyle = 'white';
+    ctx.fillRect(0, 0, width, height);
+
+    // Add random lines for noise
+    for (let i = 0; i < 20; i++) {
+        ctx.strokeStyle = 'rgba(0, 0, 0, 0.3)';
+        ctx.beginPath();
+        ctx.moveTo(Math.random() * width, Math.random() * height);
+        ctx.lineTo(Math.random() * width, Math.random() * height);
+        ctx.lineWidth = Math.random() * 2;
+        ctx.stroke();
+    }
+
+    let x = (canvas.width + 20 - width) / 2;
+
+    // Draw each character with random rotation and color
+    for (let i = 0; i < text.length; i++) {
+        const offsetX = Math.cos(i * 0.3) * 10, y = height / 2.5 + Math.floor(Math.random() * (height / 2));
+
+        ctx.font = font;
+        ctx.fillStyle = `rgb(${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)})`;
+
+        ctx.save();
+        ctx.translate(x + size / 2, y);
+        ctx.rotate((Math.random() - 0.5) * 0.5);
+        ctx.fillText(text[i], -size / 2 + offsetX, 0);
+        ctx.restore();
+
+        x += size;
+    }
+
+    // Add noise dots
+    for (let i = 0; i < 200; i++) {
+        ctx.fillStyle = 'black';
+        ctx.fillRect(Math.floor(Math.random() * width), Math.floor(Math.random() * height), 1.2, 1.2);
+    }
+
+    return canvas.toBuffer('image/png');
 }