@mtcute/node 0.17.0 → 0.18.0

package/sqlite/index.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 core = require("@mtcute/core");
+const driver = require("./driver.cjs");
+class SqliteStorage extends core.BaseSqliteStorage {
+  constructor(filename = ":memory:", params) {
+    super(new driver.SqliteStorageDriver(filename, params));
+    this.filename = filename;
+    this.params = params;
+  }
+}
+exports.SqliteStorageDriver = driver.SqliteStorageDriver;
+exports.SqliteStorage = SqliteStorage;

package/sqlite/index.d.cts

@@ -0,0 +1,8 @@
+import { SqliteStorageDriverOptions } from './driver.js';
+import { BaseSqliteStorage } from '@mtcute/core';
+export { SqliteStorageDriver } from './driver.js';
+export declare class SqliteStorage extends BaseSqliteStorage {
+    readonly filename: string;
+    readonly params?: SqliteStorageDriverOptions | undefined;
+    constructor(filename?: string, params?: SqliteStorageDriverOptions | undefined);
+}

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/{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/utils/crypto.d.cts

@@ -0,0 +1,15 @@
+import { IAesCtr, ICryptoProvider, IEncryptionScheme, BaseCryptoProvider } from '@mtcute/core/utils.js';
+export declare abstract class BaseNodeCryptoProvider extends BaseCryptoProvider {
+    createAesCtr(key: Uint8Array, iv: Uint8Array): IAesCtr;
+    pbkdf2(password: Uint8Array, salt: Uint8Array, iterations: number, keylen?: number, algo?: string): Promise<Uint8Array>;
+    sha1(data: Uint8Array): Uint8Array;
+    sha256(data: Uint8Array): Uint8Array;
+    hmacSha256(data: Uint8Array, key: Uint8Array): Uint8Array;
+    gzip(data: Uint8Array, maxSize: number): Uint8Array | null;
+    gunzip(data: Uint8Array): Uint8Array;
+    randomFill(buf: Uint8Array): void;
+}
+export declare class NodeCryptoProvider extends BaseNodeCryptoProvider implements ICryptoProvider {
+    initialize(): Promise<void>;
+    createAesIge(key: Uint8Array, iv: Uint8Array): IEncryptionScheme;
+}

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.d.ts

@@ -0,0 +1 @@
+export declare function beforeExit(fn: () => void): () => void;

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.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare const defaultLoggingHandler: (color: number, level: number, tag: string, fmt: string, args: unknown[]) => void;

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.d.cts

@@ -0,0 +1,6 @@
+import { UploadFileLike } from '@mtcute/core';
+export declare function normalizeFile(file: UploadFileLike): Promise<{
+    file: UploadFileLike;
+    fileName?: string | undefined;
+    fileSize?: number;
+} | null>;

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/utils/platform.d.cts

@@ -0,0 +1,11 @@
+import { ICorePlatform } from '@mtcute/core';
+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;
+}

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

@@ -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.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;