@mtcute/node 0.16.13 → 0.18.0-rc.5

package/{chunks/cjs/D7i-4e0W.js → utils/crypto.cjs}

@@ -1,9 +1,10 @@
 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_crypto = require("node:crypto");
 const promises = require("node:fs/promises");
 const node_module = require("node:module");
@@ -54,7 +55,7 @@ class BaseNodeCryptoProvider extends utils_js.BaseCryptoProvider {
 }
 class NodeCryptoProvider extends BaseNodeCryptoProvider {
   async initialize() {
-    const require$1 = node_module.createRequire(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.src || new URL("chunks/cjs/D7i-4e0W.js", document.baseURI).href);
+    const require$1 = node_module.createRequire(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("utils/crypto.cjs", document.baseURI).href);
     const wasmFile = require$1.resolve("@mtcute/wasm/mtcute.wasm");
     const wasm$1 = await promises.readFile(wasmFile);
     wasm.initSync(wasm$1);

package/{chunks/es/HZgHrOPU.js → utils/crypto.js}

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { deflateSync, gunzipSync } from "node:zlib";
 import { BaseCryptoProvider } from "@mtcute/core/utils.js";
-import { initSync, ige256Encrypt, ige256Decrypt } from "@mtcute/wasm";
+import { initSync, ige256Decrypt, ige256Encrypt } from "@mtcute/wasm";
 class BaseNodeCryptoProvider extends BaseCryptoProvider {
   createAesCtr(key, iv) {
     const cipher = createCipheriv(`aes-${key.length * 8}-ctr`, key, iv);

package/utils/exit-hook.cjs

@@ -0,0 +1,46 @@
+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" });
+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);
+  };
+}
+exports.beforeExit = beforeExit;

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.cjs

@@ -0,0 +1,33 @@
+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 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);
+};
+exports.defaultLoggingHandler = defaultLoggingHandler;

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.cjs

@@ -0,0 +1,33 @@
+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_fs = require("node:fs");
+const promises = require("node:fs/promises");
+const node_path = require("node:path");
+const node_stream = require("node:stream");
+const node = require("@fuman/node");
+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: node.nodeReadableToFuman(file),
+      fileName,
+      fileSize
+    };
+  }
+  if (file instanceof node_stream.Readable) {
+    return {
+      file: node.nodeReadableToFuman(file)
+    };
+  }
+  return null;
+}
+exports.normalizeFile = normalizeFile;

package/utils/normalize-file.js

@@ -0,0 +1,28 @@
+import { createReadStream, ReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { Readable } from "node:stream";
+import { nodeReadableToFuman } from "@fuman/node";
+async function normalizeFile(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: nodeReadableToFuman(file),
+      fileName,
+      fileSize
+    };
+  }
+  if (file instanceof Readable) {
+    return {
+      file: nodeReadableToFuman(file)
+    };
+  }
+  return null;
+}
+export {
+  normalizeFile
+};

package/utils/platform.cjs

@@ -0,0 +1,44 @@
+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 os = require("node:os");
+const normalizeFile = require("./normalize-file.cjs");
+const exitHook = require("./exit-hook.cjs");
+const logging = require("./logging.cjs");
+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);
+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;
+  }
+}
+NodePlatform.prototype.log = logging.defaultLoggingHandler;
+NodePlatform.prototype.beforeExit = exitHook.beforeExit;
+NodePlatform.prototype.normalizeFile = normalizeFile.normalizeFile;
+exports.NodePlatform = NodePlatform;

package/{common-internals-node → utils}/platform.d.ts

@@ -1,4 +1,4 @@
-import { ICorePlatform } from '@mtcute/core/platform.js';
+import { ICorePlatform } from '@mtcute/core';
 import { normalizeFile } from '../utils/normalize-file.js';
 import { beforeExit } from './exit-hook.js';
 import { defaultLoggingHandler } from './logging.js';
@@ -8,11 +8,4 @@ export declare class NodePlatform implements ICorePlatform {
     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/utils/platform.js

@@ -0,0 +1,22 @@
+import * as os from "node:os";
+import { normalizeFile } from "./normalize-file.js";
+import { beforeExit } from "./exit-hook.js";
+import { defaultLoggingHandler } from "./logging.js";
+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;
+  }
+}
+NodePlatform.prototype.log = defaultLoggingHandler;
+NodePlatform.prototype.beforeExit = beforeExit;
+NodePlatform.prototype.normalizeFile = normalizeFile;
+export {
+  NodePlatform
+};

package/utils/proxies.cjs

