@mtcute/node 0.16.6 → 0.16.9

package/chunks/cjs/BpvQ752Q.js

@@ -0,0 +1,33 @@
+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");
+}
+"use strict";
+const node_fs = require("node:fs");
+const promises = require("node:fs/promises");
+const core = require("@mtcute/core");
+const methods_js = require("@mtcute/core/methods.js");
+const streamUtils = require("./HP2yqAk_.js");
+async function downloadToFile(client, filename, location, params) {
+  if (location instanceof core.FileLocation && ArrayBuffer.isView(location.location)) {
+    await promises.writeFile(filename, location.location);
+  }
+  const output = node_fs.createWriteStream(filename);
+  if (params?.abortSignal) {
+    params.abortSignal.addEventListener("abort", () => {
+      client.log.debug("aborting file download %s - cleaning up", filename);
+      output.destroy();
+      node_fs.rmSync(filename);
+    });
+  }
+  for await (const chunk of methods_js.downloadAsIterable(client, location, params)) {
+    output.write(chunk);
+  }
+  output.end();
+}
+function downloadAsNodeStream(client, location, params) {
+  return streamUtils.webStreamToNode(methods_js.downloadAsStream(client, location, params));
+}
+exports.downloadAsNodeStream = downloadAsNodeStream;
+exports.downloadToFile = downloadToFile;

package/chunks/cjs/D7i-4e0W.js

@@ -0,0 +1,74 @@
+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");
+}
+"use strict";
+const node_crypto = require("node:crypto");
+const promises = require("node:fs/promises");
+const node_module = require("node:module");
+const node_zlib = require("node:zlib");
+const utils_js = require("@mtcute/core/utils.js");
+const wasm = require("@mtcute/wasm");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+class BaseNodeCryptoProvider extends utils_js.BaseCryptoProvider {
+  createAesCtr(key, iv) {
+    const cipher = node_crypto.createCipheriv(`aes-${key.length * 8}-ctr`, key, iv);
+    const update = (data) => cipher.update(data);
+    return {
+      process: update
+    };
+  }
+  pbkdf2(password, salt, iterations, keylen = 64, algo = "sha512") {
+    return new Promise(
+      (resolve, reject) => node_crypto.pbkdf2(password, salt, iterations, keylen, algo, (err, buf) => err !== null ? reject(err) : resolve(buf))
+    );
+  }
+  sha1(data) {
+    return node_crypto.createHash("sha1").update(data).digest();
+  }
+  sha256(data) {
+    return node_crypto.createHash("sha256").update(data).digest();
+  }
+  hmacSha256(data, key) {
+    return node_crypto.createHmac("sha256", key).update(data).digest();
+  }
+  gzip(data, maxSize) {
+    try {
+      return node_zlib.deflateSync(data, {
+        maxOutputLength: maxSize
+      });
+    } catch (e) {
+      if (e.code === "ERR_BUFFER_TOO_LARGE") {
+        return null;
+      }
+      throw e;
+    }
+  }
+  gunzip(data) {
+    return node_zlib.gunzipSync(data);
+  }
+  randomFill(buf) {
+    node_crypto.randomFillSync(buf);
+  }
+}
+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 wasmFile = require$1.resolve("@mtcute/wasm/mtcute.wasm");
+    const wasm$1 = await promises.readFile(wasmFile);
+    wasm.initSync(wasm$1);
+  }
+  createAesIge(key, iv) {
+    return {
+      encrypt(data) {
+        return wasm.ige256Encrypt(data, key, iv);
+      },
+      decrypt(data) {
+        return wasm.ige256Decrypt(data, key, iv);
+      }
+    };
+  }
+}
+exports.BaseNodeCryptoProvider = BaseNodeCryptoProvider;
+exports.NodeCryptoProvider = NodeCryptoProvider;

package/chunks/cjs/HP2yqAk_.js

@@ -0,0 +1,79 @@
+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");
+}
+"use strict";
+const node_stream = require("node:stream");
+const NODE_VERSION = typeof process !== "undefined" && "node" in process.versions ? process.versions.node : null;
+const NODE_VERSION_TUPLE = NODE_VERSION ? /* @__PURE__ */ NODE_VERSION.split(".").map(Number) : null;
+function isNodeVersionAfter(major, minor, patch) {
+  if (!NODE_VERSION_TUPLE) return true;
+  const [a, b, c] = NODE_VERSION_TUPLE;
+  if (a > major) return true;
+  if (a < major) return false;
+  if (b > minor) return true;
+  if (b < minor) return false;
+  return c >= patch;
+}
+function nodeStreamToWeb(stream) {
+  if (typeof node_stream.Readable.toWeb === "function") {
+    return node_stream.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();
+    }
+  });
+}
+function webStreamToNode(stream) {
+  if (typeof node_stream.Readable.fromWeb === "function" && isNodeVersionAfter(18, 13, 0)) {
+    return node_stream.Readable.fromWeb(stream);
+  }
+  const reader = stream.getReader();
+  let ended = false;
+  const readable = new node_stream.Readable({
+    async read() {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          this.push(null);
+        } else {
+          this.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+        }
+      } catch (err) {
+        this.destroy(err);
+      }
+    },
+    destroy(error, cb) {
+      if (!ended) {
+        void reader.cancel(error).catch(() => {
+        }).then(() => {
+          cb(error);
+        });
+        return;
+      }
+      cb(error);
+    }
+  });
+  reader.closed.then(() => {
+    ended = true;
+  }).catch((err) => {
+    readable.destroy(err);
+  });
+  return readable;
+}
+exports.nodeStreamToWeb = nodeStreamToWeb;
+exports.webStreamToNode = webStreamToNode;

