@mtcute/core 0.16.6 → 0.16.9

package/README.md

@@ -45,4 +45,4 @@ const self = await tg.start({
     password: 'my-password',
 })
 console.log(`✨ logged in as ${self.displayName}`)
-```
+```

package/chunks/cjs/BQETTb_8.js

@@ -0,0 +1,229 @@
+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";
+const tlRuntime = require("@mtcute/tl-runtime");
+const platform = require("./j7rWn_1y.js");
+const sortedArray = require("./C1cFqHcW.js");
+const conditionVariable = require("./eX3zeDAz.js");
+const controllablePromise = require("./CZAB54t2.js");
+function readTlDcOption(reader) {
+  const ctorId = reader.uint();
+  if (ctorId !== 414687501) {
+    throw new platform.MtArgumentError(`Invalid dcOption constructor id: ${ctorId}`);
+  }
+  const flags = reader.uint();
+  const id = reader.int();
+  const ipAddress = reader.string();
+  const port = reader.int();
+  if (flags & 1024) {
+    reader.bytes();
+  }
+  return {
+    id,
+    ipAddress,
+    port,
+    ipv6: Boolean(flags & 1),
+    mediaOnly: Boolean(flags & 2)
+  };
+}
+function writeStringSession(data) {
+  const writer = tlRuntime.TlBinaryWriter.manual(512);
+  const version = data.version;
+  if (version !== 3) {
+    throw new platform.MtArgumentError(`Unsupported string session version: ${version}`);
+  }
+  let flags = 0;
+  if (data.self) {
+    flags |= 1;
+  }
+  if (data.testMode) {
+    flags |= 2;
+  }
+  writer.uint8View[0] = version;
+  writer.pos += 1;
+  if (version >= 2 && data.primaryDcs.media !== data.primaryDcs.main) {
+    flags |= 4;
+  }
+  writer.int(flags);
+  writer.bytes(sortedArray.serializeBasicDcOption(data.primaryDcs.main));
+  if (version >= 2 && data.primaryDcs.media !== data.primaryDcs.main) {
+    writer.bytes(sortedArray.serializeBasicDcOption(data.primaryDcs.media));
+  }
+  if (data.self) {
+    writer.int53(data.self.userId);
+    writer.boolean(data.self.isBot);
+  }
+  writer.bytes(data.authKey);
+  return platform.getPlatform().base64Encode(writer.result(), true);
+}
+function readStringSession(data) {
+  const buf = platform.getPlatform().base64Decode(data, true);
+  const version = buf[0];
+  if (version !== 1 && version !== 2 && version !== 3) {
+    throw new Error(`Invalid session string (version = ${version})`);
+  }
+  if (version < 3) {
+    console.warn(
+      `You are using a deprecated session string (${data.slice(
+        0,
+        10
+      )}...). Please update your session string, as it will stop working in the future.`
+    );
+  }
+  const reader = tlRuntime.TlBinaryReader.manual(buf, 1);
+  const flags = reader.int();
+  const hasSelf = flags & 1;
+  const testMode = Boolean(flags & 2);
+  const hasMedia = version >= 2 && Boolean(flags & 4);
+  let primaryDc;
+  let primaryMediaDc;
+  if (version <= 2) {
+    const primaryDc_ = readTlDcOption(reader);
+    const primaryMediaDc_ = hasMedia ? readTlDcOption(reader) : primaryDc_;
+    primaryDc = primaryDc_;
+    primaryMediaDc = primaryMediaDc_;
+  } else if (version === 3) {
+    const primaryDc_ = sortedArray.parseBasicDcOption(reader.bytes());
+    if (primaryDc_ === null) {
+      throw new platform.MtArgumentError("Invalid session string (failed to parse primaryDc)");
+    }
+    const primaryMediaDc_ = hasMedia ? sortedArray.parseBasicDcOption(reader.bytes()) : primaryDc_;
+    if (primaryMediaDc_ === null) {
+      throw new platform.MtArgumentError("Invalid session string (failed to parse primaryMediaDc)");
+    }
+    primaryDc = primaryDc_;
+    primaryMediaDc = primaryMediaDc_;
+  } else {
+    throw new Error("unreachable");
+  }
+  let self = null;
+  if (hasSelf) {
+    const selfId = reader.int53();
+    const selfBot = reader.boolean();
+    self = {
+      userId: selfId,
+      isBot: selfBot,
+      // todo: we should make sure we fetch this from the server at first start
+      isPremium: false,
+      usernames: []
+    };
+  }
+  const key = reader.bytes();
+  return {
+    version,
+    testMode,
+    primaryDcs: {
+      main: primaryDc,
+      media: primaryMediaDc
+    },
+    self,
+    authKey: key
+  };
+}
+async function computePasswordHash(crypto, password, salt1, salt2) {
+  const SH = (data, salt) => crypto.sha256(conditionVariable.concatBuffers([salt, data, salt]));
+  const PH1 = (pwd, salt12, salt22) => SH(SH(pwd, salt12), salt22);
+  return SH(await crypto.pbkdf2(PH1(password, salt1, salt2), salt1, 1e5), salt2);
+}
+async function computeNewPasswordHash(crypto, algo, password) {
+  controllablePromise.assertTypeIs("account.getPassword", algo, "passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow");
+  const salt1 = new Uint8Array(algo.salt1.length + 32);
+  salt1.set(algo.salt1);
+  crypto.randomFill(salt1.subarray(algo.salt1.length));
+  algo.salt1 = salt1;
+  const _x = await computePasswordHash(crypto, platform.getPlatform().utf8Encode(password), algo.salt1, algo.salt2);
+  const g = BigInt(algo.g);
+  const p = sortedArray.bufferToBigInt(algo.p);
+  const x = sortedArray.bufferToBigInt(_x);
+  return sortedArray.bigIntToBuffer(sortedArray.bigIntModPow(g, x, p), 256);
+}
+async function computeSrpParams(crypto, request, password) {
+  if (!request.currentAlgo || request.currentAlgo._ !== "passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow") {
+    throw new platform.MtUnsupportedError(`Unknown algo ${request.currentAlgo?._}`);
+  }
+  const algo = request.currentAlgo;
+  if (!request.srpB) {
+    throw new platform.MtSecurityError("SRP_B is not present in the request");
+  }
+  if (!request.srpId) {
+    throw new platform.MtSecurityError("SRP_ID is not present in the request");
+  }
+  const g = BigInt(algo.g);
+  const _g = sortedArray.bigIntToBuffer(g, 256);
+  const p = sortedArray.bufferToBigInt(algo.p);
+  const gB = sortedArray.bufferToBigInt(request.srpB);
+  const a = sortedArray.bufferToBigInt(crypto.randomBytes(256));
+  const gA = sortedArray.bigIntModPow(g, a, p);
+  const _gA = sortedArray.bigIntToBuffer(gA, 256);
+  const H = (data) => crypto.sha256(data);
+  const _k = crypto.sha256(conditionVariable.concatBuffers([algo.p, _g]));
+  const _u = crypto.sha256(conditionVariable.concatBuffers([_gA, request.srpB]));
+  const _x = await computePasswordHash(crypto, platform.getPlatform().utf8Encode(password), algo.salt1, algo.salt2);
+  const k = sortedArray.bufferToBigInt(_k);
+  const u = sortedArray.bufferToBigInt(_u);
+  const x = sortedArray.bufferToBigInt(_x);
+  const v = sortedArray.bigIntModPow(g, x, p);
+  const kV = k * v % p;
+  let t = gB - kV;
+  if (t < 0n) t += p;
+  const sA = sortedArray.bigIntModPow(t, a + u * x, p);
+  const _kA = H(sortedArray.bigIntToBuffer(sA, 256));
+  const _M1 = H(conditionVariable.concatBuffers([sortedArray.xorBuffer(H(algo.p), H(_g)), H(algo.salt1), H(algo.salt2), _gA, request.srpB, _kA]));
+  return {
+    _: "inputCheckPasswordSRP",
+    srpId: request.srpId,
+    A: _gA,
+    M1: _M1
+  };
+}
+function jsonToTlJson(obj) {
+  if (obj === null || obj === void 0) return { _: "jsonNull" };
+  if (typeof obj === "boolean") return { _: "jsonBool", value: obj };
+  if (typeof obj === "number") return { _: "jsonNumber", value: obj };
+  if (typeof obj === "string") return { _: "jsonString", value: obj };
+  if (Array.isArray(obj)) {
+    return { _: "jsonArray", value: obj.map(jsonToTlJson) };
+  }
+  if (typeof obj !== "object") {
+    throw new platform.MtArgumentError(`Unsupported type: ${typeof obj}`);
+  }
+  const items = [];
+  Object.entries(obj).forEach(([key, value]) => {
+    items.push({
+      _: "jsonObjectValue",
+      key,
+      value: jsonToTlJson(value)
+    });
+  });
+  return {
+    _: "jsonObject",
+    value: items
+  };
+}
+function tlJsonToJson(obj) {
+  switch (obj._) {
+    case "jsonNull":
+      return null;
+    case "jsonBool":
+    case "jsonNumber":
+    case "jsonString":
+      return obj.value;
+    case "jsonArray":
+      return obj.value.map(tlJsonToJson);
+  }
+  const ret = {};
+  obj.value.forEach((item) => {
+    ret[item.key] = tlJsonToJson(item.value);
+  });
+  return ret;
+}
+exports.computeNewPasswordHash = computeNewPasswordHash;
+exports.computePasswordHash = computePasswordHash;
+exports.computeSrpParams = computeSrpParams;
+exports.jsonToTlJson = jsonToTlJson;
+exports.readStringSession = readStringSession;
+exports.tlJsonToJson = tlJsonToJson;
+exports.writeStringSession = writeStringSession;

