@mtcute/bun 0.17.0 → 0.18.0

package/client.d.ts

@@ -1,8 +1,8 @@
-import { Readable } from 'node:stream';
 import { FileDownloadLocation, FileDownloadParameters, ITelegramStorageProvider, PartialOnly, User } from '@mtcute/core';
 import { BaseTelegramClientOptions as BaseTelegramClientOptionsBase, TelegramClientOptions, BaseTelegramClient as BaseTelegramClientBase, TelegramClient as TelegramClientBase } from '@mtcute/core/client.js';
+import { Readable } from 'node:stream';
 export type { TelegramClientOptions };
-export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegramClientOptionsBase, 'storage'>, 'transport' | 'crypto'> {
+export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegramClientOptionsBase, 'storage'>, 'transport' | 'crypto' | 'platform'> {
     /**
      * Storage to use for this client.
      *
@@ -12,13 +12,6 @@ export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegram
      * @default `"client.session"`
      */
     storage?: string | ITelegramStorageProvider;
-    /**
-     * **ADVANCED USE ONLY**
-     *
-     * Whether to not set up the platform.
-     * This is useful if you call `setPlatform` yourself.
-     */
-    platformless?: boolean;
 }
 export declare class BaseTelegramClient extends BaseTelegramClientBase {
     constructor(opts: BaseTelegramClientOptions);

package/client.js

@@ -0,0 +1,90 @@
+import { createInterface } from "node:readline";
+import { unknownToError } from "@fuman/utils";
+import { BaseTelegramClient as BaseTelegramClient$1, TelegramClient as TelegramClient$1 } from "@mtcute/core/client.js";
+import { downloadToFile } from "./methods/download-file.js";
+import { downloadAsNodeStream } from "./methods/download-node-stream.js";
+import { BunPlatform } from "./platform.js";
+import { SqliteStorage } from "./sqlite/index.js";
+import { BunCryptoProvider } from "./utils/crypto.js";
+import { TcpTransport } from "./utils/tcp.js";
+class BaseTelegramClient extends BaseTelegramClient$1 {
+  constructor(opts) {
+    super({
+      crypto: new BunCryptoProvider(),
+      transport: new TcpTransport(),
+      platform: new BunPlatform(),
+      ...opts,
+      storage: typeof opts.storage === "string" ? new SqliteStorage(opts.storage) : opts.storage ?? new SqliteStorage("client.session")
+    });
+  }
+}
+class TelegramClient extends TelegramClient$1 {
+  constructor(opts) {
+    if ("client" in opts) {
+      super(opts);
+      return;
+    }
+    super({
+      client: new BaseTelegramClient(opts),
+      disableUpdates: opts.disableUpdates,
+      skipConversationUpdates: opts.skipConversationUpdates,
+      updates: opts.updates
+    });
+  }
+  _rl;
+  /**
+   * Tiny wrapper over Node `readline` package
+   * for simpler user input for `.start()` method.
+   *
+   * Associated `readline` interface is closed
+   * after `start()` returns, or with the client.
+   *
+   * @param text  Text of the question
+   */
+  input(text) {
+    if (!this._rl) {
+      this._rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+    }
+    return new Promise((res) => this._rl?.question(text, res));
+  }
+  close() {
+    this._rl?.close();
+    return super.close();
+  }
+  start(params = {}) {
+    if (!params.botToken) {
+      if (!params.phone) params.phone = () => this.input("phone > ");
+      if (!params.code) params.code = () => this.input("code > ");
+      if (!params.password) {
+        params.password = () => this.input("2fa password > ");
+      }
+    }
+    return super.start(params).then((user) => {
+      if (this._rl) {
+        this._rl.close();
+        delete this._rl;
+      }
+      return user;
+    });
+  }
+  run(params, then) {
+    if (typeof params === "function") {
+      then = params;
+      params = {};
+    }
+    this.start(params).then(then).catch((err) => this.onError.emit(unknownToError(err)));
+  }
+  downloadToFile(filename, location, params) {
+    return downloadToFile(this, filename, location, params);
+  }
+  downloadAsNodeStream(location, params) {
+    return downloadAsNodeStream(this, location, params);
+  }
+}
+export {
+  BaseTelegramClient,
+  TelegramClient
+};

package/index.d.ts

@@ -2,6 +2,7 @@ export * from './client.js';
 export * from './platform.js';
 export * from './sqlite/index.js';
 export * from './utils/crypto.js';
+export * from './utils/proxies.js';
 export * from './utils/tcp.js';
 export * from './worker.js';
 export * from '@mtcute/core';

package/index.js

@@ -1,537 +1,24 @@
-import { createInterface } from "node:readline";
-import { BaseTelegramClient as BaseTelegramClient$1, TelegramClient as TelegramClient$1 } from "@mtcute/core/client.js";
-import { setPlatform } from "@mtcute/core/platform.js";
-import { downloadToFile, downloadAsNodeStream } from "./chunks/es/BmtxbrWZ.js";
-import * as os from "node:os";
-import { createReadStream, ReadStream } from "node:fs";
-import { stat, readFile } from "node:fs/promises";
-import { basename } from "node:path";
-import { Readable } from "node:stream";
-import { BaseSqliteStorageDriver, BaseSqliteStorage, TransportState, MtcuteError, IntermediatePacketCodec } from "@mtcute/core";
+import { BaseTelegramClient, TelegramClient } from "./client.js";
+import { BunPlatform } from "./platform.js";
+import { SqliteStorage } from "./sqlite/index.js";
+import { BunCryptoProvider } from "./utils/crypto.js";
+import { HttpProxyTcpTransport, MtProxyTcpTransport, SocksProxyTcpTransport } from "./utils/proxies.js";
+import { TcpTransport } from "./utils/tcp.js";
+import { TelegramWorker, TelegramWorkerPort } from "./worker.js";
 export * from "@mtcute/core";
-import { Database } from "bun:sqlite";
-import { deflateSync, gunzipSync } from "node:zlib";
-import { pbkdf2 } from "node:crypto";
-import { BaseCryptoProvider } from "@mtcute/core/utils.js";
-import { initSync, ige256Encrypt, ige256Decrypt, createCtr256, ctr256, freeCtr256 } from "@mtcute/wasm";
-import EventEmitter from "events";
-import { parentPort, Worker } from "node:worker_threads";
-import { TelegramWorker as TelegramWorker$1, TelegramWorkerPort as TelegramWorkerPort$1 } from "@mtcute/core/worker.js";
 export * from "@mtcute/html-parser";
 export * from "@mtcute/markdown-parser";
-function nodeStreamToWeb(stream) {
-  if (typeof Readable.toWeb === "function") {
-    return Readable.toWeb(stream);
-  }
-  stream.pause();
-  return new ReadableStream({
-    start(c) {
-      stream.on("data", (chunk) => {
-        c.enqueue(chunk);
-      });
-      stream.on("end", () => {
-        c.close();
-      });
-      stream.on("error", (err) => {
-        c.error(err);
-      });
-    },
-    pull() {
-      stream.resume();
-    }
-  });
-}
-async function normalizeFile$1(file) {
-  if (typeof file === "string") {
-    file = createReadStream(file);
-  }
-  if (file instanceof ReadStream) {
-    const fileName = basename(file.path.toString());
-    const fileSize = await stat(file.path.toString()).then((stat2) => stat2.size);
-    return {
-      file: nodeStreamToWeb(file),
-      fileName,
-      fileSize
-    };
-  }
-  if (file instanceof Readable) {
-    return {
-      file: nodeStreamToWeb(file)
-    };
-  }
-  return null;
-}
-let installed = false;
-let handled = false;
-const callbacks = /* @__PURE__ */ new Set();
-const myHandlers = /* @__PURE__ */ new Map();
-function register(shouldManuallyExit, signal, event) {
-  function eventHandler() {
-    if (handled) {
-      return;
-    }
-    handled = true;
-    for (const callback of callbacks) {
-      callback();
-    }
-    for (const [event2, handler] of myHandlers) {
-      process.off(event2, handler);
-    }
-    if (shouldManuallyExit) {
-      process.kill(process.pid, signal);
-    }
-  }
-  process.on(event, eventHandler);
-  myHandlers.set(event, eventHandler);
-}
-function beforeExit(fn) {
-  if (typeof process === "undefined") return () => {
-  };
-  if (!installed) {
-    installed = true;
-    register(true, 0, "beforeExit");
-    register(true, 2, "SIGINT");
-    register(true, 15, "SIGTERM");
-    register(false, 15, "exit");
-  }
-  callbacks.add(fn);
-  return () => {
-    callbacks.delete(fn);
-  };
-}
-const isTty = typeof process === "object" && Boolean(process.stdout?.isTTY);
-const BASE_FORMAT = isTty ? "%s [%s] [%s%s\x1B[0m] " : "%s [%s] [%s] ";
-const LEVEL_NAMES = isTty ? [
-  "",
-  // OFF
-  "\x1B[31mERR\x1B[0m",
-  "\x1B[33mWRN\x1B[0m",
-  "\x1B[34mINF\x1B[0m",
-  "\x1B[36mDBG\x1B[0m",
-  "\x1B[35mVRB\x1B[0m"
-] : [
-  "",
-  // OFF
-  "ERR",
-  "WRN",
-  "INF",
-  "DBG",
-  "VRB"
-];
-const TAG_COLORS = [6, 2, 3, 4, 5, 1].map((i) => `\x1B[3${i};1m`);
-const defaultLoggingHandler = isTty ? (color, level, tag, fmt, args) => {
-  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], TAG_COLORS[color], tag, ...args);
-} : (color, level, tag, fmt, args) => {
-  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], tag, ...args);
-};
-const BUFFER_BASE64_URL_AVAILABLE = typeof Buffer.isEncoding === "function" && Buffer.isEncoding("base64url");
-const toBuffer = (buf) => Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
-class NodePlatform {
-  getDeviceModel() {
-    return `Node.js/${process.version} (${os.type()} ${os.arch()})`;
-  }
-  getDefaultLogLevel() {
-    const envLogLevel = Number.parseInt(process.env.MTCUTE_LOG_LEVEL ?? "");
-    if (!Number.isNaN(envLogLevel)) {
-      return envLogLevel;
-    }
-    return null;
-  }
-  // ITlPlatform
-  utf8ByteLength(str) {
-    return Buffer.byteLength(str, "utf8");
-  }
-  utf8Encode(str) {
-    return Buffer.from(str, "utf8");
-  }
-  utf8Decode(buf) {
-    return toBuffer(buf).toString("utf8");
-  }
-  hexEncode(buf) {
-    return toBuffer(buf).toString("hex");
-  }
-  hexDecode(str) {
-    return Buffer.from(str, "hex");
-  }
-  base64Encode(buf, url = false) {
-    const nodeBuffer = toBuffer(buf);
-    if (url && BUFFER_BASE64_URL_AVAILABLE) return nodeBuffer.toString("base64url");
-    const str = nodeBuffer.toString("base64");
-    if (url) return str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-    return str;
-  }
-  base64Decode(string, url = false) {
-    if (url && BUFFER_BASE64_URL_AVAILABLE) {
-      return Buffer.from(string, "base64url");
-    }
-    if (url) {
-      string = string.replace(/-/g, "+").replace(/_/g, "/");
-      while (string.length % 4) string += "=";
-    }
-    return Buffer.from(string, "base64");
-  }
-}
-NodePlatform.prototype.log = defaultLoggingHandler;
-NodePlatform.prototype.beforeExit = beforeExit;
-NodePlatform.prototype.normalizeFile = normalizeFile$1;
-function isBunFile(file) {
-  return file instanceof Blob && "name" in file && file.name.length > 0;
-}
-async function normalizeFile(file) {
-  if (typeof file === "string") {
-    file = Bun.file(file);
-  }
-  if (isBunFile(file)) {
-    return {
-      file,
-      fileName: file.name,
-      fileSize: file.size
-    };
-  }
-  if (file instanceof ReadStream) {
-    const fileName = basename(file.path.toString());
-    const fileSize = await stat(file.path.toString()).then((stat2) => stat2.size);
-    return {
-      file: Readable.toWeb(file),
-      fileName,
-      fileSize
-    };
-  }
-  if (file instanceof Readable) {
-    return {
-      file: Readable.toWeb(file)
-    };
-  }
-  return null;
-}
-class BunPlatform extends NodePlatform {
-  getDeviceModel() {
-    return `Bun/${Bun.version} (${os.type()} ${os.arch()})`;
-  }
-}
-BunPlatform.prototype.normalizeFile = normalizeFile;
-class SqliteStorageDriver extends BaseSqliteStorageDriver {
-  constructor(filename = ":memory:", params) {
-    super();
-    this.filename = filename;
-    this.params = params;
-  }
-  _createDatabase() {
-    const db = new Database(this.filename);
-    if (!this.params?.disableWal) {
-      db.exec("PRAGMA journal_mode = WAL;");
-    }
-    return db;
-  }
-}
-class SqliteStorage extends BaseSqliteStorage {
-  constructor(filename = ":memory:", params) {
-    super(new SqliteStorageDriver(filename, params));
-    this.filename = filename;
-    this.params = params;
-  }
-}
-class BunCryptoProvider extends BaseCryptoProvider {
-  async initialize() {
-    const wasmFile = require.resolve("@mtcute/wasm/mtcute.wasm");
-    const wasm = await readFile(wasmFile);
-    initSync(wasm);
-  }
-  createAesIge(key, iv) {
-    return {
-      encrypt(data) {
-        return ige256Encrypt(data, key, iv);
-      },
-      decrypt(data) {
-        return ige256Decrypt(data, key, iv);
-      }
-    };
-  }
-  createAesCtr(key, iv) {
-    const ctx = createCtr256(key, iv);
-    return {
-      process: (data) => ctr256(ctx, data),
-      close: () => freeCtr256(ctx)
-    };
-  }
-  pbkdf2(password, salt, iterations, keylen = 64, algo = "sha512") {
-    return new Promise(
-      (resolve, reject) => pbkdf2(password, salt, iterations, keylen, algo, (err, buf) => err !== null ? reject(err) : resolve(buf))
-    );
-  }
-  sha1(data) {
-    const res = new Uint8Array(Bun.SHA1.byteLength);
-    Bun.SHA1.hash(data, res);
-    return res;
-  }
-  sha256(data) {
-    const res = new Uint8Array(Bun.SHA256.byteLength);
-    Bun.SHA256.hash(data, res);
-    return res;
-  }
-  async hmacSha256(data, key) {
-    const keyMaterial = await crypto.subtle.importKey(
-      "raw",
-      key,
-      { name: "HMAC", hash: { name: "SHA-256" } },
-      false,
-      ["sign"]
-    );
-    const res = await crypto.subtle.sign({ name: "HMAC" }, keyMaterial, data);
-    return new Uint8Array(res);
-  }
-  gzip(data, maxSize) {
-    try {
-      return deflateSync(data, {
-        maxOutputLength: maxSize
-      });
-    } catch (e) {
-      if (e.code === "ERR_BUFFER_TOO_LARGE") {
-        return null;
-      }
-      throw e;
-    }
-  }
-  gunzip(data) {
-    return gunzipSync(data);
-  }
-  randomFill(buf) {
-    crypto.getRandomValues(buf);
-  }
-}
-class BaseTcpTransport extends EventEmitter {
-  _currentDc = null;
-  _state = TransportState.Idle;
-  _socket = null;
-  _crypto;
-  log;
-  packetCodecInitialized = false;
-  _updateLogPrefix() {
-    if (this._currentDc) {
-      this.log.prefix = `[TCP:${this._currentDc.ipAddress}:${this._currentDc.port}] `;
-    } else {
-      this.log.prefix = "[TCP:disconnected] ";
-    }
-  }
-  setup(crypto2, log) {
-    this._crypto = crypto2;
-    this.log = log.create("tcp");
-    this._updateLogPrefix();
-  }
-  state() {
-    return this._state;
-  }
-  currentDc() {
-    return this._currentDc;
-  }
-  // eslint-disable-next-line unused-imports/no-unused-vars
-  connect(dc, testMode) {
-    if (this._state !== TransportState.Idle) {
-      throw new MtcuteError("Transport is not IDLE");
-    }
-    if (!this.packetCodecInitialized) {
-      this._packetCodec.setup?.(this._crypto, this.log);
-      this._packetCodec.on("error", (err) => this.emit("error", err));
-      this._packetCodec.on("packet", (buf) => this.emit("message", buf));
-      this.packetCodecInitialized = true;
-    }
-    this._state = TransportState.Connecting;
-    this._currentDc = dc;
-    this._updateLogPrefix();
-    this.log.debug("connecting to %j", dc);
-    Bun.connect({
-      hostname: dc.ipAddress,
-      port: dc.port,
-      socket: {
-        open: this.handleConnect.bind(this),
-        error: this.handleError.bind(this),
-        data: (socket, data) => this._packetCodec.feed(data),
-        close: this.close.bind(this),
-        drain: this.handleDrained.bind(this)
-      }
-    }).catch((err) => {
-      this.handleError(null, err);
-      this.close();
-    });
-  }
-  close() {
-    if (this._state === TransportState.Idle) return;
-    this.log.info("connection closed");
-    this._state = TransportState.Idle;
-    this._socket?.end();
-    this._socket = null;
-    this._currentDc = null;
-    this._packetCodec.reset();
-    this._sendOnceDrained = [];
-    this.emit("close");
-  }
-  handleError(socket, error) {
-    this.log.error("error: %s", error.stack);
-    if (this.listenerCount("error") > 0) {
-      this.emit("error", error);
-    }
-  }
-  handleConnect(socket) {
-    this._socket = socket;
-    this.log.info("connected");
-    Promise.resolve(this._packetCodec.tag()).then((initialMessage) => {
-      if (initialMessage.length) {
-        this._socket.write(initialMessage);
-        this._state = TransportState.Ready;
-        this.emit("ready");
-      } else {
-        this._state = TransportState.Ready;
-        this.emit("ready");
-      }
-    }).catch((err) => {
-      if (this.listenerCount("error") > 0) {
-        this.emit("error", err);
-      }
-    });
-  }
-  async send(bytes) {
-    const framed = await this._packetCodec.encode(bytes);
-    if (this._state !== TransportState.Ready) {
-      throw new MtcuteError("Transport is not READY");
-    }
-    const written = this._socket.write(framed);
-    if (written < framed.length) {
-      this._sendOnceDrained.push(framed.subarray(written));
-    }
-  }
-  _sendOnceDrained = [];
-  handleDrained() {
-    while (this._sendOnceDrained.length) {
-      const data = this._sendOnceDrained.shift();
-      const written = this._socket.write(data);
-      if (written < data.length) {
-        this._sendOnceDrained.unshift(data.subarray(written));
-        break;
-      }
-    }
-  }
-}
-class TcpTransport extends BaseTcpTransport {
-  _packetCodec = new IntermediatePacketCodec();
-}
-class BaseTelegramClient extends BaseTelegramClient$1 {
-  constructor(opts) {
-    if (!opts.platformless) setPlatform(new BunPlatform());
-    super({
-      crypto: new BunCryptoProvider(),
-      transport: () => new TcpTransport(),
-      ...opts,
-      storage: typeof opts.storage === "string" ? new SqliteStorage(opts.storage) : opts.storage ?? new SqliteStorage("client.session")
-    });
-  }
-}
-class TelegramClient extends TelegramClient$1 {
-  constructor(opts) {
-    if ("client" in opts) {
-      super(opts);
-      return;
-    }
-    super({
-      client: new BaseTelegramClient(opts),
-      disableUpdates: opts.disableUpdates,
-      skipConversationUpdates: opts.skipConversationUpdates,
-      updates: opts.updates
-    });
-  }
-  _rl;
-  /**
-   * Tiny wrapper over Node `readline` package
-   * for simpler user input for `.start()` method.
-   *
-   * Associated `readline` interface is closed
-   * after `start()` returns, or with the client.
-   *
-   * @param text  Text of the question
-   */
-  input(text) {
-    if (!this._rl) {
-      this._rl = createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-    }
-    return new Promise((res) => this._rl?.question(text, res));
-  }
-  close() {
-    this._rl?.close();
-    return super.close();
-  }
-  start(params = {}) {
-    if (!params.botToken) {
-      if (!params.phone) params.phone = () => this.input("phone > ");
-      if (!params.code) params.code = () => this.input("code > ");
-      if (!params.password) {
-        params.password = () => this.input("2fa password > ");
-      }
-    }
-    return super.start(params).then((user) => {
-      if (this._rl) {
-        this._rl.close();
-        delete this._rl;
-      }
-      return user;
-    });
-  }
-  run(params, then) {
-    if (typeof params === "function") {
-      then = params;
-      params = {};
-    }
-    this.start(params).then(then).catch((err) => this.emitError(err));
-  }
-  downloadToFile(filename, location, params) {
-    return downloadToFile(this, filename, location, params);
-  }
-  downloadAsNodeStream(location, params) {
-    return downloadAsNodeStream(this, location, params);
-  }
-}
-let _registered = false;
-class TelegramWorker extends TelegramWorker$1 {
-  registerWorker(handler) {
-    if (!parentPort) {
-      throw new Error("TelegramWorker must be created from a worker thread");
-    }
-    if (_registered) {
-      throw new Error("TelegramWorker must be created only once");
-    }
-    _registered = true;
-    const port = parentPort;
-    const respond = port.postMessage.bind(port);
-    parentPort.on("message", (message) => handler(message, respond));
-    return respond;
-  }
-}
-class TelegramWorkerPort extends TelegramWorkerPort$1 {
-  constructor(options) {
-    setPlatform(new BunPlatform());
-    super(options);
-    this.options = options;
-  }
-  connectToWorker(worker, handler) {
-    if (!(worker instanceof Worker)) {
-      throw new TypeError("Only worker_threads are supported");
-    }
-    const send = worker.postMessage.bind(worker);
-    worker.on("message", handler);
-    return [
-      send,
-      () => {
-        worker.off("message", handler);
-      }
-    ];
-  }
-}
+import { SqliteStorageDriver } from "./sqlite/driver.js";
+import { HttpProxyConnectionError, SocksProxyConnectionError } from "@fuman/net";
 export {
-  BaseTcpTransport,
   BaseTelegramClient,
   BunCryptoProvider,
   BunPlatform,
+  HttpProxyConnectionError,
+  HttpProxyTcpTransport,
+  MtProxyTcpTransport,
+  SocksProxyConnectionError,
+  SocksProxyTcpTransport,
   SqliteStorage,
   SqliteStorageDriver,
   TcpTransport,

package/{chunks/es/BmtxbrWZ.js → methods/download-file.js}

@@ -1,7 +1,6 @@
 import { unlinkSync } from "node:fs";
 import { FileLocation } from "@mtcute/core";
-import { downloadAsIterable, downloadAsStream } from "@mtcute/core/methods.js";
-import { Readable } from "node:stream";
+import { downloadAsIterable } from "@mtcute/core/methods.js";
 async function downloadToFile(client, filename, location, params) {
   if (location instanceof FileLocation && ArrayBuffer.isView(location.location)) {
     await Bun.write(filename, location.location);
@@ -20,10 +19,6 @@ async function downloadToFile(client, filename, location, params) {
   }
   await output.end();
 }
-function downloadAsNodeStream(client, location, params) {
-  return Readable.fromWeb(downloadAsStream(client, location, params));
-}
 export {
-  downloadAsNodeStream,
   downloadToFile
 };

package/methods/download-node-stream.d.ts

@@ -1,5 +1,5 @@
-import { Readable } from 'node:stream';
 import { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
+import { Readable } from 'node:stream';
 /**
  * Download a remote file as a Node.js Readable stream
  * (discouraged under Bun, since Web Streams are first-class).

package/methods/download-node-stream.js

@@ -0,0 +1,8 @@
+import { Readable } from "node:stream";
+import { downloadAsStream } from "@mtcute/core/methods.js";
+function downloadAsNodeStream(client, location, params) {
+  return Readable.fromWeb(downloadAsStream(client, location, params));
+}
+export {
+  downloadAsNodeStream
+};

package/methods.js

@@ -1,4 +1,5 @@
-import { downloadAsNodeStream, downloadToFile } from "./chunks/es/BmtxbrWZ.js";
+import { downloadToFile } from "./methods/download-file.js";
+import { downloadAsNodeStream } from "./methods/download-node-stream.js";
 export * from "@mtcute/core/methods.js";
 export {
   downloadAsNodeStream,

package/package.json

@@ -1,11 +1,19 @@
 {
     "name": "@mtcute/bun",
     "type": "module",
-    "version": "0.17.0",
+    "version": "0.18.0",
     "description": "Meta-package for Bun",
-    "author": "alina sireneva <alina@tei.su>",
     "license": "MIT",
-    "sideEffects": false,
+    "dependencies": {
+        "@mtcute/core": "^0.18.0",
+        "@mtcute/html-parser": "^0.18.0",
+        "@mtcute/markdown-parser": "^0.18.0",
+        "@mtcute/wasm": "^0.18.0",
+        "@fuman/utils": "0.0.4",
+        "@fuman/bun": "0.0.4",
+        "@fuman/net": "0.0.4",
+        "@fuman/io": "0.0.4"
+    },
     "exports": {
         ".": {
             "import": {
@@ -38,16 +46,12 @@
             }
         }
     },
-    "scripts": {},
-    "dependencies": {
-        "@mtcute/core": "^0.17.0",
-        "@mtcute/html-parser": "^0.17.0",
-        "@mtcute/markdown-parser": "^0.17.0",
-        "@mtcute/wasm": "^0.17.0"
-    },
+    "author": "alina sireneva <alina@tei.su>",
+    "sideEffects": false,
     "homepage": "https://mtcute.dev",
     "repository": {
         "type": "git",
-        "url": "https://github.com/mtcute/mtcute"
-    }
+        "url": "git+https://github.com/mtcute/mtcute.git"
+    },
+    "scripts": {}
 }

package/platform.d.ts

@@ -1,6 +1,11 @@
-import { NodePlatform } from './common-internals-node/platform.js';
+import { ICorePlatform } from '@mtcute/core';
+import { beforeExit } from './utils/exit-hook.js';
+import { defaultLoggingHandler } from './utils/logging.js';
 import { normalizeFile } from './utils/normalize-file.js';
-export declare class BunPlatform extends NodePlatform {
+export declare class BunPlatform implements ICorePlatform {
+    log: typeof defaultLoggingHandler;
+    beforeExit: typeof beforeExit;
     normalizeFile: typeof normalizeFile;
     getDeviceModel(): string;
+    getDefaultLogLevel(): number | null;
 }

package/platform.js

@@ -0,0 +1,22 @@
+import * as os from "node:os";
+import { beforeExit } from "./utils/exit-hook.js";
+import { defaultLoggingHandler } from "./utils/logging.js";
+import { normalizeFile } from "./utils/normalize-file.js";
+class BunPlatform {
+  getDeviceModel() {
+    return `Bun/${Bun.version} (${os.type()} ${os.arch()})`;
+  }
+  getDefaultLogLevel() {
+    const envLogLevel = Number.parseInt(process.env.MTCUTE_LOG_LEVEL ?? "");
+    if (!Number.isNaN(envLogLevel)) {
+      return envLogLevel;
+    }
+    return null;
+  }
+}
+BunPlatform.prototype.normalizeFile = normalizeFile;
+BunPlatform.prototype.log = defaultLoggingHandler;
+BunPlatform.prototype.beforeExit = beforeExit;
+export {
+  BunPlatform
+};

package/sqlite/driver.js

@@ -0,0 +1,19 @@
+import { BaseSqliteStorageDriver } from "@mtcute/core";
+import { Database } from "bun:sqlite";
+class SqliteStorageDriver extends BaseSqliteStorageDriver {
+  constructor(filename = ":memory:", params) {
+    super();
+    this.filename = filename;
+    this.params = params;
+  }
+  _createDatabase() {
+    const db = new Database(this.filename);
+    if (!this.params?.disableWal) {
+      db.exec("PRAGMA journal_mode = WAL;");
+    }
+    return db;
+  }
+}
+export {
+  SqliteStorageDriver
+};

package/sqlite/index.d.ts

@@ -1,5 +1,5 @@
-import { BaseSqliteStorage } from '@mtcute/core';
 import { SqliteStorageDriverOptions } from './driver.js';
+import { BaseSqliteStorage } from '@mtcute/core';
 export { SqliteStorageDriver } from './driver.js';
 export declare class SqliteStorage extends BaseSqliteStorage {
     readonly filename: string;

package/sqlite/index.js

@@ -0,0 +1,13 @@
+import { BaseSqliteStorage } from "@mtcute/core";
+import { SqliteStorageDriver } from "./driver.js";
+class SqliteStorage extends BaseSqliteStorage {
+  constructor(filename = ":memory:", params) {
+    super(new SqliteStorageDriver(filename, params));
+    this.filename = filename;
+    this.params = params;
+  }
+}
+export {
+  SqliteStorage,
+  SqliteStorageDriver
+};

package/utils/crypto.js

@@ -0,0 +1,77 @@
+import { pbkdf2 } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { deflateSync, gunzipSync } from "node:zlib";
+import { u8 } from "@fuman/utils";
+import { BaseCryptoProvider } from "@mtcute/core/utils.js";
+import { initSync, ige256Decrypt, ige256Encrypt, createCtr256, freeCtr256, ctr256 } from "@mtcute/wasm";
+class BunCryptoProvider extends BaseCryptoProvider {
+  async initialize() {
+    const wasmFile = require.resolve("@mtcute/wasm/mtcute.wasm");
+    const wasm = await readFile(wasmFile);
+    initSync(wasm);
+  }
+  createAesIge(key, iv) {
+    return {
+      encrypt(data) {
+        return ige256Encrypt(data, key, iv);
+      },
+      decrypt(data) {
+        return ige256Decrypt(data, key, iv);
+      }
+    };
+  }
+  createAesCtr(key, iv) {
+    const ctx = createCtr256(key, iv);
+    return {
+      process: (data) => ctr256(ctx, data),
+      close: () => freeCtr256(ctx)
+    };
+  }
+  pbkdf2(password, salt, iterations, keylen = 64, algo = "sha512") {
+    return new Promise(
+      (resolve, reject) => pbkdf2(password, salt, iterations, keylen, algo, (err, buf) => err !== null ? reject(err) : resolve(buf))
+    );
+  }
+  sha1(data) {
+    const res = u8.alloc(Bun.SHA1.byteLength);
+    Bun.SHA1.hash(data, res);
+    return res;
+  }
+  sha256(data) {
+    const res = u8.alloc(Bun.SHA256.byteLength);
+    Bun.SHA256.hash(data, res);
+    return res;
+  }
+  async hmacSha256(data, key) {
+    const keyMaterial = await crypto.subtle.importKey(
+      "raw",
+      key,
+      { name: "HMAC", hash: { name: "SHA-256" } },
+      false,
+      ["sign"]
+    );
+    const res = await crypto.subtle.sign({ name: "HMAC" }, keyMaterial, data);
+    return new Uint8Array(res);
+  }
+  gzip(data, maxSize) {
+    try {
+      return deflateSync(data, {
+        maxOutputLength: maxSize
+      });
+    } catch (e) {
+      if (e.code === "ERR_BUFFER_TOO_LARGE") {
+        return null;
+      }
+      throw e;
+    }
+  }
+  gunzip(data) {
+    return gunzipSync(data);
+  }
+  randomFill(buf) {
+    crypto.getRandomValues(buf);
+  }
+}
+export {
+  BunCryptoProvider
+};

package/utils/exit-hook.js

@@ -0,0 +1,41 @@
+let installed = false;
+let handled = false;
+const callbacks = /* @__PURE__ */ new Set();
+const myHandlers = /* @__PURE__ */ new Map();
+function register(shouldManuallyExit, signal, event) {
+  function eventHandler() {
+    if (handled) {
+      return;
+    }
+    handled = true;
+    for (const callback of callbacks) {
+      callback();
+    }
+    for (const [event2, handler] of myHandlers) {
+      process.off(event2, handler);
+    }
+    if (shouldManuallyExit) {
+      process.kill(process.pid, signal);
+    }
+  }
+  process.on(event, eventHandler);
+  myHandlers.set(event, eventHandler);
+}
+function beforeExit(fn) {
+  if (typeof process === "undefined") return () => {
+  };
+  if (!installed) {
+    installed = true;
+    register(true, 0, "beforeExit");
+    register(true, 2, "SIGINT");
+    register(true, 15, "SIGTERM");
+    register(false, 15, "exit");
+  }
+  callbacks.add(fn);
+  return () => {
+    callbacks.delete(fn);
+  };
+}
+export {
+  beforeExit
+};

package/utils/logging.js

@@ -0,0 +1,28 @@
+const isTty = typeof process === "object" && Boolean(process.stdout?.isTTY);
+const BASE_FORMAT = isTty ? "%s [%s] [%s%s\x1B[0m] " : "%s [%s] [%s] ";
+const LEVEL_NAMES = isTty ? [
+  "",
+  // OFF
+  "\x1B[31mERR\x1B[0m",
+  "\x1B[33mWRN\x1B[0m",
+  "\x1B[34mINF\x1B[0m",
+  "\x1B[36mDBG\x1B[0m",
+  "\x1B[35mVRB\x1B[0m"
+] : [
+  "",
+  // OFF
+  "ERR",
+  "WRN",
+  "INF",
+  "DBG",
+  "VRB"
+];
+const TAG_COLORS = [6, 2, 3, 4, 5, 1].map((i) => `\x1B[3${i};1m`);
+const defaultLoggingHandler = isTty ? (color, level, tag, fmt, args) => {
+  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], TAG_COLORS[color], tag, ...args);
+} : (color, level, tag, fmt, args) => {
+  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], tag, ...args);
+};
+export {
+  defaultLoggingHandler
+};

