@mtcute/core 0.16.6 → 0.16.9

package/utils.cjs

@@ -0,0 +1,689 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const conditionVariable = require("./chunks/cjs/eX3zeDAz.js");
+const sortedArray = require("./chunks/cjs/C1cFqHcW.js");
+const controllablePromise = require("./chunks/cjs/CZAB54t2.js");
+const logger = require("./chunks/cjs/D4qcXFYA.js");
+const tlJson = require("./chunks/cjs/BQETTb_8.js");
+const tlRuntime = require("@mtcute/tl-runtime");
+const chat = require("./chunks/cjs/BijPAnvP.js");
+function joinTextWithEntities(parts, delim = "") {
+  const textParts = [];
+  const newEntities = [];
+  let position = 0;
+  if (typeof delim === "string") {
+    delim = { text: delim };
+  }
+  const pushPart = (part) => {
+    textParts.push(part.text);
+    const entitiesOffset = position;
+    position += part.text.length;
+    if (part.entities) {
+      for (const entity of part.entities) {
+        newEntities.push({
+          ...entity,
+          offset: entity.offset + entitiesOffset
+        });
+      }
+    }
+  };
+  for (const part of parts) {
+    if (position > 0) {
+      pushPart(delim);
+    }
+    pushPart(typeof part === "string" ? { text: part } : part);
+  }
+  return {
+    text: textParts.join(""),
+    entities: newEntities
+  };
+}
+class RpsMeter {
+  constructor(size = 500, time = 5e3) {
+    this.size = size;
+    if (typeof process === "undefined" || !process.hrtime.bigint) {
+      throw new Error("RPS meter is not supported on this platform");
+    }
+    this._hits = new conditionVariable.Deque(size);
+    this.time = BigInt(time) * BigInt(1e6);
+  }
+  _hits;
+  time;
+  hit() {
+    this._hits.pushBack(process.hrtime.bigint());
+  }
+  getRps() {
+    if (!this._hits.length) return 0;
+    const now = process.hrtime.bigint();
+    const window = now - this.time;
+    const iter = this._hits.iter();
+    let first = iter.next();
+    let idx = 0;
+    while (!first.done && first.value < window) {
+      first = iter.next();
+      idx += 1;
+    }
+    if (!first.value) return 0;
+    const hits = this._hits.length - idx;
+    return hits * 1e9 / Number(now - first.value);
+  }
+}
+function factorizePQSync(crypto, pq) {
+  const pq_ = sortedArray.bufferToBigInt(pq);
+  const n = PollardRhoBrent(crypto, pq_);
+  const m = pq_ / n;
+  let p;
+  let q;
+  if (n < m) {
+    p = n;
+    q = m;
+  } else {
+    p = m;
+    q = n;
+  }
+  return [sortedArray.bigIntToBuffer(p), sortedArray.bigIntToBuffer(q)];
+}
+function PollardRhoBrent(crypto, n) {
+  if (n % 2n === 0n) return 2n;
+  let y = sortedArray.randomBigIntInRange(crypto, n - 1n);
+  const c = sortedArray.randomBigIntInRange(crypto, n - 1n);
+  const m = sortedArray.randomBigIntInRange(crypto, n - 1n);
+  let g = 1n;
+  let r = 1n;
+  let q = 1n;
+  let ys;
+  let x;
+  while (g === 1n) {
+    x = y;
+    for (let i = 0; r >= i; i++) y = (y * y % n + c) % n;
+    let k = 0n;
+    while (k < r && g === 1n) {
+      ys = y;
+      for (let i = 0n; i < sortedArray.bigIntMin(m, r - k); i++) {
+        y = (y * y % n + c) % n;
+        q = q * sortedArray.bigIntAbs(x - y) % n;
+      }
+      g = sortedArray.bigIntGcd(q, n);
+      k = k + m;
+    }
+    r <<= 1n;
+  }
+  if (g === n) {
+    do {
+      ys = (ys * ys % n + c) % n;
+      g = sortedArray.bigIntGcd(x - ys, n);
+    } while (g <= 1n);
+  }
+  return g;
+}
+class BaseCryptoProvider {
+  factorizePQ(pq) {
+    return factorizePQSync(this, pq);
+  }
+  randomBytes(size) {
+    const buf = new Uint8Array(size);
+    this.randomFill(buf);
+    return buf;
+  }
+}
+const botStart = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ username, parameter }) => ["resolve", { domain: username, start: parameter }],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const username = query.get("domain");
+    const parameter = query.get("start");
+    if (!username || !parameter) return null;
+    return { username, parameter };
+  },
+  externalBuild: ({ username, parameter }) => [username, { start: parameter }],
+  externalParse: (path, query) => {
+    if (path.includes("/") || path[0] === "+" || path.length <= 2) return null;
+    const username = path;
+    const parameter = query.get("start");
+    if (!parameter) return null;
+    return { username, parameter };
+  }
+});
+function normalizeBotAdmin(rights) {
+  if (!rights?.length) return;
+  return rights.map((it) => {
+    switch (it) {
+      case "changeInfo":
+        return "change_info";
+      case "postMessages":
+        return "post_messages";
+      case "editMessages":
+        return "edit_messages";
+      case "deleteMessages":
+        return "delete_messages";
+      case "banUsers":
+        return "restrict_members";
+      case "inviteUsers":
+        return "invite_users";
+      case "pinMessages":
+        return "pin_messages";
+      case "manageTopics":
+        return "manage_topics";
+      case "addAdmins":
+        return "promote_members";
+      case "manageCall":
+        return "manage_video_chats";
+      case "anonymous":
+        return "anonymous";
+      case "other":
+        return "manage_chat";
+      case "postStories":
+        return "post_stories";
+      case "editStories":
+        return "edit_stories";
+      case "deleteStories":
+        return "delete_stories";
+      default:
+        conditionVariable.assertNever();
+        return "";
+    }
+  }).join("+");
+}
+function parseBotAdmin(rights) {
+  if (!rights) return;
+  return rights.split("+").map((it) => {
+    switch (it) {
+      case "change_info":
+        return "changeInfo";
+      case "post_messages":
+        return "postMessages";
+      case "edit_messages":
+        return "editMessages";
+      case "delete_messages":
+        return "deleteMessages";
+      case "restrict_members":
+        return "banUsers";
+      case "invite_users":
+        return "inviteUsers";
+      case "pin_messages":
+        return "pinMessages";
+      case "manage_topics":
+        return "manageTopics";
+      case "promote_members":
+        return "addAdmins";
+      case "manage_video_chats":
+        return "manageCall";
+      case "anonymous":
+        return "anonymous";
+      case "manage_chat":
+        return "other";
+      case "post_stories":
+        return "postStories";
+      case "edit_stories":
+        return "editStories";
+      case "delete_stories":
+        return "deleteStories";
+      default:
+        return null;
+    }
+  }).filter(controllablePromise.isPresent);
+}
+const botAddToGroup = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ bot, parameter, admin }) => [
+    "resolve",
+    { domain: bot, startgroup: parameter ?? true, admin: normalizeBotAdmin(admin) }
+  ],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const bot = query.get("domain");
+    const parameter = query.get("startgroup");
+    const admin = query.get("admin");
+    if (!bot || parameter === null) return null;
+    return {
+      bot,
+      parameter: parameter === "" ? void 0 : parameter,
+      admin: parseBotAdmin(admin)
+    };
+  },
+  externalBuild: ({ bot, parameter, admin }) => [
+    bot,
+    { startgroup: parameter ?? true, admin: normalizeBotAdmin(admin) }
+  ],
+  externalParse: (path, query) => {
+    if (path.includes("/") || path[0] === "+" || path.length <= 2) return null;
+    const bot = path;
+    const parameter = query.get("startgroup");
+    const admin = query.get("admin");
+    if (parameter === null) return null;
+    return {
+      bot,
+      parameter: parameter === "" ? void 0 : parameter,
+      admin: parseBotAdmin(admin)
+    };
+  }
+});
+const botAddToChannel = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ bot, admin }) => [
+    "resolve",
+    { domain: bot, startchannel: true, admin: normalizeBotAdmin(admin) }
+  ],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const bot = query.get("domain");
+    const parameter = query.get("startchannel");
+    const admin = query.get("admin");
+    if (!bot || parameter === null) return null;
+    return {
+      bot,
+      admin: parseBotAdmin(admin)
+    };
+  },
+  externalBuild: ({ bot, admin }) => [bot, { startchannel: true, admin: normalizeBotAdmin(admin) }],
+  externalParse: (path, query) => {
+    if (path.includes("/") || path[0] === "+" || path.length <= 2) return null;
+    const bot = path;
+    const parameter = query.get("startchannel");
+    const admin = query.get("admin");
+    if (parameter === null) return null;
+    return {
+      bot,
+      admin: parseBotAdmin(admin)
+    };
+  }
+});
+const botGame = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ bot, game }) => ["resolve", { domain: bot, game }],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const bot = query.get("domain");
+    const game = query.get("game");
+    if (!bot || !game) return null;
+    return { bot, game };
+  },
+  externalBuild: ({ bot, game }) => [bot, { game }],
+  externalParse: (path, query) => {
+    if (path.includes("/") || path[0] === "+" || path.length <= 2) return null;
+    const bot = path;
+    const game = query.get("game");
+    if (!game) return null;
+    return { bot, game };
+  }
+});
+const botWebApp = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ bot, app, parameter }) => ["resolve", { domain: bot, appname: app, startapp: parameter }],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const bot = query.get("domain");
+    const app = query.get("appname");
+    const parameter = query.get("startapp");
+    if (!bot || !app) return null;
+    return { bot, app, parameter: parameter || void 0 };
+  },
+  externalBuild: ({ bot, app, parameter }) => [`${bot}/${app}`, { startapp: parameter }],
+  externalParse: (path, query) => {
+    const [bot, app, rest] = path.split("/");
+    if (!app || rest) return null;
+    const parameter = query.get("startapp");
+    return { bot, app, parameter: parameter || void 0 };
+  }
+});
+const videoChat = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ username, inviteHash, isLivestream }) => [
+    "resolve",
+    {
+      domain: username,
+      [isLivestream ? "livestream" : "videochat"]: inviteHash || true
+    }
+  ],
+  externalBuild: ({ username, inviteHash, isLivestream }) => [
+    username,
+    {
+      [isLivestream ? "livestream" : "videochat"]: inviteHash || true
+    }
+  ],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const domain = query.get("domain");
+    if (!domain) return null;
+    const livestream = query.get("livestream");
+    const videochat = query.get("videochat");
+    const voicechat = query.get("voicechat");
+    if (livestream === null && videochat === null && voicechat === null) return null;
+    const inviteHash = livestream || videochat || voicechat;
+    return {
+      username: domain,
+      inviteHash: inviteHash || void 0,
+      isLivestream: livestream !== null
+    };
+  },
+  externalParse: (path, query) => {
+    if (path.length <= 1 || path.includes("/") || path[0] === "+") return null;
+    const livestream = query.get("livestream");
+    const videochat = query.get("videochat");
+    const voicechat = query.get("voicechat");
+    if (livestream === null && videochat === null && voicechat === null) return null;
+    const inviteHash = livestream || videochat || voicechat;
+    return {
+      username: path,
+      inviteHash: inviteHash || void 0,
+      isLivestream: livestream !== null
+    };
+  }
+});
+const share = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ url, text }) => ["msg_url", { url, text }],
+  internalParse: (path, query) => {
+    if (path !== "msg_url") return null;
+    const url = query.get("url");
+    if (!url) return null;
+    const text = query.get("text");
+    return { url, text: text || void 0 };
+  },
+  externalBuild: ({ url, text }) => ["share", { url, text }],
+  externalParse: (path, query) => {
+    if (path !== "share") return null;
+    const url = query.get("url");
+    if (!url) return null;
+    const text = query.get("text");
+    return { url, text: text || void 0 };
+  }
+});
+const boost = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: (params) => {
+    if ("username" in params) {
+      return ["boost", { domain: params.username }];
+    }
+    return ["boost", { channel: params.channelId }];
+  },
+  internalParse: (path, query) => {
+    if (path !== "boost") return null;
+    const username = query.get("domain");
+    if (username) {
+      return { username };
+    }
+    const channelId = Number(query.get("channel"));
+    if (!Number.isNaN(channelId)) {
+      return { channelId: Number(channelId) };
+    }
+    return null;
+  },
+  externalBuild: (params) => {
+    if ("username" in params) {
+      return [params.username, { boost: true }];
+    }
+    return [`c/${params.channelId}`, { boost: true }];
+  },
+  externalParse: (path, query) => {
+    if (!query.has("boost")) return null;
+    if (path.startsWith("c/")) {
+      const channelId = Number(path.slice(2));
+      if (Number.isNaN(channelId)) return null;
+      return { channelId };
+    }
+    if (path.includes("/")) return null;
+    return { username: path };
+  }
+});
+const folder = /* @__PURE__ */ chat.deeplinkBuilder({
+  // tg://addlist?slug=XXX
+  internalBuild: ({ slug }) => ["addlist", { slug }],
+  internalParse: (path, query) => {
+    if (path !== "addlist") return null;
+    const slug = query.get("slug");
+    if (!slug) return null;
+    return { slug };
+  },
+  // https://t.me/addlist/XXX
+  externalBuild: ({ slug }) => [`addlist/${slug}`, null],
+  externalParse: (path) => {
+    const [prefix, slug] = path.split("/");
+    if (prefix !== "addlist") return null;
+    return { slug };
+  }
+});
+const mtproxy = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: (params) => ["proxy", params],
+  externalBuild: (params) => ["proxy", params],
+  internalParse: (path, query) => {
+    if (path !== "proxy") return null;
+    const server = query.get("server");
+    const port = Number(query.get("port"));
+    const secret = query.get("secret");
+    if (!server || Number.isNaN(port) || !secret) return null;
+    return { server, port, secret };
+  },
+  externalParse: (path, query) => {
+    if (path !== "proxy") return null;
+    const server = query.get("server");
+    const port = Number(query.get("port"));
+    const secret = query.get("secret");
+    if (!server || Number.isNaN(port) || !secret) return null;
+    return { server, port, secret };
+  }
+});
+const socks5 = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: (params) => ["socks", params],
+  externalBuild: (params) => ["socks", params],
+  internalParse: (path, query) => {
+    if (path !== "socks") return null;
+    const server = query.get("server");
+    const port = Number(query.get("port"));
+    const user = query.get("user");
+    const pass = query.get("pass");
+    if (!server || Number.isNaN(port)) return null;
+    return { server, port, user: user || void 0, pass: pass || void 0 };
+  },
+  externalParse: (path, query) => {
+    if (path !== "socks") return null;
+    const server = query.get("server");
+    const port = Number(query.get("port"));
+    const user = query.get("user");
+    const pass = query.get("pass");
+    if (!server || Number.isNaN(port)) return null;
+    return { server, port, user: user || void 0, pass: pass || void 0 };
+  }
+});
+const stickerset = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ slug, emoji }) => [emoji ? "addemoji" : "addstickers", { set: slug }],
+  internalParse: (path, query) => {
+    if (path !== "addstickers" && path !== "addemoji") return null;
+    const slug = query.get("set");
+    if (!slug) return null;
+    return { slug, emoji: path === "addemoji" };
+  },
+  externalBuild: ({ slug, emoji }) => [`${emoji ? "addemoji" : "addstickers"}/${slug}`, null],
+  externalParse: (path) => {
+    const [prefix, slug] = path.split("/");
+    if (prefix !== "addstickers" && prefix !== "addemoji") return null;
+    return { slug, emoji: prefix === "addemoji" };
+  }
+});
+const publicUsername = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ username }) => ["resolve", { domain: username }],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const domain = query.get("domain");
+    if (!domain) return null;
+    if ([...query.keys()].length > 1) return null;
+    return { username: domain };
+  },
+  externalBuild: ({ username }) => [username, null],
+  externalParse: (path, query) => {
+    if (path.length <= 1 || path.includes("/") || path[0] === "+") return null;
+    if ([...query.keys()].length > 0) return null;
+    return { username: path };
+  }
+});
+const temporaryProfile = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ token }) => ["contact", { token }],
+  internalParse: (path, query) => {
+    if (path !== "contact") return null;
+    const token = query.get("token");
+    if (!token) return null;
+    return { token };
+  },
+  externalBuild: ({ token }) => [`contact/${token}`, null],
+  externalParse: (path) => {
+    const [prefix, token] = path.split("/");
+    if (prefix !== "contact") return null;
+    return { token };
+  }
+});
+const phoneNumber = /* @__PURE__ */ chat.deeplinkBuilder({
+  internalBuild: ({ phone }) => ["resolve", { phone }],
+  internalParse: (path, query) => {
+    if (path !== "resolve") return null;
+    const phone = query.get("phone");
+    if (!phone) return null;
+    return { phone };
+  },
+  externalBuild: ({ phone }) => [`+${phone}`, null],
+  externalParse: (path) => {
+    const m = path.match(/^\+(\d+)$/);
+    if (!m) return null;
+    return { phone: m[1] };
+  }
+});
+const bundle = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  boost,
+  botAddToChannel,
+  botAddToGroup,
+  botGame,
+  botStart,
+  botWebApp,
+  chatFolder: chat.chatFolder,
+  chatInvite: chat.chatInvite,
+  folder,
+  message: chat.message,
+  mtproxy,
+  phoneNumber,
+  publicUsername,
+  share,
+  socks5,
+  stickerset,
+  temporaryProfile,
+  videoChat
+}, Symbol.toStringTag, { value: "Module" }));
+exports.AsyncLock = conditionVariable.AsyncLock;
+exports.ConditionVariable = conditionVariable.ConditionVariable;
+exports.Deque = conditionVariable.Deque;
+exports.INVITE_LINK_REGEX = conditionVariable.INVITE_LINK_REGEX;
+exports.LongMap = conditionVariable.LongMap;
+exports.LongSet = conditionVariable.LongSet;
+exports.LruMap = conditionVariable.LruMap;
+exports.bufferToReversed = conditionVariable.bufferToReversed;
+exports.bufferToStream = conditionVariable.bufferToStream;
+exports.buffersEqual = conditionVariable.buffersEqual;
+exports.cloneBuffer = conditionVariable.cloneBuffer;
+exports.compareLongs = conditionVariable.compareLongs;
+exports.concatBuffers = conditionVariable.concatBuffers;
+exports.createChunkedReader = conditionVariable.createChunkedReader;
+exports.dataViewFromBuffer = conditionVariable.dataViewFromBuffer;
+exports.decodeWaveform = conditionVariable.decodeWaveform;
+exports.determinePartSize = conditionVariable.determinePartSize;
+exports.encodeInlineMessageId = conditionVariable.encodeInlineMessageId;
+exports.encodeWaveform = conditionVariable.encodeWaveform;
+exports.extractFileName = conditionVariable.extractFileName;
+exports.extractUsernames = conditionVariable.extractUsernames;
+exports.getAllPeersFrom = conditionVariable.getAllPeersFrom;
+exports.getBarePeerId = conditionVariable.getBarePeerId;
+exports.getMarkedPeerId = conditionVariable.getMarkedPeerId;
+exports.getRandomInt = conditionVariable.getRandomInt;
+exports.inflateSvgPath = conditionVariable.inflateSvgPath;
+exports.inputPeerToPeer = conditionVariable.inputPeerToPeer;
+exports.isInputPeerChannel = conditionVariable.isInputPeerChannel;
+exports.isInputPeerChat = conditionVariable.isInputPeerChat;
+exports.isInputPeerUser = conditionVariable.isInputPeerUser;
+exports.isProbablyPlainText = conditionVariable.isProbablyPlainText;
+exports.longFromBuffer = conditionVariable.longFromBuffer;
+exports.longFromFastString = conditionVariable.longFromFastString;
+exports.longToFastString = conditionVariable.longToFastString;
+exports.makeArrayPaginated = conditionVariable.makeArrayPaginated;
+exports.makeArrayWithTotal = conditionVariable.makeArrayWithTotal;
+exports.makeInspectable = conditionVariable.makeInspectable;
+exports.normalizeDate = conditionVariable.normalizeDate;
+exports.normalizeInlineId = conditionVariable.normalizeInlineId;
+exports.normalizeMessageId = conditionVariable.normalizeMessageId;
+exports.normalizePhoneNumber = conditionVariable.normalizePhoneNumber;
+exports.parseInlineMessageId = conditionVariable.parseInlineMessageId;
+exports.parseMarkedPeerId = conditionVariable.parseMarkedPeerId;
+exports.randomLong = conditionVariable.randomLong;
+exports.removeFromLongArray = conditionVariable.removeFromLongArray;
+exports.resolveMaybeDynamic = conditionVariable.resolveMaybeDynamic;
+exports.sleep = conditionVariable.sleep;
+exports.sleepWithAbort = conditionVariable.sleepWithAbort;
+exports.streamToBuffer = conditionVariable.streamToBuffer;
+exports.strippedPhotoToJpg = conditionVariable.strippedPhotoToJpg;
+exports.svgPathToFile = conditionVariable.svgPathToFile;
+exports.timers = conditionVariable.timers;
+exports.toInputChannel = conditionVariable.toInputChannel;
+exports.toInputPeer = conditionVariable.toInputPeer;
+exports.toInputUser = conditionVariable.toInputUser;
+exports.toggleChannelIdMark = conditionVariable.toggleChannelIdMark;
+exports.BaseService = sortedArray.BaseService;
+exports.CurrentUserService = sortedArray.CurrentUserService;
+exports.DefaultDcsService = sortedArray.DefaultDcsService;
+exports.EarlyTimer = sortedArray.EarlyTimer;
+exports.LruSet = sortedArray.LruSet;
+exports.SortedArray = sortedArray.SortedArray;
+exports.SortedLinkedList = sortedArray.SortedLinkedList;
+exports.UpdatesStateService = sortedArray.UpdatesStateService;
+exports.addPublicKey = sortedArray.addPublicKey;
+exports.asyncResettable = sortedArray.asyncResettable;
+exports.bigIntAbs = sortedArray.bigIntAbs;
+exports.bigIntBitLength = sortedArray.bigIntBitLength;
+exports.bigIntGcd = sortedArray.bigIntGcd;
+exports.bigIntMin = sortedArray.bigIntMin;
+exports.bigIntModInv = sortedArray.bigIntModInv;
+exports.bigIntModPow = sortedArray.bigIntModPow;
+exports.bigIntToBuffer = sortedArray.bigIntToBuffer;
+exports.bufferToBigInt = sortedArray.bufferToBigInt;
+exports.composeMiddlewares = sortedArray.composeMiddlewares;
+exports.createAesIgeForMessage = sortedArray.createAesIgeForMessage;
+exports.createAesIgeForMessageOld = sortedArray.createAesIgeForMessageOld;
+exports.defaultProductionDc = sortedArray.defaultProductionDc;
+exports.defaultProductionIpv6Dc = sortedArray.defaultProductionIpv6Dc;
+exports.defaultTestDc = sortedArray.defaultTestDc;
+exports.defaultTestIpv6Dc = sortedArray.defaultTestIpv6Dc;
+exports.findKeyByFingerprints = sortedArray.findKeyByFingerprints;
+exports.generateKeyAndIvFromNonce = sortedArray.generateKeyAndIvFromNonce;
+exports.millerRabin = sortedArray.millerRabin;
+exports.parseBasicDcOption = sortedArray.parseBasicDcOption;
+exports.parsePublicKey = sortedArray.parsePublicKey;
+exports.randomBigInt = sortedArray.randomBigInt;
+exports.randomBigIntBits = sortedArray.randomBigIntBits;
+exports.randomBigIntInRange = sortedArray.randomBigIntInRange;
+exports.serializeBasicDcOption = sortedArray.serializeBasicDcOption;
+exports.throttle = sortedArray.throttle;
+exports.twoMultiplicity = sortedArray.twoMultiplicity;
+exports.xorBuffer = sortedArray.xorBuffer;
+exports.xorBufferInPlace = sortedArray.xorBufferInPlace;
+exports.assertTrue = controllablePromise.assertTrue;
+exports.assertTypeIs = controllablePromise.assertTypeIs;
+exports.assertTypeIsNot = controllablePromise.assertTypeIsNot;
+exports.createControllablePromise = controllablePromise.createControllablePromise;
+exports.hasValueAtKey = controllablePromise.hasValueAtKey;
+exports.isPresent = controllablePromise.isPresent;
+exports.isTlRpcError = controllablePromise.isTlRpcError;
+exports.mtpAssertTypeIs = controllablePromise.mtpAssertTypeIs;
+exports.LogManager = logger.LogManager;
+exports.Logger = logger.Logger;
+exports.computeNewPasswordHash = tlJson.computeNewPasswordHash;
+exports.computePasswordHash = tlJson.computePasswordHash;
+exports.computeSrpParams = tlJson.computeSrpParams;
+exports.jsonToTlJson = tlJson.jsonToTlJson;
+exports.readStringSession = tlJson.readStringSession;
+exports.tlJsonToJson = tlJson.tlJsonToJson;
+exports.writeStringSession = tlJson.writeStringSession;
+exports.BaseCryptoProvider = BaseCryptoProvider;
+exports.RpsMeter = RpsMeter;
+exports.factorizePQSync = factorizePQSync;
+exports.joinTextWithEntities = joinTextWithEntities;
+exports.links = bundle;
+Object.keys(tlRuntime).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => tlRuntime[k]
+  });
+});

package/utils.d.cts

@@ -0,0 +1 @@
+export * from './utils/index.js'

package/utils.d.ts

@@ -1 +1 @@
-export * from './esm/utils/index.js'
+export * from './utils/index.js'