@@ -0,0 +1,73 @@
+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 net = require("@fuman/net");
+const node = require("@fuman/node");
+const core = require("@mtcute/core");
+class HttpProxyTcpTransport {
+  constructor(proxy) {
+    this.proxy = proxy;
+  }
+  async connect(dc) {
+    let conn;
+    if (this.proxy.tls) {
+      conn = await node.connectTls({
+        address: this.proxy.host,
+        port: this.proxy.port,
+        extraOptions: this.proxy.tlsOptions
+      });
+    } else {
+      conn = await node.connectTcp({
+        address: this.proxy.host,
+        port: this.proxy.port
+      });
+    }
+    await net.performHttpProxyHandshake(conn, conn, this.proxy, {
+      address: dc.ipAddress,
+      port: dc.port
+    });
+    return conn;
+  }
+  packetCodec() {
+    return new core.IntermediatePacketCodec();
+  }
+}
+class SocksProxyTcpTransport {
+  constructor(proxy) {
+    this.proxy = proxy;
+  }
+  async connect(dc) {
+    const conn = await node.connectTcp({
+      address: this.proxy.host,
+      port: this.proxy.port
+    });
+    await net.performSocksHandshake(conn, conn, this.proxy, {
+      address: dc.ipAddress,
+      port: dc.port
+    });
+    return conn;
+  }
+  packetCodec() {
+    return new core.IntermediatePacketCodec();
+  }
+}
+class MtProxyTcpTransport extends core.BaseMtProxyTransport {
+  async _connectTcp(endpoint) {
+    return node.connectTcp(endpoint);
+  }
+}
+Object.defineProperty(exports, "HttpProxyConnectionError", {
+  enumerable: true,
+  get: () => net.HttpProxyConnectionError
+});
+Object.defineProperty(exports, "SocksProxyConnectionError", {
+  enumerable: true,
+  get: () => net.SocksProxyConnectionError
+});
+exports.HttpProxyTcpTransport = HttpProxyTcpTransport;
+exports.MtProxyTcpTransport = MtProxyTcpTransport;
+exports.SocksProxyTcpTransport = SocksProxyTcpTransport;

package/utils/proxies.d.ts

@@ -0,0 +1,34 @@
+import { HttpProxySettings as FumanHttpProxySettings, ITcpConnection, SocksProxySettings, TcpEndpoint } from '@fuman/net';
+import { BasicDcOption } from '@mtcute/core/utils.js';
+import { SecureContextOptions } from 'node:tls';
+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;
+    /**
+     * Additional TLS options, used if `tls = true`.
+     * Can contain stuff like custom certificate, host,
+     * or whatever.
+     */
+    tlsOptions?: SecureContextOptions;
+}
+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,63 @@
+import { performHttpProxyHandshake, performSocksHandshake } from "@fuman/net";
+import { HttpProxyConnectionError, SocksProxyConnectionError } from "@fuman/net";
+import { connectTls, connectTcp } from "@fuman/node";
+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,
+        extraOptions: this.proxy.tlsOptions
+      });
+    } 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.cjs

@@ -0,0 +1,18 @@
+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 = require("@fuman/node");
+const core = require("@mtcute/core");
+class TcpTransport {
+  connect(dc) {
+    return node.connectTcp({ address: dc.ipAddress, port: dc.port });
+  }
+  packetCodec() {
+    return new core.IntermediatePacketCodec();
+  }
+}
+exports.TcpTransport = TcpTransport;

package/utils/tcp.d.ts

@@ -1,29 +1,7 @@
-import { default as EventEmitter } from 'node:events';
-import { Socket } from 'node:net';
-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(error: Error): void;
-    handleConnect(): void;
-    send(bytes: Uint8Array): Promise<void>;
-}
-export declare class TcpTransport extends BaseTcpTransport {
-    _packetCodec: IntermediatePacketCodec;
+import { ITcpConnection } from '@fuman/net';
+import { TelegramTransport, IntermediatePacketCodec } from '@mtcute/core';
+import { BasicDcOption } from '@mtcute/core/utils.js';
+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/node";
+import { IntermediatePacketCodec } from "@mtcute/core";
+class TcpTransport {
+  connect(dc) {
+    return connectTcp({ address: dc.ipAddress, port: dc.port });
+  }
+  packetCodec() {
+    return new IntermediatePacketCodec();
+  }
+}
+export {
+  TcpTransport
+};

package/utils.cjs

@@ -1,17 +1,14 @@
 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 crypto = require("./chunks/cjs/D7i-4e0W.js");
-const streamUtils = require("./chunks/cjs/HP2yqAk_.js");
+const crypto = require("./utils/crypto.cjs");
 const utils_js = require("@mtcute/core/utils.js");
 exports.BaseNodeCryptoProvider = crypto.BaseNodeCryptoProvider;
 exports.NodeCryptoProvider = crypto.NodeCryptoProvider;
-exports.nodeStreamToWeb = streamUtils.nodeStreamToWeb;
-exports.webStreamToNode = streamUtils.webStreamToNode;
 Object.keys(utils_js).forEach((k) => {
   if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,

package/utils.d.ts

@@ -1,3 +1,2 @@
 export * from './utils/crypto.js';
-export * from './utils/stream-utils.js';
 export * from '@mtcute/core/utils.js';

package/utils.js

@@ -1,9 +1,6 @@
-import { BaseNodeCryptoProvider, NodeCryptoProvider } from "./chunks/es/HZgHrOPU.js";
-import { nodeStreamToWeb, webStreamToNode } from "./chunks/es/CKso6cAV.js";
+import { BaseNodeCryptoProvider, NodeCryptoProvider } from "./utils/crypto.js";
 export * from "@mtcute/core/utils.js";
 export {
   BaseNodeCryptoProvider,
-  NodeCryptoProvider,
-  nodeStreamToWeb,
-  webStreamToNode
+  NodeCryptoProvider
 };

package/worker.cjs

@@ -0,0 +1,49 @@
+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_worker_threads = require("node:worker_threads");
+const worker_js = require("@mtcute/core/worker.js");
+const platform = require("./utils/platform.cjs");
+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) {
+    super({
+      worker: options.worker,
+      platform: new platform.NodePlatform()
+    });
+  }
+  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.TelegramWorker = TelegramWorker;
+exports.TelegramWorkerPort = TelegramWorkerPort;