ayiin 2.0.51 → 2.0.53

package/dist/methods/crypt.d.ts

@@ -1,11 +1,25 @@
 declare class Crypt {
-    private chars;
-    private base62Encode;
-    private base62Decode;
-    private generateKeystream;
+    /**
+     * Performs Base encryption and decryption.
+     * @param {string | Buffer} input - The input data to be encrypted or decrypted.
+     * @param {string} key - The encryption/decryption key.
+     * @returns {Buffer} - The encrypted or decrypted data as a Buffer.
+     */
     private baseCrypt;
-    encrypt: (text: string, key: string) => string;
-    decrypt: (token: string, key: string) => string | null;
+    /**
+     * Encrypts a plaintext message using the given key.
+     * @param {string} text - The plaintext message to be encrypted.
+     * @param {string} key - The encryption key.
+     * @returns {string} - The encrypted data in Hex format.
+     */
+    encrypt: (text: string, key: string, bufferEncoding?: BufferEncoding) => string;
+    /**
+     * Decrypts an encrypted message using the given key.
+     * @param {string} encrypted - The encrypted data in Hex format.
+     * @param {string} key - The decryption key.
+     * @returns {string} - The decrypted plaintext message.
+     */
+    decrypt: (encrypted: string, key: string, bufferEncoding?: BufferEncoding) => string;
     /**
      * Converts a Hex string to its corresponding ASCII representation.
      * @param {string} hexString - The Hex string to be converted.

package/dist/methods/crypt.js

@@ -5,87 +5,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = __importDefault(require("crypto"));
 class Crypt {
-    chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    // Base62 encode: buffer → base62 string
-    base62Encode(buffer) {
-        let digits = [0];
-        for (const byte of buffer) {
-            let carry = byte;
-            for (let j = 0; j < digits.length; j++) {
-                const val = digits[j] * 256 + carry;
-                digits[j] = val % 62;
-                carry = Math.floor(val / 62);
-            }
-            while (carry > 0) {
-                digits.push(carry % 62);
-                carry = Math.floor(carry / 62);
-            }
-        }
-        return (digits
-            .reverse()
-            .map((d) => this.chars[d])
-            .join("") || "0");
-    }
-    // Base62 decode: string → buffer
-    base62Decode(str) {
-        let digits = [0];
-        for (const c of str) {
-            let carry = this.chars.indexOf(c);
-            for (let j = 0; j < digits.length; j++) {
-                const val = digits[j] * 62 + carry;
-                digits[j] = val & 0xff;
-                carry = val >> 8;
-            }
-            while (carry > 0) {
-                digits.push(carry & 0xff);
-                carry >>= 8;
-            }
-        }
-        return Buffer.from(digits.reverse());
-    }
-    generateKeystream(key, length) {
-        const result = Buffer.alloc(length);
-        let pos = 0;
-        let counter = 0;
-        while (pos < length) {
-            const hash = crypto_1.default.createHash("sha256");
-            hash.update(key);
-            hash.update(Buffer.from(counter.toString()));
-            const digest = hash.digest();
-            const copy = Math.min(length - pos, digest.length);
-            digest.copy(result, pos, 0, copy);
-            pos += copy;
-            counter++;
-        }
-        return result;
-    }
-    baseCrypt(input, key) {
-        const keystream = this.generateKeystream(key, input.length);
-        const output = Buffer.alloc(input.length);
-        for (let i = 0; i < input.length; i++) {
-            output[i] = input[i] ^ keystream[i];
+    /**
+     * Performs Base encryption and decryption.
+     * @param {string | Buffer} input - The input data to be encrypted or decrypted.
+     * @param {string} key - The encryption/decryption key.
+     * @returns {Buffer} - The encrypted or decrypted data as a Buffer.
+     */
+    baseCrypt = (input, key) => {
+        const inputBuffer = Buffer.from(input, "ascii");
+        const keyBuffer = Buffer.from(key, "ascii");
+        const resultBuffer = Buffer.alloc(inputBuffer.length);
+        for (let i = 0; i < inputBuffer.length; i++) {
+            resultBuffer[i] = inputBuffer[i] ^ keyBuffer[i % keyBuffer.length];
         }
-        return output;
-    }
-    encrypt = (text, key) => {
-        const input = Buffer.from(text, "utf8");
-        const encrypted = this.baseCrypt(input, key);
-        const cipher = this.base62Encode(encrypted);
-        const hmac = crypto_1.default.createHmac("sha256", key).update(cipher).digest();
-        const signature = this.base62Encode(hmac);
-        return `${cipher}.${signature}`;
+        return resultBuffer;
     };
-    decrypt = (token, key) => {
-        const [cipher, signature] = token.split(".");
-        if (!cipher || !signature)
-            return null;
-        const hmac = crypto_1.default.createHmac("sha256", key).update(cipher).digest();
-        const expected = this.base62Encode(hmac);
-        if (expected !== signature)
-            return null;
-        const input = this.base62Decode(cipher);
-        const decrypted = this.baseCrypt(input, key);
-        return decrypted.toString("utf8");
+    /**
+     * Encrypts a plaintext message using the given key.
+     * @param {string} text - The plaintext message to be encrypted.
+     * @param {string} key - The encryption key.
+     * @returns {string} - The encrypted data in Hex format.
+     */
+    encrypt = (text, key, bufferEncoding = "base64") => {
+        const encryptedBuffer = this.baseCrypt(text, key);
+        return encryptedBuffer.toString(bufferEncoding);
+    };
+    /**
+     * Decrypts an encrypted message using the given key.
+     * @param {string} encrypted - The encrypted data in Hex format.
+     * @param {string} key - The decryption key.
+     * @returns {string} - The decrypted plaintext message.
+     */
+    decrypt = (encrypted, key, bufferEncoding = "base64") => {
+        const encryptedBuffer = Buffer.from(encrypted, bufferEncoding);
+        const decryptedBuffer = this.baseCrypt(encryptedBuffer, key);
+        return decryptedBuffer.toString("ascii");
     };
     /**
      * Converts a Hex string to its corresponding ASCII representation.

package/dist/methods/index.d.ts

@@ -8,9 +8,10 @@ import Objects from "./objects";
 import Random from "./random";
 import ResponseApi from "./response";
 import Strings from "./strings";
+import Token from "./token";
 import Validation from "./validation";
 declare class Methods {
 }
-interface Methods extends Async, Crypt, Currency, Dates, Files, Limiter, Objects, Random, ResponseApi, Strings, Validation {
+interface Methods extends Async, Crypt, Currency, Dates, Files, Limiter, Objects, Random, ResponseApi, Strings, Token, Validation {
 }
 export default Methods;

package/dist/methods/index.js

@@ -13,6 +13,7 @@ const objects_1 = __importDefault(require("./objects"));
 const random_1 = __importDefault(require("./random"));
 const response_1 = __importDefault(require("./response"));
 const strings_1 = __importDefault(require("./strings"));
+const token_1 = __importDefault(require("./token"));
 const validation_1 = __importDefault(require("./validation"));
 class Methods {
 }
@@ -27,5 +28,6 @@ Object.assign(Methods.prototype, new objects_1.default());
 Object.assign(Methods.prototype, new random_1.default());
 Object.assign(Methods.prototype, new response_1.default());
 Object.assign(Methods.prototype, new strings_1.default());
+Object.assign(Methods.prototype, new token_1.default());
 Object.assign(Methods.prototype, new validation_1.default());
 exports.default = Methods;

package/dist/methods/response.d.ts

@@ -46,6 +46,24 @@ declare class ResponseApi {
         responseMessage: string;
         responseData: any;
     };
+    forbidden: ({ caption, data }: {
+        caption: string;
+        data?: any;
+    }) => {
+        responseCode: number;
+        responseSuccess: boolean;
+        responseMessage: string;
+        responseData: any;
+    };
+    floodWait: ({ caption, data }: {
+        caption: string;
+        data?: any;
+    }) => {
+        responseCode: number;
+        responseSuccess: boolean;
+        responseMessage: string;
+        responseData: any;
+    };
     internalServer: ({ caption, data }: {
         caption: string;
         data?: any;

package/dist/methods/response.js

@@ -42,6 +42,22 @@ class ResponseApi {
             responseData: data,
         };
     };
+    forbidden = ({ caption, data }) => {
+        return {
+            responseCode: 4037400,
+            responseSuccess: false,
+            responseMessage: `[Forbidden] - ${caption}`,
+            responseData: data,
+        };
+    };
+    floodWait = ({ caption, data }) => {
+        return {
+            responseCode: 4297400,
+            responseSuccess: false,
+            responseMessage: `[Flood Wait] - ${caption}`,
+            responseData: data,
+        };
+    };
     internalServer = ({ caption, data }) => {
         return {
             responseCode: 5007400,

package/dist/methods/token.d.ts

@@ -0,0 +1,10 @@
+declare class Token {
+    private chars;
+    private base62Encode;
+    private base62Decode;
+    private generateKeystream;
+    private baseCryptToken;
+    generateToken: (text: string, key: string) => string;
+    verifyToken: (token: string, key: string) => string | null;
+}
+export default Token;

package/dist/methods/token.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+class Token {
+    chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    // Base62 encode: buffer → base62 string
+    base62Encode(buffer) {
+        let digits = [0];
+        for (const byte of buffer) {
+            let carry = byte;
+            for (let j = 0; j < digits.length; j++) {
+                const val = digits[j] * 256 + carry;
+                digits[j] = val % 62;
+                carry = Math.floor(val / 62);
+            }
+            while (carry > 0) {
+                digits.push(carry % 62);
+                carry = Math.floor(carry / 62);
+            }
+        }
+        return (digits
+            .reverse()
+            .map((d) => this.chars[d])
+            .join("") || "0");
+    }
+    // Base62 decode: string → buffer
+    base62Decode(str) {
+        let digits = [0];
+        for (const c of str) {
+            let carry = this.chars.indexOf(c);
+            for (let j = 0; j < digits.length; j++) {
+                const val = digits[j] * 62 + carry;
+                digits[j] = val & 0xff;
+                carry = val >> 8;
+            }
+            while (carry > 0) {
+                digits.push(carry & 0xff);
+                carry >>= 8;
+            }
+        }
+        return Buffer.from(digits.reverse());
+    }
+    generateKeystream(key, length) {
+        const result = Buffer.alloc(length);
+        let pos = 0;
+        let counter = 0;
+        while (pos < length) {
+            const hash = crypto_1.default.createHash("sha256");
+            hash.update(key);
+            hash.update(Buffer.from(counter.toString()));
+            const digest = hash.digest();
+            const copy = Math.min(length - pos, digest.length);
+            digest.copy(result, pos, 0, copy);
+            pos += copy;
+            counter++;
+        }
+        return result;
+    }
+    baseCryptToken(input, key) {
+        const keystream = this.generateKeystream(key, input.length);
+        const output = Buffer.alloc(input.length);
+        for (let i = 0; i < input.length; i++) {
+            output[i] = input[i] ^ keystream[i];
+        }
+        return output;
+    }
+    generateToken = (text, key) => {
+        const input = Buffer.from(text, "utf8");
+        const encrypted = this.baseCryptToken(input, key);
+        const cipher = this.base62Encode(encrypted);
+        const hmac = crypto_1.default.createHmac("sha256", key).update(cipher).digest();
+        const signature = this.base62Encode(hmac);
+        return `${cipher}.${signature}`;
+    };
+    verifyToken = (token, key) => {
+        const [cipher, signature] = token.split(".");
+        if (!cipher || !signature)
+            return null;
+        const hmac = crypto_1.default.createHmac("sha256", key).update(cipher).digest();
+        const expected = this.base62Encode(hmac);
+        if (expected !== signature)
+            return null;
+        const input = this.base62Decode(cipher);
+        const decrypted = this.baseCryptToken(input, key);
+        return decrypted.toString("utf8");
+    };
+}
+exports.default = Token;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ayiin",
-  "version": "2.0.51",
+  "version": "2.0.53",
   "author": {
     "name": "AyiinXd",
     "url": "https://github.com/AyiinXd"