@armatofik/tgsnake-core 1.0.0

package/lib/src/helpers.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_USER_ID = exports.MAX_USER_ID_OLD = exports.MIN_CHAT_ID = exports.MAX_CHANNEL_ID = exports.MIN_CHANNEL_ID = exports.bigMath = void 0;
+exports.bigintToBuffer = bigintToBuffer;
+exports.includesBuffer = includesBuffer;
+exports.sliceBuffer = sliceBuffer;
+exports.makeCRCTable = makeCRCTable;
+exports.crc32 = crc32;
+exports.sleep = sleep;
+exports.bufferToBigint = bufferToBigint;
+exports.mod = mod;
+exports.bigIntMod = bigIntMod;
+exports.range = range;
+exports.rangeBigint = rangeBigint;
+exports.randint = randint;
+exports.randBigint = randBigint;
+exports.pow = pow;
+exports.bigIntPow = bigIntPow;
+exports.getChannelId = getChannelId;
+exports.getPeerType = getPeerType;
+exports.base64urlTobase64 = base64urlTobase64;
+exports.generateRandomBigInt = generateRandomBigInt;
+exports.normalizeSecretString = normalizeSecretString;
+const platform_node_js_1 = require("./platform.node.js");
+function bigintToBuffer(int, padding, litte = true, signed = false) {
+    const bigintLength = int.toString(2).length;
+    const bytes = Math.ceil(bigintLength / 8);
+    if (padding < bytes) {
+        throw new Error("Too big, Can't convert it to buffer with that padding.");
+    }
+    if (!signed && int < BigInt(0)) {
+        throw new Error('Too small, can convert it when unsigned.');
+    }
+    let isBellow = false;
+    if (int < BigInt(0)) {
+        isBellow = true;
+        int = int * BigInt(-1);
+    }
+    const hex = int.toString(16).padStart(padding * 2, '0');
+    let buffer = platform_node_js_1.Buffer.from(hex, 'hex');
+    if (litte)
+        buffer = buffer.reverse();
+    if (isBellow && signed) {
+        if (litte) {
+            let isReminder = false;
+            if (buffer[0])
+                buffer[0] -= 1;
+            for (let b = 0; b < platform_node_js_1.Buffer.byteLength(buffer); b++) {
+                if (!buffer[b]) {
+                    isReminder = true;
+                    continue;
+                }
+                if (isReminder) {
+                    buffer[b] -= 1;
+                    isReminder = false;
+                }
+                buffer[b] = 255 - buffer[b];
+            }
+        }
+        else {
+            buffer[platform_node_js_1.Buffer.byteLength(buffer) - 1] =
+                256 - buffer[platform_node_js_1.Buffer.byteLength(buffer) - 1];
+            for (let b = 0; b < platform_node_js_1.Buffer.byteLength(buffer); b++) {
+                buffer[b] = 255 - buffer[b];
+            }
+        }
+    }
+    return buffer;
+}
+function includesBuffer(array, buffer) {
+    for (const buff of array) {
+        if (buff.equals(buffer)) {
+            return true;
+        }
+    }
+    return false;
+}
+function sliceBuffer(buffer, start, stop, step = 1) {
+    let slc = buffer.subarray(start, stop);
+    let res = slc;
+    if (step === 0) {
+        throw new Error('slice step cannot be zero.');
+    }
+    if (step < 0) {
+        slc = platform_node_js_1.Buffer.from(buffer.subarray(stop - step, start - step)).reverse();
+        res = slc;
+        step = -step;
+    }
+    if (step > 1) {
+        res = platform_node_js_1.Buffer.alloc(0);
+        let i = 0;
+        for (const buff of slc) {
+            i++;
+            if (i >= step) {
+                i = 0;
+            }
+            if (i === 1) {
+                res = platform_node_js_1.Buffer.concat([
+                    res,
+                    platform_node_js_1.Buffer.from([buff]),
+                ]);
+            }
+        }
+    }
+    return res;
+}
+function makeCRCTable() {
+    let c;
+    const crcTable = [];
+    for (let n = 0; n < 256; n++) {
+        c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        crcTable[n] = c;
+    }
+    return crcTable;
+}
+function crc32(str) {
+    str = platform_node_js_1.Buffer.isBuffer(str) ? platform_node_js_1.Buffer.from(str) : str;
+    const crcTable = makeCRCTable();
+    const length = platform_node_js_1.Buffer.isBuffer(str) ? platform_node_js_1.Buffer.byteLength(str) : str.length;
+    let crc = -1;
+    for (let i = 0; i < length; i++) {
+        const bytes = Number(str[i]);
+        crc = (crc >>> 8) ^ crcTable[(crc ^ bytes) & 0xff];
+    }
+    return (crc ^ -1) >>> 0;
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function bufferToBigint(buffer, little = true, signed = false) {
+    const length = platform_node_js_1.Buffer.byteLength(buffer);
+    const value = little ? buffer.reverse().toString('hex') : buffer.toString('hex');
+    const _bigint = (0, platform_node_js_1.bigInt)(value, 16);
+    let bigint = BigInt(String(_bigint));
+    if (signed && Math.floor(bigint.toString(2).length / 8) >= length) {
+        bigint = bigint - bigIntPow(BigInt(2), BigInt(length * 8));
+    }
+    return BigInt(bigint);
+}
+function mod(n, m) {
+    return ((n % m) + m) % m;
+}
+function bigIntMod(n, m) {
+    return ((n % m) + m) % m;
+}
+function range(start, stop, step = 1) {
+    const temp = [];
+    const results = [];
+    if (step === 0) {
+        throw new Error('step cannot be zero');
+    }
+    if (step < 0) {
+        if (stop < 0) {
+            for (let i = start; i > stop; i--) {
+                temp.push(i);
+            }
+            step = -step;
+            if (step > 1) {
+                let i = 0;
+                for (let num of temp) {
+                    i++;
+                    if (i >= step) {
+                        i = 0;
+                    }
+                    if (i === 1) {
+                        results.push(num);
+                    }
+                }
+                return results;
+            }
+            else {
+                return temp;
+            }
+        }
+        return results;
+    }
+    for (let i = start; i < stop; i++) {
+        temp.push(i);
+    }
+    if (step > 1) {
+        let i = 0;
+        for (let num of temp) {
+            i++;
+            if (i >= step) {
+                i = 0;
+            }
+            if (i === 1) {
+                results.push(num);
+            }
+        }
+        return results;
+    }
+    return temp;
+}
+function rangeBigint(start, stop, step = 1) {
+    const temp = [];
+    const results = [];
+    if (step === 0) {
+        throw new Error('step cannot be zero');
+    }
+    if (step < 0) {
+        if (stop < BigInt(0)) {
+            for (let i = start; i > stop; i--) {
+                temp.push(i);
+            }
+            step = -step;
+            if (step > 1) {
+                let i = 0;
+                for (const num of temp) {
+                    i++;
+                    if (i >= step) {
+                        i = 0;
+                    }
+                    if (i === 1) {
+                        results.push(num);
+                    }
+                }
+                return results;
+            }
+            else {
+                return temp;
+            }
+        }
+        return results;
+    }
+    for (let i = start; i < stop; i++) {
+        temp.push(i);
+    }
+    if (step > 1) {
+        let i = 0;
+        for (const num of temp) {
+            i++;
+            if (i >= step) {
+                i = 0;
+            }
+            if (i === 1) {
+                results.push(num);
+            }
+        }
+        return results;
+    }
+    return temp;
+}
+function randint(min, max) {
+    return Math.floor(Math.random() * (max - min)) + min;
+}
+function randBigint(min, max) {
+    return platform_node_js_1.bigInt.randBetween(min, max).value;
+}
+function pow(x, y, z) {
+    let result = Math.pow(x, y);
+    if (z !== undefined) {
+        return mod(result, z);
+    }
+    return result;
+}
+function bigIntPow(x, y, z) {
+    if (z === undefined) {
+        return x ** y;
+    }
+    else {
+        let result = BigInt(1);
+        while (y > BigInt(0)) {
+            if (bigIntMod(y, BigInt(2)) === BigInt(1)) {
+                result = bigIntMod(result * x, z);
+            }
+            y = y >> BigInt(1);
+            x = bigIntMod(x * x, z);
+        }
+        return result;
+    }
+}
+const bigMath = {
+    abs(x) {
+        return x < BigInt(0) ? -x : x;
+    },
+    sign(x) {
+        if (x === BigInt(0))
+            return BigInt(0);
+        return x < BigInt(0) ? -BigInt(1) : BigInt(1);
+    },
+    pow(base, exponent) {
+        return base ** exponent;
+    },
+    min(value, ...values) {
+        for (const v of values)
+            if (v < value)
+                value = v;
+        return value;
+    },
+    max(value, ...values) {
+        for (const v of values)
+            if (v > value)
+                value = v;
+        return value;
+    },
+};
+exports.bigMath = bigMath;
+exports.MIN_CHANNEL_ID = BigInt(-1002147483647);
+exports.MAX_CHANNEL_ID = BigInt(-1000000000000);
+exports.MIN_CHAT_ID = BigInt(-2147483647);
+exports.MAX_USER_ID_OLD = BigInt(2147483647);
+exports.MAX_USER_ID = BigInt(999999999999);
+function getChannelId(id) {
+    return exports.MAX_CHANNEL_ID - id;
+}
+function getPeerType(id) {
+    if (id < BigInt(0)) {
+        if (exports.MIN_CHAT_ID <= id)
+            return 'chat';
+        if (exports.MIN_CHANNEL_ID <= id < exports.MAX_CHANNEL_ID)
+            return 'channel';
+    }
+    else if (BigInt(0) < id <= exports.MAX_USER_ID) {
+        return 'user';
+    }
+    else {
+        throw new Error(`PeerId Invalid: ${id}`);
+    }
+}
+function base64urlTobase64(text) {
+    const pad = text.length % 4;
+    if (pad === 1) {
+        throw new Error('Invalid base64url');
+    }
+    return (pad === 2 || pad === 3 ? text.padEnd(4 - pad, '=') : text)
+        .replace(/\-/g, '+')
+        .replace(/_/g, '/');
+}
+function generateRandomBigInt(lowBigInt, highBigInt) {
+    if (lowBigInt >= highBigInt) {
+        throw new Error('lowBigInt must be smaller than highBigInt');
+    }
+    const difference = highBigInt - lowBigInt;
+    const differenceLength = difference.toString().length;
+    let multiplier = '';
+    while (multiplier.length < differenceLength) {
+        multiplier += Math.random().toString().split('.')[1];
+    }
+    multiplier = multiplier.slice(0, differenceLength);
+    const divisor = '1' + '0'.repeat(differenceLength);
+    const randomDifference = (difference * BigInt(multiplier)) / BigInt(divisor);
+    return lowBigInt + randomDifference;
+}
+function normalizeSecretString(secret) {
+    if (secret.slice(0, 2) === 'dd' || secret.slice(0, 2) === 'ee') {
+        secret = secret.slice(2);
+    }
+    if (/^[0-9a-fA-F]+$/.test(secret)) {
+        return platform_node_js_1.Buffer.from(secret, 'hex');
+    }
+    return platform_node_js_1.Buffer.from(secret, 'base64').subarray(0, 16);
+}

package/lib/src/index.d.ts

@@ -0,0 +1,16 @@
+export { Client } from './client/Client.js';
+export { Raw } from './raw/index.js';
+export { Queue } from './Queue.js';
+export { TCP } from './connection/connection.js';
+export * as Clients from './client/index.js';
+export * as Connections from './connection/index.js';
+export * as Cryptos from './crypto/index.js';
+export * as Errors from './errors/index.js';
+export * as Files from './file/index.js';
+export * as Raws from './raw/index.js';
+export * as Sessions from './session/index.js';
+export * as Storages from './storage/index.js';
+export * as Versions from './Version.node.js';
+export * as Helpers from './helpers.js';
+export * as Timeouts from './Timeout.js';
+export * as Loggers from './Logger.js';

package/lib/src/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loggers = exports.Timeouts = exports.Helpers = exports.Versions = exports.Storages = exports.Sessions = exports.Raws = exports.Files = exports.Errors = exports.Cryptos = exports.Connections = exports.Clients = exports.TCP = exports.Queue = exports.Raw = exports.Client = void 0;
+var Client_js_1 = require("./client/Client.js");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return Client_js_1.Client; } });
+var index_js_1 = require("./raw/index.js");
+Object.defineProperty(exports, "Raw", { enumerable: true, get: function () { return index_js_1.Raw; } });
+var Queue_js_1 = require("./Queue.js");
+Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return Queue_js_1.Queue; } });
+var connection_js_1 = require("./connection/connection.js");
+Object.defineProperty(exports, "TCP", { enumerable: true, get: function () { return connection_js_1.TCP; } });
+exports.Clients = __importStar(require("./client/index.js"));
+exports.Connections = __importStar(require("./connection/index.js"));
+exports.Cryptos = __importStar(require("./crypto/index.js"));
+exports.Errors = __importStar(require("./errors/index.js"));
+exports.Files = __importStar(require("./file/index.js"));
+exports.Raws = __importStar(require("./raw/index.js"));
+exports.Sessions = __importStar(require("./session/index.js"));
+exports.Storages = __importStar(require("./storage/index.js"));
+exports.Versions = __importStar(require("./Version.node.js"));
+exports.Helpers = __importStar(require("./helpers.js"));
+exports.Timeouts = __importStar(require("./Timeout.js"));
+exports.Loggers = __importStar(require("./Logger.js"));