package/chunks/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/chunks/es/CKso6cAV.js

@@ -0,0 +1,75 @@
+import { Readable } from "node:stream";
+const NODE_VERSION = typeof process !== "undefined" && "node" in process.versions ? process.versions.node : null;
+const NODE_VERSION_TUPLE = NODE_VERSION ? /* @__PURE__ */ NODE_VERSION.split(".").map(Number) : null;
+function isNodeVersionAfter(major, minor, patch) {
+  if (!NODE_VERSION_TUPLE) return true;
+  const [a, b, c] = NODE_VERSION_TUPLE;
+  if (a > major) return true;
+  if (a < major) return false;
+  if (b > minor) return true;
+  if (b < minor) return false;
+  return c >= patch;
+}
+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();
+    }
+  });
+}
+function webStreamToNode(stream) {
+  if (typeof Readable.fromWeb === "function" && isNodeVersionAfter(18, 13, 0)) {
+    return Readable.fromWeb(stream);
+  }
+  const reader = stream.getReader();
+  let ended = false;
+  const readable = new Readable({
+    async read() {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          this.push(null);
+        } else {
+          this.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+        }
+      } catch (err) {
+        this.destroy(err);
+      }
+    },
+    destroy(error, cb) {
+      if (!ended) {
+        void reader.cancel(error).catch(() => {
+        }).then(() => {
+          cb(error);
+        });
+        return;
+      }
+      cb(error);
+    }
+  });
+  reader.closed.then(() => {
+    ended = true;
+  }).catch((err) => {
+    readable.destroy(err);
+  });
+  return readable;
+}
+export {
+  nodeStreamToWeb,
+  webStreamToNode
+};

package/chunks/es/CnOjjhdK.js

@@ -0,0 +1,29 @@
+import { createWriteStream, rmSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { FileLocation } from "@mtcute/core";
+import { downloadAsIterable, downloadAsStream } from "@mtcute/core/methods.js";
+import { webStreamToNode } from "./CKso6cAV.js";
+async function downloadToFile(client, filename, location, params) {
+  if (location instanceof FileLocation && ArrayBuffer.isView(location.location)) {
+    await writeFile(filename, location.location);
+  }
+  const output = createWriteStream(filename);
+  if (params?.abortSignal) {
+    params.abortSignal.addEventListener("abort", () => {
+      client.log.debug("aborting file download %s - cleaning up", filename);
+      output.destroy();
+      rmSync(filename);
+    });
+  }
+  for await (const chunk of downloadAsIterable(client, location, params)) {
+    output.write(chunk);
+  }
+  output.end();
+}
+function downloadAsNodeStream(client, location, params) {
+  return webStreamToNode(downloadAsStream(client, location, params));
+}
+export {
+  downloadAsNodeStream,
+  downloadToFile
+};

package/chunks/es/HZgHrOPU.js

@@ -0,0 +1,69 @@
+import { createCipheriv, pbkdf2, createHash, createHmac, randomFillSync } from "node:crypto";
+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";
+class BaseNodeCryptoProvider extends BaseCryptoProvider {
+  createAesCtr(key, iv) {
+    const cipher = createCipheriv(`aes-${key.length * 8}-ctr`, key, iv);
+    const update = (data) => cipher.update(data);
+    return {
+      process: update
+    };
+  }
+  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) {
+    return createHash("sha1").update(data).digest();
+  }
+  sha256(data) {
+    return createHash("sha256").update(data).digest();
+  }
+  hmacSha256(data, key) {
+    return createHmac("sha256", key).update(data).digest();
+  }
+  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) {
+    randomFillSync(buf);
+  }
+}
+class NodeCryptoProvider extends BaseNodeCryptoProvider {
+  async initialize() {
+    const require2 = createRequire(import.meta.url);
+    const wasmFile = require2.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);
+      }
+    };
+  }
+}
+export {
+  BaseNodeCryptoProvider,
+  NodeCryptoProvider
+};

package/{cjs/client.d.ts → client.d.ts}

@@ -1,5 +1,6 @@
+import { Readable } from 'node:stream';
 import { FileDownloadLocation, FileDownloadParameters, ITelegramStorageProvider, PartialOnly, User } from '@mtcute/core';
-import { BaseTelegramClient as BaseTelegramClientBase, BaseTelegramClientOptions as BaseTelegramClientOptionsBase, TelegramClient as TelegramClientBase, TelegramClientOptions } from '@mtcute/core/client.js';
+import { BaseTelegramClientOptions as BaseTelegramClientOptionsBase, TelegramClientOptions, BaseTelegramClient as BaseTelegramClientBase, TelegramClient as TelegramClientBase } from '@mtcute/core/client.js';
 export type { TelegramClientOptions };
 export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegramClientOptionsBase, 'storage'>, 'transport' | 'crypto'> {
     /**
@@ -42,5 +43,5 @@ export declare class TelegramClient extends TelegramClientBase {
     start(params?: Parameters<TelegramClientBase['start']>[0]): Promise<User>;
     run(params: Parameters<TelegramClient['start']>[0] | ((user: User) => void | Promise<void>), then?: (user: User) => void | Promise<void>): void;
     downloadToFile(filename: string, location: FileDownloadLocation, params?: FileDownloadParameters | undefined): Promise<void>;
-    downloadAsNodeStream(location: FileDownloadLocation, params?: FileDownloadParameters | undefined): import("stream").Readable;
+    downloadAsNodeStream(location: FileDownloadLocation, params?: FileDownloadParameters | undefined): Readable;
 }