package/utils/normalize-file.js

@@ -0,0 +1,37 @@
+import { ReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { Readable } from "node:stream";
+function isBunFile(file) {
+  return file instanceof Blob && "name" in file && file.name.length > 0;
+}
+async function normalizeFile(file) {
+  if (typeof file === "string") {
+    file = Bun.file(file);
+  }
+  if (isBunFile(file)) {
+    return {
+      file,
+      fileName: file.name,
+      fileSize: file.size
+    };
+  }
+  if (file instanceof ReadStream) {
+    const fileName = basename(file.path.toString());
+    const fileSize = await stat(file.path.toString()).then((stat2) => stat2.size);
+    return {
+      file: Readable.toWeb(file),
+      fileName,
+      fileSize
+    };
+  }
+  if (file instanceof Readable) {
+    return {
+      file: Readable.toWeb(file)
+    };
+  }
+  return null;
+}
+export {
+  normalizeFile
+};

package/utils/proxies.d.ts

@@ -0,0 +1,27 @@
+import { HttpProxySettings as FumanHttpProxySettings, ITcpConnection, SocksProxySettings, TcpEndpoint } from '@fuman/net';
+import { BasicDcOption } from '@mtcute/core/utils.js';
+import { BaseMtProxyTransport, IntermediatePacketCodec, ITelegramConnection, TelegramTransport } from '@mtcute/core';
+export type { SocksProxySettings } from '@fuman/net';
+export { HttpProxyConnectionError, SocksProxyConnectionError } from '@fuman/net';
+export type { MtProxySettings } from '@mtcute/core';
+export interface HttpProxySettings extends FumanHttpProxySettings {
+    /**
+     * Whether this is a HTTPS proxy (by default it is regular HTTP).
+     */
+    tls?: boolean;
+}
+export declare class HttpProxyTcpTransport implements TelegramTransport {
+    readonly proxy: HttpProxySettings;
+    constructor(proxy: HttpProxySettings);
+    connect(dc: BasicDcOption): Promise<ITelegramConnection>;
+    packetCodec(): IntermediatePacketCodec;
+}
+export declare class SocksProxyTcpTransport implements TelegramTransport {
+    readonly proxy: SocksProxySettings;
+    constructor(proxy: SocksProxySettings);
+    connect(dc: BasicDcOption): Promise<ITelegramConnection>;
+    packetCodec(): IntermediatePacketCodec;
+}
+export declare class MtProxyTcpTransport extends BaseMtProxyTransport {
+    _connectTcp(endpoint: TcpEndpoint): Promise<ITcpConnection>;
+}

package/utils/proxies.js

@@ -0,0 +1,62 @@
+import { connectTls, connectTcp } from "@fuman/bun";
+import { performHttpProxyHandshake, performSocksHandshake } from "@fuman/net";
+import { HttpProxyConnectionError, SocksProxyConnectionError } from "@fuman/net";
+import { IntermediatePacketCodec, BaseMtProxyTransport } from "@mtcute/core";
+class HttpProxyTcpTransport {
+  constructor(proxy) {
+    this.proxy = proxy;
+  }
+  async connect(dc) {
+    let conn;
+    if (this.proxy.tls) {
+      conn = await connectTls({
+        address: this.proxy.host,
+        port: this.proxy.port
+      });
+    } else {
+      conn = await connectTcp({
+        address: this.proxy.host,
+        port: this.proxy.port
+      });
+    }
+    await performHttpProxyHandshake(conn, conn, this.proxy, {
+      address: dc.ipAddress,
+      port: dc.port
+    });
+    return conn;
+  }
+  packetCodec() {
+    return new IntermediatePacketCodec();
+  }
+}
+class SocksProxyTcpTransport {
+  constructor(proxy) {
+    this.proxy = proxy;
+  }
+  async connect(dc) {
+    const conn = await connectTcp({
+      address: this.proxy.host,
+      port: this.proxy.port
+    });
+    await performSocksHandshake(conn, conn, this.proxy, {
+      address: dc.ipAddress,
+      port: dc.port
+    });
+    return conn;
+  }
+  packetCodec() {
+    return new IntermediatePacketCodec();
+  }
+}
+class MtProxyTcpTransport extends BaseMtProxyTransport {
+  async _connectTcp(endpoint) {
+    return connectTcp(endpoint);
+  }
+}
+export {
+  HttpProxyConnectionError,
+  HttpProxyTcpTransport,
+  MtProxyTcpTransport,
+  SocksProxyConnectionError,
+  SocksProxyTcpTransport
+};

package/utils/tcp.d.ts

@@ -1,31 +1,7 @@
-import { default as EventEmitter } from 'events';
-import { Socket } from 'bun';
-import { IPacketCodec, ITelegramTransport, IntermediatePacketCodec, TransportState } from '@mtcute/core';
-import { BasicDcOption, ICryptoProvider, Logger } from '@mtcute/core/utils.js';
-/**
- * Base for TCP transports.
- * Subclasses must provide packet codec in `_packetCodec` property
- */
-export declare abstract class BaseTcpTransport extends EventEmitter implements ITelegramTransport {
-    protected _currentDc: BasicDcOption | null;
-    protected _state: TransportState;
-    protected _socket: Socket | null;
-    abstract _packetCodec: IPacketCodec;
-    protected _crypto: ICryptoProvider;
-    protected log: Logger;
-    packetCodecInitialized: boolean;
-    private _updateLogPrefix;
-    setup(crypto: ICryptoProvider, log: Logger): void;
-    state(): TransportState;
-    currentDc(): BasicDcOption | null;
-    connect(dc: BasicDcOption, testMode: boolean): void;
-    close(): void;
-    handleError(socket: unknown, error: Error): void;
-    handleConnect(socket: Socket): void;
-    send(bytes: Uint8Array): Promise<void>;
-    private _sendOnceDrained;
-    private handleDrained;
-}
-export declare class TcpTransport extends BaseTcpTransport {
-    _packetCodec: IntermediatePacketCodec;
+import { ITcpConnection } from '@fuman/net';
+import { BasicDcOption } from '@mtcute/core/utils.js';
+import { IntermediatePacketCodec, TelegramTransport } from '@mtcute/core';
+export declare class TcpTransport implements TelegramTransport {
+    connect(dc: BasicDcOption): Promise<ITcpConnection>;
+    packetCodec(): IntermediatePacketCodec;
 }

package/utils/tcp.js

@@ -0,0 +1,13 @@
+import { connectTcp } from "@fuman/bun";
+import { IntermediatePacketCodec } from "@mtcute/core";
+class TcpTransport {
+  connect(dc) {
+    return connectTcp({ address: dc.ipAddress, port: dc.port });
+  }
+  packetCodec() {
+    return new IntermediatePacketCodec();
+  }
+}
+export {
+  TcpTransport
+};

package/worker.d.ts

@@ -1,10 +1,12 @@
-import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
-export type { TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods };
+import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
+export type { TelegramWorkerOptions, WorkerCustomMethods };
+export interface TelegramWorkerPortOptions {
+    worker: SomeWorker;
+}
 export declare class TelegramWorker<T extends WorkerCustomMethods> extends TelegramWorkerBase<T> {
     registerWorker(handler: WorkerMessageHandler): RespondFn;
 }
 export declare class TelegramWorkerPort<T extends WorkerCustomMethods> extends TelegramWorkerPortBase<T> {
-    readonly options: TelegramWorkerPortOptions;
     constructor(options: TelegramWorkerPortOptions);
     connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
 }

package/worker.js

@@ -0,0 +1,44 @@
+import { parentPort, Worker } from "node:worker_threads";
+import { TelegramWorker as TelegramWorker$1, TelegramWorkerPort as TelegramWorkerPort$1 } from "@mtcute/core/worker.js";
+import { BunPlatform } from "./platform.js";
+let _registered = false;
+class TelegramWorker extends TelegramWorker$1 {
+  registerWorker(handler) {
+    if (!parentPort) {
+      throw new Error("TelegramWorker must be created from a worker thread");
+    }
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    const port = parentPort;
+    const respond = port.postMessage.bind(port);
+    parentPort.on("message", (message) => handler(message, respond));
+    return respond;
+  }
+}
+class TelegramWorkerPort extends TelegramWorkerPort$1 {
+  constructor(options) {
+    super({
+      worker: options.worker,
+      platform: new BunPlatform()
+    });
+  }
+  connectToWorker(worker, handler) {
+    if (!(worker instanceof Worker)) {
+      throw new TypeError("Only worker_threads are supported");
+    }
+    const send = worker.postMessage.bind(worker);
+    worker.on("message", handler);
+    return [
+      send,
+      () => {
+        worker.off("message", handler);
+      }
+    ];
+  }
+}
+export {
+  TelegramWorker,
+  TelegramWorkerPort
+};

package/common-internals-node/platform.d.ts

@@ -1,18 +0,0 @@
-import { ICorePlatform } from '@mtcute/core/platform.js';
-import { normalizeFile } from '../utils/normalize-file.js';
-import { beforeExit } from './exit-hook.js';
-import { defaultLoggingHandler } from './logging.js';
-export declare class NodePlatform implements ICorePlatform {
-    log: typeof defaultLoggingHandler;
-    beforeExit: typeof beforeExit;
-    normalizeFile: typeof normalizeFile;
-    getDeviceModel(): string;
-    getDefaultLogLevel(): number | null;
-    utf8ByteLength(str: string): number;
-    utf8Encode(str: string): Uint8Array;
-    utf8Decode(buf: Uint8Array): string;
-    hexEncode(buf: Uint8Array): string;
-    hexDecode(str: string): Uint8Array;
-    base64Encode(buf: Uint8Array, url?: boolean): string;
-    base64Decode(string: string, url?: boolean): Uint8Array;
-}

package/index.d.cts

@@ -1,9 +0,0 @@
-export * from './client.js';
-export * from './platform.js';
-export * from './sqlite/index.js';
-export * from './utils/crypto.js';
-export * from './utils/tcp.js';
-export * from './worker.js';
-export * from '@mtcute/core';
-export * from '@mtcute/html-parser';
-export * from '@mtcute/markdown-parser';

package/methods.d.cts

@@ -1,3 +0,0 @@
-export { downloadToFile } from './methods/download-file.js';
-export { downloadAsNodeStream } from './methods/download-node-stream.js';
-export * from '@mtcute/core/methods.js';

package/utils.d.cts

@@ -1 +0,0 @@
-export * from '@mtcute/core/utils.js';