@mtcute/node 0.16.13 → 0.18.0-rc.5

package/client.cjs

@@ -0,0 +1,101 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_readline = require("node:readline");
+const utils = require("@fuman/utils");
+const client_js = require("@mtcute/core/client.js");
+const downloadFile = require("./methods/download-file.cjs");
+const downloadNodeStream = require("./methods/download-node-stream.cjs");
+const index = require("./sqlite/index.cjs");
+const crypto = require("./utils/crypto.cjs");
+const platform = require("./utils/platform.cjs");
+const tcp = require("./utils/tcp.cjs");
+let nativeCrypto;
+try {
+  nativeCrypto = require("@mtcute/crypto-node").NodeNativeCryptoProvider;
+} catch {
+}
+class BaseTelegramClient extends client_js.BaseTelegramClient {
+  constructor(opts) {
+    super({
+      // eslint-disable-next-line
+      crypto: nativeCrypto ? new nativeCrypto() : new crypto.NodeCryptoProvider(),
+      transport: new tcp.TcpTransport(),
+      platform: new platform.NodePlatform(),
+      ...opts,
+      storage: typeof opts.storage === "string" ? new index.SqliteStorage(opts.storage) : opts.storage ?? new index.SqliteStorage("client.session")
+    });
+  }
+}
+class TelegramClient extends client_js.TelegramClient {
+  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 = node_readline.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(utils.unknownToError(err)));
+  }
+  downloadToFile(filename, location, params) {
+    return downloadFile.downloadToFile(this, filename, location, params);
+  }
+  downloadAsNodeStream(location, params) {
+    return downloadNodeStream.downloadAsNodeStream(this, location, params);
+  }
+}
+exports.BaseTelegramClient = BaseTelegramClient;
+exports.TelegramClient = TelegramClient;

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,96 @@
+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 { SqliteStorage } from "./sqlite/index.js";
+import { NodeCryptoProvider } from "./utils/crypto.js";
+import { NodePlatform } from "./utils/platform.js";
+import { TcpTransport } from "./utils/tcp.js";
+let nativeCrypto;
+try {
+  nativeCrypto = (await import("@mtcute/crypto-node")).NodeNativeCryptoProvider;
+} catch {
+}
+class BaseTelegramClient extends BaseTelegramClient$1 {
+  constructor(opts) {
+    super({
+      // eslint-disable-next-line
+      crypto: nativeCrypto ? new nativeCrypto() : new NodeCryptoProvider(),
+      transport: new TcpTransport(),
+      platform: new NodePlatform(),
+      ...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.cjs

@@ -1,434 +1,40 @@
 if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
   globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
-  console.warn("[@mtcute/node] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
-  console.warn("[@mtcute/node] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
 }
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const node_readline = require("node:readline");
-const client_js = require("@mtcute/core/client.js");
-const platform_js = require("@mtcute/core/platform.js");
-const os = require("node:os");
-const node_fs = require("node:fs");
-const promises = require("node:fs/promises");
-const node_path = require("node:path");
-const node_stream = require("node:stream");
-const streamUtils = require("./chunks/cjs/HP2yqAk_.js");
-const downloadNodeStream = require("./chunks/cjs/BpvQ752Q.js");
+const client = require("./client.cjs");
+const index = require("./sqlite/index.cjs");
+const platform = require("./utils/platform.cjs");
+const proxies = require("./utils/proxies.cjs");
+const tcp = require("./utils/tcp.cjs");
+const worker = require("./worker.cjs");
 const core = require("@mtcute/core");
-const sqlite3 = require("better-sqlite3");
-const crypto = require("./chunks/cjs/D7i-4e0W.js");
-const EventEmitter = require("node:events");
-const node_net = require("node:net");
-const node_worker_threads = require("node:worker_threads");
-const worker_js = require("@mtcute/core/worker.js");
 const htmlParser = require("@mtcute/html-parser");
 const markdownParser = require("@mtcute/markdown-parser");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
-async function normalizeFile(file) {
-  if (typeof file === "string") {
-    file = node_fs.createReadStream(file);
-  }
-  if (file instanceof node_fs.ReadStream) {
-    const fileName = node_path.basename(file.path.toString());
-    const fileSize = await promises.stat(file.path.toString()).then((stat2) => stat2.size);
-    return {
-      file: streamUtils.nodeStreamToWeb(file),
-      fileName,
-      fileSize
-    };
-  }
-  if (file instanceof node_stream.Readable) {
-    return {
-      file: streamUtils.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__namespace.type()} ${os__namespace.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;
-class SqliteStorageDriver extends core.BaseSqliteStorageDriver {
-  constructor(filename = ":memory:", params) {
-    super();
-    this.filename = filename;
-    this.params = params;
-  }
-  _createDatabase() {
-    const db = sqlite3(this.filename, {
-      ...this.params?.options,
-      verbose: this._log.mgr.level >= 5 ? this._log.verbose : void 0
-    });
-    if (!this.params?.disableWal) {
-      db.pragma("journal_mode = WAL");
-    }
-    return db;
-  }
-}
-class SqliteStorage extends core.BaseSqliteStorage {
-  constructor(filename = ":memory:", params) {
-    super(new SqliteStorageDriver(filename, params));
-    this.filename = filename;
-    this.params = params;
-  }
-}
-class BaseTcpTransport extends EventEmitter {
-  _currentDc = null;
-  _state = core.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 !== core.TransportState.Idle) {
-      throw new core.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 = core.TransportState.Connecting;
-    this._currentDc = dc;
-    this._updateLogPrefix();
-    this.log.debug("connecting to %j", dc);
-    this._socket = node_net.connect(dc.port, dc.ipAddress, this.handleConnect.bind(this));
-    this._socket.on("data", (data) => {
-      this._packetCodec.feed(data);
-    });
-    this._socket.on("error", this.handleError.bind(this));
-    this._socket.on("close", this.close.bind(this));
-  }
-  close() {
-    if (this._state === core.TransportState.Idle) return;
-    this.log.info("connection closed");
-    this._state = core.TransportState.Idle;
-    this._socket.removeAllListeners();
-    this._socket.destroy();
-    this._socket = null;
-    this._currentDc = null;
-    this._packetCodec.reset();
-    this.emit("close");
-  }
-  handleError(error) {
-    this.log.error("error: %s", error.stack);
-    if (this.listenerCount("error") > 0) {
-      this.emit("error", error);
-    }
-  }
-  handleConnect() {
-    this.log.info("connected");
-    Promise.resolve(this._packetCodec.tag()).then((initialMessage) => {
-      if (initialMessage.length) {
-        this._socket.write(initialMessage, (err) => {
-          if (err) {
-            this.log.error("failed to write initial message: %s", err.stack);
-            this.emit("error");
-            this.close();
-          } else {
-            this._state = core.TransportState.Ready;
-            this.emit("ready");
-          }
-        });
-      } else {
-        this._state = core.TransportState.Ready;
-        this.emit("ready");
-      }
-    }).catch((err) => this.emit("error", err));
-  }
-  async send(bytes) {
-    const framed = await this._packetCodec.encode(bytes);
-    if (this._state !== core.TransportState.Ready) {
-      throw new core.MtcuteError("Transport is not READY");
-    }
-    return new Promise((resolve, reject) => {
-      this._socket.write(framed, (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-}
-class TcpTransport extends BaseTcpTransport {
-  _packetCodec = new core.IntermediatePacketCodec();
-}
-let nativeCrypto;
-try {
-  nativeCrypto = require("@mtcute/crypto-node").NodeNativeCryptoProvider;
-} catch {
-}
-class BaseTelegramClient extends client_js.BaseTelegramClient {
-  constructor(opts) {
-    if (!opts.platformless) platform_js.setPlatform(new NodePlatform());
-    super({
-      // eslint-disable-next-line
-      crypto: nativeCrypto ? new nativeCrypto() : new crypto.NodeCryptoProvider(),
-      transport: () => new TcpTransport(),
-      ...opts,
-      storage: typeof opts.storage === "string" ? new SqliteStorage(opts.storage) : opts.storage ?? new SqliteStorage("client.session")
-    });
-  }
-}
-class TelegramClient extends client_js.TelegramClient {
-  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 = node_readline.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 downloadNodeStream.downloadToFile(this, filename, location, params);
-  }
-  downloadAsNodeStream(location, params) {
-    return downloadNodeStream.downloadAsNodeStream(this, location, params);
-  }
-}
-let _registered = false;
-class TelegramWorker extends worker_js.TelegramWorker {
-  registerWorker(handler) {
-    if (!node_worker_threads.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 = node_worker_threads.parentPort;
-    const respond = port.postMessage.bind(port);
-    node_worker_threads.parentPort.on("message", (message) => handler(message, respond));
-    return respond;
-  }
-}
-class TelegramWorkerPort extends worker_js.TelegramWorkerPort {
-  constructor(options) {
-    platform_js.setPlatform(new NodePlatform());
-    super(options);
-    this.options = options;
-  }
-  connectToWorker(worker, handler) {
-    if (!(worker instanceof node_worker_threads.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);
-      }
-    ];
-  }
-}
-exports.BaseTcpTransport = BaseTcpTransport;
-exports.BaseTelegramClient = BaseTelegramClient;
-exports.NodePlatform = NodePlatform;
-exports.SqliteStorage = SqliteStorage;
-exports.SqliteStorageDriver = SqliteStorageDriver;
-exports.TcpTransport = TcpTransport;
-exports.TelegramClient = TelegramClient;
-exports.TelegramWorker = TelegramWorker;
-exports.TelegramWorkerPort = TelegramWorkerPort;
+const driver = require("./sqlite/driver.cjs");
+const net = require("@fuman/net");
+exports.BaseTelegramClient = client.BaseTelegramClient;
+exports.TelegramClient = client.TelegramClient;
+exports.SqliteStorage = index.SqliteStorage;
+exports.NodePlatform = platform.NodePlatform;
+exports.HttpProxyTcpTransport = proxies.HttpProxyTcpTransport;
+exports.MtProxyTcpTransport = proxies.MtProxyTcpTransport;
+exports.SocksProxyTcpTransport = proxies.SocksProxyTcpTransport;
+exports.TcpTransport = tcp.TcpTransport;
+exports.TelegramWorker = worker.TelegramWorker;
+exports.TelegramWorkerPort = worker.TelegramWorkerPort;
+exports.SqliteStorageDriver = driver.SqliteStorageDriver;
+Object.defineProperty(exports, "HttpProxyConnectionError", {
+  enumerable: true,
+  get: () => net.HttpProxyConnectionError
+});
+Object.defineProperty(exports, "SocksProxyConnectionError", {
+  enumerable: true,
+  get: () => net.SocksProxyConnectionError
+});
 Object.keys(core).forEach((k) => {
   if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,

package/index.d.ts

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