@mtcute/convert 0.17.0 → 0.18.0

package/index.js

@@ -1,486 +1,39 @@
-import { dataViewFromBuffer, readStringSession, TlBinaryReader, TlBinaryWriter, longFromBuffer } from "@mtcute/core/utils.js";
-import { MtArgumentError, Long } from "@mtcute/core";
-import { getPlatform } from "@mtcute/core/platform.js";
-const DC_MAPPING_PROD = {
-  1: {
-    main: {
-      id: 1,
-      ipAddress: "149.154.175.56",
-      port: 443
-    },
-    media: {
-      id: 1,
-      ipAddress: "149.154.175.211",
-      port: 443
-    }
-  },
-  2: {
-    main: {
-      id: 2,
-      ipAddress: "149.154.167.41",
-      port: 443
-    },
-    media: {
-      id: 2,
-      ipAddress: "149.154.167.35",
-      port: 443
-    }
-  },
-  3: {
-    main: {
-      id: 3,
-      ipAddress: "149.154.175.100",
-      port: 443
-    },
-    media: {
-      id: 3,
-      ipAddress: "149.154.175.100",
-      port: 443
-    }
-  },
-  4: {
-    main: {
-      id: 4,
-      ipAddress: "149.154.167.91",
-      port: 443
-    },
-    media: {
-      id: 4,
-      ipAddress: "149.154.167.255",
-      port: 443
-    }
-  },
-  5: {
-    main: {
-      id: 5,
-      ipAddress: "91.108.56.179",
-      port: 443
-    },
-    media: {
-      id: 5,
-      ipAddress: "149.154.171.255",
-      port: 443
-    }
-  }
-};
-const DC_MAPPING_TEST = {
-  1: {
-    main: {
-      id: 1,
-      ipAddress: "149.154.175.10",
-      port: 80
-    },
-    media: {
-      id: 1,
-      ipAddress: "149.154.175.10",
-      port: 80
-    }
-  },
-  2: {
-    main: {
-      id: 2,
-      ipAddress: "149.154.167.40",
-      port: 443
-    },
-    media: {
-      id: 2,
-      ipAddress: "149.154.167.40",
-      port: 443
-    }
-  },
-  3: {
-    main: {
-      id: 3,
-      ipAddress: "149.154.175.117",
-      port: 443
-    },
-    media: {
-      id: 3,
-      ipAddress: "149.154.175.117",
-      port: 443
-    }
-  }
-};
-function isTestDc(ip) {
-  return Object.values(DC_MAPPING_TEST).some((dc) => dc.main.ipAddress === ip || dc.media.ipAddress === ip);
-}
-function parseIpFromBytes(data) {
-  if (data.length === 4) {
-    return `${data[0]}.${data[1]}.${data[2]}.${data[3]}`;
-  }
-  if (data.length === 16) {
-    let res = "";
-    for (let i = 0; i < 16; i += 2) {
-      res += data[i].toString(16).padStart(2, "0");
-      res += data[i + 1].toString(16).padStart(2, "0");
-      if (i < 14) res += ":";
-    }
-    return res;
-  }
-  throw new MtArgumentError("Invalid IP address length");
-}
-function serializeIpv4ToBytes(ip, buf) {
-  const parts = ip.split(".");
-  if (parts.length !== 4) {
-    throw new MtArgumentError("Invalid IPv4 address");
-  }
-  buf[0] = Number(parts[0]);
-  buf[1] = Number(parts[1]);
-  buf[2] = Number(parts[2]);
-  buf[3] = Number(parts[3]);
-}
-function serializeIpv6ToBytes(ip, buf) {
-  const parts = ip.split(":");
-  if (parts.length !== 8) {
-    throw new MtArgumentError("Invalid IPv6 address");
-  }
-  for (let i = 0; i < 8; i++) {
-    const val = Number.parseInt(parts[i], 16);
-    buf[i * 2] = val >> 8;
-    buf[i * 2 + 1] = val & 255;
-  }
-}
-function parseTelethonSession(session) {
-  if (session[0] !== "1") {
-    throw new MtArgumentError(`Invalid session string (version = ${session[0]})`);
-  }
-  session = session.slice(1);
-  const data = getPlatform().base64Decode(session, true);
-  const dv = dataViewFromBuffer(data);
-  const dcId = dv.getUint8(0);
-  const ipSize = session.length === 352 ? 4 : 16;
-  let pos = 1 + ipSize;
-  const ipBytes = data.subarray(1, pos);
-  const port = dv.getUint16(pos);
-  pos += 2;
-  const authKey = data.subarray(pos, pos + 256);
-  const ip = parseIpFromBytes(ipBytes);
-  return {
-    dcId,
-    ipAddress: ip,
-    ipv6: ipSize === 16,
-    port,
-    authKey
-  };
-}
-function serializeTelethonSession(session) {
-  if (session.authKey.length !== 256) {
-    throw new MtArgumentError("authKey must be 256 bytes long");
-  }
-  const ipSize = session.ipv6 ? 16 : 4;
-  const u8 = new Uint8Array(259 + ipSize);
-  const dv = dataViewFromBuffer(u8);
-  dv.setUint8(0, session.dcId);
-  let pos;
-  if (session.ipv6) {
-    serializeIpv6ToBytes(session.ipAddress, u8.subarray(1, 17));
-    pos = 17;
-  } else {
-    serializeIpv4ToBytes(session.ipAddress, u8.subarray(1, 5));
-    pos = 5;
-  }
-  dv.setUint16(pos, session.port);
-  pos += 2;
-  u8.set(session.authKey, pos);
-  let b64 = getPlatform().base64Encode(u8, true);
-  while (b64.length % 4 !== 0) b64 += "=";
-  return `1${b64}`;
-}
-function convertFromTelethonSession(session) {
-  if (typeof session === "string") {
-    session = parseTelethonSession(session);
-  }
-  const dc = {
-    id: session.dcId,
-    ipAddress: session.ipAddress,
-    port: session.port,
-    ipv6: session.ipv6
-  };
-  return {
-    version: 3,
-    // we don't exactly have that information. try to deduce it from DC_MAPPING_TEST
-    // todo: we should maybe check this at connect?
-    testMode: isTestDc(session.ipAddress),
-    primaryDcs: {
-      main: dc,
-      media: dc
-    },
-    authKey: session.authKey
-  };
-}
-function convertToTelethonSession(session) {
-  if (typeof session === "string") {
-    session = readStringSession(session);
-  }
-  return serializeTelethonSession({
-    dcId: session.primaryDcs.main.id,
-    ipAddress: session.primaryDcs.main.ipAddress,
-    port: session.primaryDcs.main.port,
-    ipv6: session.primaryDcs.main.ipv6 ?? false,
-    authKey: session.authKey
-  });
-}
-function parseGramjsSession(session) {
-  if (session[0] !== "1") {
-    throw new MtArgumentError(`Invalid session string (version = ${session[0]})`);
-  }
-  session = session.slice(1);
-  const data = getPlatform().base64Decode(session);
-  const dv = dataViewFromBuffer(data);
-  const dcId = dv.getUint8(0);
-  const ipSize = dv.getUint16(1);
-  let pos = 3 + ipSize;
-  const ip = getPlatform().utf8Decode(data.subarray(3, pos));
-  const port = dv.getUint16(pos);
-  pos += 2;
-  const authKey = data.subarray(pos, pos + 256);
-  return {
-    dcId,
-    ipAddress: ip,
-    ipv6: ip.includes(":"),
-    // dumb check but gramjs does this
-    port,
-    authKey
-  };
-}
-function serializeGramjsSession(session) {
-  if (session.authKey.length !== 256) {
-    throw new MtArgumentError("authKey must be 256 bytes long");
-  }
-  const ipEncoded = getPlatform().utf8Encode(session.ipAddress);
-  const u8 = new Uint8Array(261 + ipEncoded.length);
-  const dv = dataViewFromBuffer(u8);
-  dv.setUint8(0, session.dcId);
-  dv.setUint16(1, ipEncoded.length);
-  u8.set(ipEncoded, 3);
-  let pos = 3 + ipEncoded.length;
-  dv.setUint16(pos, session.port);
-  pos += 2;
-  u8.set(session.authKey, pos);
-  return `1${getPlatform().base64Encode(u8)}`;
-}
-function convertFromGramjsSession(session) {
-  if (typeof session === "string") {
-    session = parseGramjsSession(session);
-  }
-  return convertFromTelethonSession(session);
-}
-function convertToGramjsSession(session) {
-  if (typeof session === "string") {
-    session = readStringSession(session);
-  }
-  return serializeGramjsSession({
-    dcId: session.primaryDcs.main.id,
-    ipAddress: session.primaryDcs.main.ipAddress,
-    port: session.primaryDcs.main.port,
-    ipv6: session.primaryDcs.main.ipv6 ?? false,
-    authKey: session.authKey
-  });
-}
-function telegramRleEncode(buf) {
-  const len = buf.length;
-  const ret = [];
-  let count = 0;
-  for (let i = 0; i < len; i++) {
-    const cur = buf[i];
-    if (cur === 0) {
-      count += 1;
-    } else {
-      if (count > 0) {
-        ret.push(0, count);
-        count = 0;
-      }
-      ret.push(cur);
-    }
-  }
-  if (count > 0) {
-    ret.push(0, count);
-  }
-  return new Uint8Array(ret);
-}
-function telegramRleDecode(buf) {
-  const len = buf.length;
-  const ret = [];
-  let prev = -1;
-  for (let i = 0; i < len; i++) {
-    const cur = buf[i];
-    if (prev === 0) {
-      for (let j = 0; j < cur; j++) {
-        ret.push(prev);
-      }
-      prev = -1;
-    } else {
-      if (prev !== -1) ret.push(prev);
-      prev = cur;
-    }
-  }
-  if (prev !== -1) ret.push(prev);
-  return new Uint8Array(ret);
-}
-function parseMtkrutoSession(session) {
-  const data = telegramRleDecode(getPlatform().base64Decode(session, true));
-  const reader = TlBinaryReader.manual(data);
-  let dcIdStr = reader.string();
-  const authKey = reader.bytes();
-  const isTest = dcIdStr.endsWith("-test");
-  if (isTest) {
-    dcIdStr = dcIdStr.slice(0, -5);
-  }
-  const dcId = Number(dcIdStr);
-  if (Number.isNaN(dcId)) {
-    throw new MtArgumentError(`Invalid DC ID: ${dcIdStr}`);
-  }
-  return {
-    dcId,
-    isTest,
-    authKey
-  };
-}
-function serializeMtkrutoSession(session) {
-  const dcIdStr = `${session.dcId}${session.isTest ? "-test" : ""}`;
-  const writer = TlBinaryWriter.manual(session.authKey.length + dcIdStr.length + 8);
-  writer.string(dcIdStr);
-  writer.bytes(session.authKey);
-  return getPlatform().base64Encode(telegramRleEncode(writer.result()), true);
-}
-function convertFromMtkrutoSession(session) {
-  if (typeof session === "string") {
-    session = parseMtkrutoSession(session);
-  }
-  return {
-    version: 3,
-    testMode: session.isTest,
-    primaryDcs: (session.isTest ? DC_MAPPING_TEST : DC_MAPPING_PROD)[session.dcId],
-    authKey: session.authKey
-  };
-}
-function convertToMtkrutoSession(session) {
-  if (typeof session === "string") {
-    session = readStringSession(session);
-  }
-  return serializeMtkrutoSession({
-    dcId: session.primaryDcs.main.id,
-    isTest: session.testMode,
-    authKey: session.authKey
-  });
-}
-const SESSION_STRING_SIZE$1 = 351;
-const SESSION_STRING_SIZE_64 = 356;
-function parsePyrogramSession(session) {
-  const data = getPlatform().base64Decode(session, true);
-  const dv = dataViewFromBuffer(data);
-  if (session.length === SESSION_STRING_SIZE$1 || session.length === SESSION_STRING_SIZE_64) {
-    const dcId2 = dv.getUint8(0);
-    const isTest2 = dv.getUint8(1) !== 0;
-    const authKey2 = data.subarray(2, 258);
-    let userId2;
-    if (data.length === SESSION_STRING_SIZE$1) {
-      userId2 = dv.getUint32(258);
-    } else {
-      const high = dv.getUint32(258);
-      const low = dv.getUint32(262);
-      userId2 = Long.fromBits(low, high).toNumber();
-    }
-    const isBot2 = dv.getUint8(data.length - 1) !== 0;
-    return {
-      dcId: dcId2,
-      isTest: isTest2,
-      authKey: authKey2,
-      userId: userId2,
-      isBot: isBot2
-    };
-  }
-  const dcId = dv.getUint8(0);
-  const apiId = dv.getUint32(1);
-  const isTest = dv.getUint8(5) !== 0;
-  const authKey = data.subarray(6, 262);
-  const userId = longFromBuffer(data.subarray(262, 270), true, false).toNumber();
-  const isBot = dv.getUint8(270) !== 0;
-  return {
-    dcId,
-    apiId,
-    isTest,
-    authKey,
-    userId,
-    isBot
-  };
-}
-const SESSION_STRING_SIZE_OLD = 267;
-const SESSION_STRING_SIZE = 271;
-function serializePyrogramSession(session) {
-  if (session.authKey.length !== 256) {
-    throw new MtArgumentError("authKey must be 256 bytes long");
-  }
-  const userIdLong = Long.fromNumber(session.userId, true);
-  let u8;
-  if (session.apiId === void 0) {
-    u8 = new Uint8Array(SESSION_STRING_SIZE_OLD);
-    const dv = dataViewFromBuffer(u8);
-    dv.setUint8(0, session.dcId);
-    dv.setUint8(1, session.isTest ? 1 : 0);
-    u8.set(session.authKey, 2);
-    dv.setUint32(258, userIdLong.high);
-    dv.setUint32(262, userIdLong.low);
-    dv.setUint8(266, session.isBot ? 1 : 0);
-  } else {
-    u8 = new Uint8Array(SESSION_STRING_SIZE);
-    const dv = dataViewFromBuffer(u8);
-    dv.setUint8(0, session.dcId);
-    dv.setUint32(1, session.apiId);
-    dv.setUint8(5, session.isTest ? 1 : 0);
-    u8.set(session.authKey, 6);
-    dv.setUint32(262, userIdLong.high);
-    dv.setUint32(266, userIdLong.low);
-    dv.setUint8(270, session.isBot ? 1 : 0);
-  }
-  return getPlatform().base64Encode(u8, true);
-}
-function convertFromPyrogramSession(session) {
-  if (typeof session === "string") {
-    session = parsePyrogramSession(session);
-  }
-  return {
-    version: 3,
-    testMode: session.isTest,
-    primaryDcs: (session.isTest ? DC_MAPPING_TEST : DC_MAPPING_PROD)[session.dcId],
-    authKey: session.authKey,
-    self: {
-      userId: session.userId,
-      isBot: session.isBot,
-      isPremium: false,
-      usernames: []
-    }
-  };
-}
-function convertToPyrogramSession(session, params) {
-  if (typeof session === "string") {
-    session = readStringSession(session);
-  }
-  return serializePyrogramSession({
-    apiId: params?.apiId,
-    isBot: session.self?.isBot ?? false,
-    isTest: session.testMode,
-    userId: session.self?.userId ?? 0,
-    dcId: session.primaryDcs.main.id,
-    authKey: session.authKey
-  });
-}
+import { DC_MAPPING_PROD, DC_MAPPING_TEST, isTestDc } from "./convert/src/dcs.js";
+import { convertFromGramjsSession, convertToGramjsSession } from "./convert/src/gramjs/convert.js";
+import { parseGramjsSession } from "./convert/src/gramjs/parse.js";
+import { serializeGramjsSession } from "./convert/src/gramjs/serialize.js";
+import { convertFromMtkrutoSession, convertToMtkrutoSession } from "./convert/src/mtkruto/convert.js";
+import { parseMtkrutoSession } from "./convert/src/mtkruto/parse.js";
+import { serializeMtkrutoSession } from "./convert/src/mtkruto/serialize.js";
+import { convertFromPyrogramSession, convertToPyrogramSession } from "./convert/src/pyrogram/convert.js";
+import { parsePyrogramSession } from "./convert/src/pyrogram/parse.js";
+import { serializePyrogramSession } from "./convert/src/pyrogram/serialize.js";
+import { convertFromTdata, convertToTdata } from "./convert/src/tdesktop/convert.js";
+import { Tdata } from "./convert/src/tdesktop/tdata.js";
+import * as qtBundle from "./convert/src/tdesktop/qt-bundle.js";
+import { convertFromTelethonSession, convertToTelethonSession } from "./convert/src/telethon/convert.js";
+import { parseTelethonSession } from "./convert/src/telethon/parse.js";
+import { serializeTelethonSession } from "./convert/src/telethon/serialize.js";
 export {
   DC_MAPPING_PROD,
   DC_MAPPING_TEST,
+  Tdata,
   convertFromGramjsSession,
   convertFromMtkrutoSession,
   convertFromPyrogramSession,
+  convertFromTdata,
   convertFromTelethonSession,
   convertToGramjsSession,
   convertToMtkrutoSession,
   convertToPyrogramSession,
+  convertToTdata,
   convertToTelethonSession,
   isTestDc,
   parseGramjsSession,
   parseMtkrutoSession,
   parsePyrogramSession,
   parseTelethonSession,
+  qtBundle as qt,
   serializeGramjsSession,
   serializeMtkrutoSession,
   serializePyrogramSession,

package/mtkruto/__fixtures__/session.d.cts

@@ -0,0 +1 @@
+export declare const MTKRUTO_SESSION = "BjItdGVzdAAB_gABAQABWEIKa07Ch-9zoA024mDOpsv20TW4YwuoRRROqSi41YQCbD3c4nKnz7BcFIu1mfn6f6Xm3OTVqoT0zib4p_AuZD9H-t8j5AagecRg-oSpQlmjoiUazKQSxnxWotGWf1mPNntAeOvDNa5t1NjXUxmqdB3e2AjYLF_E2jDESVgUuDBQUMBHIDc_xFBAlz6kVxCZ6iINJHbnyJ2F19tbEPFJvSM999RKaFj5lUUVs0qKNXEUmsFYUuIdPBzjWilY8Uvf9nYU_xXd9CUAAXS5_i4aaWlHoTIf3zn8ZEINhDIU1DMauh5vhSWt7F0fkxODjtou-7PdIunuDtqyQm4steuNJc8";

package/mtkruto/convert.d.cts

@@ -0,0 +1,4 @@
+import { StringSessionData } from '@mtcute/core/utils.js';
+import { MtkrutoSession } from './types.js';
+export declare function convertFromMtkrutoSession(session: MtkrutoSession | string): StringSessionData;
+export declare function convertToMtkrutoSession(session: StringSessionData | string): string;

package/mtkruto/convert.test.d.cts

@@ -0,0 +1 @@
+export {};

package/mtkruto/index.d.cts

@@ -0,0 +1,4 @@
+export * from './convert.js';
+export * from './parse.js';
+export * from './serialize.js';
+export * from './types.js';

package/mtkruto/parse.d.cts

@@ -0,0 +1,2 @@
+import { MtkrutoSession } from './types.js';
+export declare function parseMtkrutoSession(session: string): MtkrutoSession;

package/mtkruto/parse.test.d.cts

@@ -0,0 +1 @@
+export {};

package/mtkruto/serialize.d.cts

@@ -0,0 +1,2 @@
+import { MtkrutoSession } from './types.js';
+export declare function serializeMtkrutoSession(session: MtkrutoSession): string;

package/mtkruto/serialize.test.d.cts

@@ -0,0 +1 @@
+export {};

package/mtkruto/types.d.cts

@@ -0,0 +1,5 @@
+export interface MtkrutoSession {
+    dcId: number;
+    isTest: boolean;
+    authKey: Uint8Array;
+}

package/node/src/utils/crypto.cjs

@@ -0,0 +1,75 @@
+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_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 index = require("../../../wasm/src/index.cjs");
+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.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("node/src/utils/crypto.cjs", document.baseURI).href);
+    const wasmFile = require$1.resolve("@mtcute/wasm/mtcute.wasm");
+    const wasm = await promises.readFile(wasmFile);
+    index.initSync(wasm);
+  }
+  createAesIge(key, iv) {
+    return {
+      encrypt(data) {
+        return index.ige256Encrypt(data, key, iv);
+      },
+      decrypt(data) {
+        return index.ige256Decrypt(data, key, iv);
+      }
+    };
+  }
+}
+exports.BaseNodeCryptoProvider = BaseNodeCryptoProvider;
+exports.NodeCryptoProvider = NodeCryptoProvider;

package/node/src/utils/crypto.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, ige256Decrypt, ige256Encrypt } from "../../../wasm/src/index.js";
+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
+};