package/lib/src/platform.node.d.ts

@@ -0,0 +1,36 @@
+import * as crypto from 'crypto';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import process from 'process';
+import { Buffer } from 'buffer';
+export { inspect } from 'util';
+export { gzipSync, gunzipSync } from 'zlib';
+import bigInt from 'big-integer';
+export { Logger } from '@tgsnake/log';
+export { SocksClient } from 'socks';
+export { Mutex, Semaphore } from 'async-mutex';
+export { Readable, Writable, Duplex } from 'stream';
+export declare const isDeno: boolean;
+export declare const isBun: boolean;
+export declare const isBrowser: boolean;
+export declare const where: string;
+export type BufferEncoding = 'utf-8' | 'utf8' | 'utf-16le' | 'utf16le' | 'latin1' | 'binary' | 'base64' | 'hex';
+export declare namespace aesjs {
+    namespace ModeOfOperation {
+        class ecb {
+            constructor(..._args: Array<any>);
+            encrypt(..._args: Array<any>): Buffer;
+            decrypt(..._args: Array<any>): Buffer;
+        }
+        class ctr {
+            constructor(..._args: Array<any>);
+            encrypt(..._args: Array<any>): Buffer;
+            decrypt(..._args: Array<any>): Buffer;
+        }
+    }
+    class Counter {
+        constructor(..._args: Array<any>);
+    }
+}
+export { crypto, net, os, bigInt, path, process as sysprc, Buffer };