package/chunks/cjs/BijPAnvP.js

@@ -0,0 +1,181 @@
+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";
+function writeQuery(query) {
+  if (!query) return "";
+  let str = "";
+  for (const [key, value] of Object.entries(query)) {
+    if (value == void 0) continue;
+    if (str) str += "&";
+    if (value === true) {
+      str += `${key}`;
+      continue;
+    }
+    str += `${key}=${encodeURIComponent(value)}`;
+  }
+  if (!str) return "";
+  return `?${str}`;
+}
+// @__NO_SIDE_EFFECTS__
+function deeplinkBuilder(params) {
+  const { internalBuild, internalParse, externalBuild, externalParse } = params;
+  const fn_ = (options) => {
+    const { protocol = "https", domain = "t.me", ...rest } = options;
+    if (protocol === "tg") {
+      if (!internalBuild) throw new Error("tg:// deeplink is not supported");
+      const [path2, query2] = internalBuild(rest);
+      return `tg://${path2}${writeQuery(query2)}`;
+    }
+    if (!externalBuild) throw new Error("t.me deeplink is not supported");
+    const [path, query] = externalBuild(rest);
+    return `${protocol}://${domain}/${path}${writeQuery(query)}`;
+  };
+  const fn = fn_;
+  fn.parse = (url) => {
+    const isInternal = url.startsWith("tg://");
+    if (isInternal) url = `https://fake/${url.slice(5)}`;
+    const parsed = new URL(url);
+    if (isInternal) {
+      if (!internalParse) throw new Error("tg:// deeplink is not supported");
+      const path2 = parsed.pathname.slice(1);
+      return internalParse(path2, parsed.searchParams);
+    }
+    if (!externalParse) throw new Error("t.me deeplink is not supported");
+    const path = parsed.pathname.slice(1);
+    return externalParse(path, parsed.searchParams);
+  };
+  return fn;
+}
+const chatInvite = /* @__PURE__ */ deeplinkBuilder({
+  internalBuild: ({ hash }) => ["join", { invite: hash }],
+  internalParse: (path, query) => {
+    if (path !== "join") return null;
+    const invite = query.get("invite");
+    if (!invite) return null;
+    return { hash: invite };
+  },
+  externalBuild: ({ hash }) => [`+${hash}`, null],
+  externalParse: (path) => {
+    const m = path.match(/^(?:\+|joinchat\/)([\w-]+)$/);
+    if (!m) return null;
+    if (m[1].match(/^\d+$/)) {
+      return null;
+    }
+    return { hash: m[1] };
+  }
+});
+const chatFolder = /* @__PURE__ */ deeplinkBuilder({
+  internalBuild: ({ slug }) => ["addlist", { slug }],
+  internalParse: (path, query) => {
+    if (path !== "addlist") return null;
+    const slug = query.get("slug");
+    if (!slug) return null;
+    return { slug };
+  },
+  externalBuild: ({ slug }) => [`addlist/${slug}`, null],
+  externalParse: (path) => {
+    const [prefix, slug] = path.split("/");
+    if (prefix !== "addlist") return null;
+    return { slug };
+  }
+});
+function parseMediaTimestamp(timestamp) {
+  let m;
+  if (m = timestamp.match(/^(\d+)$/)) {
+    return Number(m[1]);
+  }
+  if (m = timestamp.match(/^(\d+):(\d{1,2})$/)) {
+    return Number(m[1]) * 60 + Number(m[2]);
+  }
+  if (m = timestamp.match(/^(?:(\d+)h)?(?:(\d{1,2})m)?(\d{1,2})s$/)) {
+    return (Number(m[1]) || 0) * 3600 + (Number(m[2]) || 0) * 60 + (Number(m[3]) || 0);
+  }
+  return void 0;
+}
+const message = /* @__PURE__ */ deeplinkBuilder({
+  internalBuild: (params) => {
+    const common = {
+      post: params.id,
+      thread: params.threadId,
+      comment: params.commentId,
+      t: params.mediaTimestamp,
+      single: params.single ? "" : void 0
+    };
+    if ("username" in params) {
+      return ["resolve", { domain: params.username, ...common }];
+    }
+    return ["privatepost", { channel: params.channelId, ...common }];
+  },
+  internalParse: (path, query) => {
+    const common = {
+      id: Number(query.get("post")),
+      threadId: query.has("thread") ? Number(query.get("thread")) : void 0,
+      commentId: query.has("comment") ? Number(query.get("comment")) : void 0,
+      mediaTimestamp: query.has("t") ? parseMediaTimestamp(query.get("t")) : void 0,
+      single: query.has("single")
+    };
+    if (path === "resolve") {
+      const username = query.get("domain");
+      if (!username) return null;
+      return { username, ...common };
+    }
+    if (path === "privatepost") {
+      const channelId = Number(query.get("channel"));
+      if (!channelId) return null;
+      return { channelId, ...common };
+    }
+    return null;
+  },
+  externalBuild: (params) => {
+    const common = {
+      comment: params.commentId,
+      t: params.mediaTimestamp,
+      single: params.single ? "" : void 0
+    };
+    if ("username" in params) {
+      if (params.threadId) {
+        return [`${params.username}/${params.threadId}/${params.id}`, common];
+      }
+      return [`${params.username}/${params.id}`, common];
+    }
+    if (params.threadId) {
+      return [`c/${params.channelId}/${params.threadId}/${params.id}`, common];
+    }
+    return [`c/${params.channelId}/${params.id}`, common];
+  },
+  externalParse: (path, query) => {
+    const chunks = path.split("/");
+    if (chunks.length < 2) return null;
+    const id = Number(chunks[chunks.length - 1]);
+    if (Number.isNaN(id)) return null;
+    const common = {
+      id,
+      commentId: query.has("comment") ? Number(query.get("comment")) : void 0,
+      mediaTimestamp: query.has("t") ? parseMediaTimestamp(query.get("t")) : void 0,
+      single: query.has("single")
+    };
+    if (chunks[0] === "c") {
+      const channelId = Number(chunks[1]);
+      if (Number.isNaN(channelId)) return null;
+      return {
+        channelId,
+        threadId: chunks[3] ? Number(chunks[2]) : void 0,
+        ...common
+      };
+    }
+    const username = chunks[0];
+    if (username[0] === "+") return null;
+    return {
+      username,
+      threadId: chunks[2] ? Number(chunks[1]) : void 0,
+      ...common
+    };
+  }
+});
+exports.chatFolder = chatFolder;
+exports.chatInvite = chatInvite;
+exports.deeplinkBuilder = deeplinkBuilder;
+exports.message = message;