package/lib/src/platform.node.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Buffer = exports.sysprc = exports.path = exports.bigInt = exports.os = exports.net = exports.crypto = exports.aesjs = exports.where = exports.isBrowser = exports.isBun = exports.isDeno = exports.Duplex = exports.Writable = exports.Readable = exports.Semaphore = exports.Mutex = exports.SocksClient = exports.Logger = exports.gunzipSync = exports.gzipSync = exports.inspect = void 0;
+const crypto = __importStar(require("crypto"));
+exports.crypto = crypto;
+const net = __importStar(require("net"));
+exports.net = net;
+const os = __importStar(require("os"));
+exports.os = os;
+const path = __importStar(require("path"));
+exports.path = path;
+const process_1 = __importDefault(require("process"));
+exports.sysprc = process_1.default;
+const buffer_1 = require("buffer");
+Object.defineProperty(exports, "Buffer", { enumerable: true, get: function () { return buffer_1.Buffer; } });
+var util_1 = require("util");
+Object.defineProperty(exports, "inspect", { enumerable: true, get: function () { return util_1.inspect; } });
+var zlib_1 = require("zlib");
+Object.defineProperty(exports, "gzipSync", { enumerable: true, get: function () { return zlib_1.gzipSync; } });
+Object.defineProperty(exports, "gunzipSync", { enumerable: true, get: function () { return zlib_1.gunzipSync; } });
+const big_integer_1 = __importDefault(require("big-integer"));
+exports.bigInt = big_integer_1.default;
+var log_1 = require("@tgsnake/log");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return log_1.Logger; } });
+var socks_1 = require("socks");
+Object.defineProperty(exports, "SocksClient", { enumerable: true, get: function () { return socks_1.SocksClient; } });
+var async_mutex_1 = require("async-mutex");
+Object.defineProperty(exports, "Mutex", { enumerable: true, get: function () { return async_mutex_1.Mutex; } });
+Object.defineProperty(exports, "Semaphore", { enumerable: true, get: function () { return async_mutex_1.Semaphore; } });
+var stream_1 = require("stream");
+Object.defineProperty(exports, "Readable", { enumerable: true, get: function () { return stream_1.Readable; } });
+Object.defineProperty(exports, "Writable", { enumerable: true, get: function () { return stream_1.Writable; } });
+Object.defineProperty(exports, "Duplex", { enumerable: true, get: function () { return stream_1.Duplex; } });
+exports.isDeno = 'Deno' in globalThis;
+exports.isBun = 'Bun' in globalThis;
+exports.isBrowser = !exports.isDeno && !exports.isBun && typeof window !== 'undefined';
+exports.where = exports.isDeno ? 'Deno' : exports.isBun ? 'Bun' : exports.isBrowser ? 'Browser' : 'Node';
+var aesjs;
+(function (aesjs) {
+    let ModeOfOperation;
+    (function (ModeOfOperation) {
+        class ecb {
+            constructor(..._args) {
+                throw new Error('not implemented');
+            }
+            encrypt(..._args) {
+                return buffer_1.Buffer.alloc(0);
+            }
+            decrypt(..._args) {
+                return buffer_1.Buffer.alloc(0);
+            }
+        }
+        ModeOfOperation.ecb = ecb;
+        class ctr {
+            constructor(..._args) {
+                throw new Error('not implemented');
+            }
+            encrypt(..._args) {
+                return buffer_1.Buffer.alloc(0);
+            }
+            decrypt(..._args) {
+                return buffer_1.Buffer.alloc(0);
+            }
+        }
+        ModeOfOperation.ctr = ctr;
+    })(ModeOfOperation = aesjs.ModeOfOperation || (aesjs.ModeOfOperation = {}));
+    class Counter {
+        constructor(..._args) {
+            throw new Error('not implemented');
+        }
+    }
+    aesjs.Counter = Counter;
+})(aesjs || (exports.aesjs = aesjs = {}));