@mtcute/core 0.16.6 → 0.16.9

package/chunks/cjs/eX3zeDAz.js

@@ -0,0 +1,1128 @@
+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 tl = require("@mtcute/tl");
+const controllablePromise = require("./CZAB54t2.js");
+const Long = require("long");
+const platform = require("./j7rWn_1y.js");
+const tlRuntime = require("@mtcute/tl-runtime");
+function assertNever(_) {
+  throw new Error("Illegal state");
+}
+const INVITE_LINK_REGEX = /^(?:https?:\/\/)?(?:www\.)?t(?:elegram)?\.(?:org|me|dog)\/(?:joinchat\/|\+)([\w-]+)$/i;
+function toInputPeer(res) {
+  if (tl.tl.isAnyInputPeer(res)) return res;
+  switch (res._) {
+    case "inputChannelEmpty":
+    case "inputUserEmpty":
+      return { _: "inputPeerEmpty" };
+    case "inputUser":
+      return {
+        _: "inputPeerUser",
+        userId: res.userId,
+        accessHash: res.accessHash
+      };
+    case "inputUserSelf":
+      return { _: "inputPeerSelf" };
+    case "inputChannel":
+      return {
+        _: "inputPeerChannel",
+        channelId: res.channelId,
+        accessHash: res.accessHash
+      };
+    case "inputChannelFromMessage":
+      return {
+        _: "inputPeerChannelFromMessage",
+        channelId: res.channelId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+    case "inputUserFromMessage":
+      return {
+        _: "inputPeerUserFromMessage",
+        userId: res.userId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+    default:
+      assertNever();
+  }
+}
+function toInputUser(res, input) {
+  if (tl.tl.isAnyInputUser(res)) return res;
+  switch (res._) {
+    case "inputPeerSelf":
+      return { _: "inputUserSelf" };
+    case "inputPeerUser":
+      return {
+        _: "inputUser",
+        userId: res.userId,
+        accessHash: res.accessHash
+      };
+    case "inputPeerUserFromMessage":
+      return {
+        _: "inputUserFromMessage",
+        userId: res.userId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+  }
+  throw new controllablePromise.MtInvalidPeerTypeError(input ?? res, "user");
+}
+function toInputChannel(res, input) {
+  if (tl.tl.isAnyInputChannel(res)) return res;
+  switch (res._) {
+    case "inputPeerChannel":
+      return {
+        _: "inputChannel",
+        channelId: res.channelId,
+        accessHash: res.accessHash
+      };
+    case "inputPeerChannelFromMessage":
+      return {
+        _: "inputChannelFromMessage",
+        channelId: res.channelId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+  }
+  throw new controllablePromise.MtInvalidPeerTypeError(input ?? res, "channel");
+}
+function isInputPeerUser(obj) {
+  switch (obj._) {
+    case "inputPeerUser":
+    case "inputPeerUserFromMessage":
+    case "inputPeerSelf":
+      return true;
+  }
+  return false;
+}
+function isInputPeerChannel(obj) {
+  switch (obj._) {
+    case "inputPeerChannel":
+    case "inputPeerChannelFromMessage":
+      return true;
+  }
+  return false;
+}
+function isInputPeerChat(obj) {
+  return obj._ === "inputPeerChat";
+}
+function inputPeerToPeer(inp) {
+  switch (inp._) {
+    case "inputPeerUser":
+    case "inputPeerUserFromMessage":
+      return { _: "peerUser", userId: inp.userId };
+    case "inputPeerChannel":
+    case "inputPeerChannelFromMessage":
+      return { _: "peerChannel", channelId: inp.channelId };
+    case "inputPeerChat":
+      return { _: "peerChat", chatId: inp.chatId };
+    default:
+      throw new controllablePromise.MtInvalidPeerTypeError(inp, `Cannot convert ${inp._} to peer`);
+  }
+}
+function extractUsernames(obj) {
+  if (obj.usernames?.length) return obj.usernames.map((x) => x.username.toLowerCase());
+  if (obj.username) return [obj.username.toLowerCase()];
+  return [];
+}
+function buffersEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function cloneBuffer(buf, start = 0, end = buf.length) {
+  const ret = new Uint8Array(end - start);
+  ret.set(buf.subarray(start, end));
+  return ret;
+}
+function concatBuffers(buffers) {
+  if (buffers.length === 1) return buffers[0];
+  if (typeof Buffer !== "undefined") {
+    return Buffer.concat(buffers);
+  }
+  let length = 0;
+  for (const buf of buffers) {
+    length += buf.length;
+  }
+  const ret = new Uint8Array(length);
+  let offset = 0;
+  for (const buf of buffers) {
+    ret.set(buf, offset);
+    offset += buf.length;
+  }
+  return ret;
+}
+function dataViewFromBuffer(buf) {
+  return new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function bufferToReversed(buf, start = 0, end = buf.length) {
+  const len = end - start;
+  const ret = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    ret[i] = buf[end - i - 1];
+  }
+  return ret;
+}
+const setTimeoutWrap = (...args) => setTimeout(...args);
+const setIntervalWrap = (...args) => setInterval(...args);
+let setImmediateWrap;
+if (typeof setImmediate !== "undefined") {
+  setImmediateWrap = (...args) => setImmediate(...args);
+} else {
+  setImmediateWrap = (fn, ...args) => setTimeout(fn, 0, ...args);
+}
+const setImmediateWrapExported = setImmediateWrap;
+const clearTimeoutWrap = (...args) => clearTimeout(...args);
+const clearIntervalWrap = (...args) => clearInterval(...args);
+let clearImmediateWrap;
+if (typeof clearImmediate !== "undefined") {
+  clearImmediateWrap = (...args) => clearImmediate(...args);
+} else {
+  clearImmediateWrap = (timer) => clearTimeout(timer);
+}
+const clearImmediateWrapExported = clearImmediateWrap;
+const timers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  clearImmediate: clearImmediateWrapExported,
+  clearInterval: clearIntervalWrap,
+  clearTimeout: clearTimeoutWrap,
+  setImmediate: setImmediateWrapExported,
+  setInterval: setIntervalWrap,
+  setTimeout: setTimeoutWrap
+}, Symbol.toStringTag, { value: "Module" }));
+const sleep = (ms) => new Promise((resolve) => setTimeoutWrap(resolve, ms));
+function sleepWithAbort(ms, signal) {
+  return new Promise((resolve, reject) => {
+    let timeout;
+    const onAbort = () => {
+      clearTimeoutWrap(timeout);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort);
+    timeout = setTimeoutWrap(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+  });
+}
+function getRandomInt(top) {
+  return Math.floor(Math.random() * top);
+}
+function randomLong(unsigned = false) {
+  const lo = getRandomInt(4294967295);
+  const hi = getRandomInt(4294967295);
+  return new Long(lo, hi, unsigned);
+}
+function longFromBuffer(buf, unsigned = false, le = true) {
+  const dv = dataViewFromBuffer(buf);
+  if (le) {
+    return new Long(dv.getInt32(0, true), dv.getInt32(4, true), unsigned);
+  }
+  return new Long(dv.getInt32(4, false), dv.getInt32(0, false), unsigned);
+}
+function removeFromLongArray(arr, val) {
+  for (let i = 0; i < arr.length; i++) {
+    const v = arr[i];
+    if (v === val || v.eq(val)) {
+      arr.splice(i, 1);
+      return true;
+    }
+  }
+  return false;
+}
+function compareLongs(a, b) {
+  if (a.eq(b)) return 0;
+  if (a.gt(b)) return 1;
+  return -1;
+}
+function longToFastString(val) {
+  return `${val.low}|${val.high}`;
+}
+function longFromFastString(val, unsigned = false) {
+  const parts = val.split("|");
+  if (parts.length !== 2) throw new Error(`Invalid long fast string: ${val}`);
+  const low = Number.parseInt(parts[0]);
+  const high = Number.parseInt(parts[1]);
+  if (Number.isNaN(low) || Number.isNaN(high)) {
+    throw new TypeError(`Invalid long fast string: ${val}`);
+  }
+  return new Long(low, high, unsigned);
+}
+class LongMap {
+  _map = /* @__PURE__ */ new Map();
+  set(key, value) {
+    this._map.set(longToFastString(key), value);
+  }
+  has(key) {
+    return this._map.has(longToFastString(key));
+  }
+  get(key) {
+    return this._map.get(longToFastString(key));
+  }
+  delete(key) {
+    this._map.delete(longToFastString(key));
+  }
+  *keys(unsigned) {
+    for (const v of this._map.keys()) {
+      yield longFromFastString(v, unsigned);
+    }
+  }
+  values() {
+    return this._map.values();
+  }
+  clear() {
+    this._map.clear();
+  }
+  size() {
+    return this._map.size;
+  }
+}
+class LongSet {
+  _set = /* @__PURE__ */ new Set();
+  get size() {
+    return this._set.size;
+  }
+  add(val) {
+    this._set.add(longToFastString(val));
+  }
+  delete(val) {
+    this._set.delete(longToFastString(val));
+  }
+  has(val) {
+    return this._set.has(longToFastString(val));
+  }
+  clear() {
+    this._set.clear();
+  }
+  toArray() {
+    const arr = [];
+    for (const v of this._set) {
+      arr.push(longFromFastString(v));
+    }
+    return arr;
+  }
+}
+class LruMap {
+  _capacity;
+  _first;
+  _last;
+  _map;
+  _size = 0;
+  constructor(capacity, forLong = false) {
+    this._capacity = capacity;
+    this._map = forLong ? new LongMap() : /* @__PURE__ */ new Map();
+  }
+  _markUsed(item) {
+    if (item === this._first) {
+      return;
+    }
+    if (item.p) {
+      if (item === this._last) {
+        this._last = item.p;
+      }
+      item.p.n = item.n;
+    }
+    if (item.n) {
+      item.n.p = item.p;
+    }
+    item.p = void 0;
+    item.n = this._first;
+    if (this._first) {
+      this._first.p = item;
+    }
+    this._first = item;
+  }
+  get(key) {
+    const item = this._map.get(key);
+    if (!item) return void 0;
+    this._markUsed(item);
+    return item.v;
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  _remove(item) {
+    if (item.p) {
+      this._last = item.p;
+      this._last.n = void 0;
+    } else {
+      this._last = void 0;
+      this._first = void 0;
+    }
+    item.p = item.n = void 0;
+    this._map.delete(item.k);
+    this._size -= 1;
+  }
+  set(key, value) {
+    let item = this._map.get(key);
+    if (item) {
+      item.v = value;
+      this._markUsed(item);
+      return;
+    }
+    item = {
+      k: key,
+      v: value,
+      // for jit to optimize stuff
+      n: void 0,
+      p: void 0
+    };
+    this._map.set(key, item);
+    if (this._first) {
+      this._first.p = item;
+      item.n = this._first;
+    } else {
+      this._last = item;
+    }
+    this._first = item;
+    this._size += 1;
+    if (this._size > this._capacity) {
+      const oldest = this._last;
+      if (oldest) {
+        this._remove(oldest);
+      }
+    }
+  }
+  delete(key) {
+    const item = this._map.get(key);
+    if (item) this._remove(item);
+  }
+  clear() {
+    this._map.clear();
+    this._first = void 0;
+    this._last = void 0;
+    this._size = 0;
+  }
+}
+const ZERO_CHANNEL_ID = -1e12;
+const ZERO_SECRET_CHAT_ID = -2e12;
+const MAX_SECRET_CHAT_ID = -1997852516353;
+const MIN_MARKED_CHAT_ID = -999999999999;
+const MAX_USER_ID = 1099511627775;
+const MIN_MARKED_CHANNEL_ID = -1997852516352;
+function toggleChannelIdMark(id) {
+  return ZERO_CHANNEL_ID - id;
+}
+function getBarePeerId(peer) {
+  switch (peer._) {
+    case "peerUser":
+      return peer.userId;
+    case "peerChat":
+      return peer.chatId;
+    case "peerChannel":
+      return peer.channelId;
+  }
+}
+function getMarkedPeerId(peer, peerType) {
+  if (typeof peer === "number") {
+    switch (peerType) {
+      case "user":
+        return peer;
+      case "chat":
+        return -peer;
+      case "channel":
+        return ZERO_CHANNEL_ID - peer;
+    }
+    throw new platform.MtArgumentError("Invalid peer type");
+  }
+  switch (peer._) {
+    case "mtcute.dummyInputPeerMinUser":
+    case "peerUser":
+    case "inputPeerUser":
+    case "inputPeerUserFromMessage":
+    case "inputUser":
+    case "inputUserFromMessage":
+      return peer.userId;
+    case "peerChat":
+    case "inputPeerChat":
+      return -peer.chatId;
+    case "mtcute.dummyInputPeerMinChannel":
+    case "peerChannel":
+    case "inputPeerChannel":
+    case "inputPeerChannelFromMessage":
+    case "inputChannel":
+    case "inputChannelFromMessage":
+      return ZERO_CHANNEL_ID - peer.channelId;
+  }
+  throw new platform.MtArgumentError(`Invalid peer: ${peer._}`);
+}
+function parseMarkedPeerId(id) {
+  if (id < 0) {
+    if (MIN_MARKED_CHAT_ID <= id) {
+      return ["chat", -id];
+    }
+    if (MIN_MARKED_CHANNEL_ID <= id && id !== ZERO_CHANNEL_ID) {
+      return ["channel", ZERO_CHANNEL_ID - id];
+    }
+    if (MAX_SECRET_CHAT_ID >= id && id !== ZERO_SECRET_CHAT_ID) {
+      throw new platform.MtUnsupportedError("Secret chats are not supported");
+    }
+  } else if (id > 0 && id <= MAX_USER_ID) {
+    return ["user", id];
+  }
+  throw new platform.MtArgumentError(`Invalid marked peer id: ${id}`);
+}
+function* getAllPeersFrom(obj) {
+  if (typeof obj !== "object") return;
+  if (Array.isArray(obj)) {
+    for (const it of obj) {
+      yield* getAllPeersFrom(it);
+    }
+    return;
+  }
+  switch (obj._) {
+    case "user":
+    case "chat":
+    case "channel":
+    case "chatForbidden":
+    case "channelForbidden":
+      yield obj;
+      return;
+  }
+  if ("user" in obj && typeof obj.user === "object" && obj.user._ === "user") {
+    yield obj.user;
+  }
+  if ("chat" in obj && typeof obj.chat === "object") {
+    switch (obj.chat._) {
+      case "chat":
+      case "channel":
+      case "chatForbidden":
+      case "channelForbidden":
+        yield obj.chat;
+        break;
+    }
+  }
+  if ("channel" in obj && typeof obj.channel === "object") {
+    switch (obj.channel._) {
+      case "chat":
+      case "channel":
+      case "chatForbidden":
+      case "channelForbidden":
+        yield obj.channel;
+        break;
+    }
+  }
+  if ("users" in obj && Array.isArray(obj.users) && obj.users.length) {
+    for (const user of obj.users) {
+      if (typeof user === "object" && user._ === "user") {
+        yield user;
+      }
+    }
+  }
+  if ("chats" in obj && Array.isArray(obj.chats) && obj.chats.length) {
+    for (const chat of obj.chats) {
+      if (typeof chat === "object") {
+        switch (chat._) {
+          case "chat":
+          case "channel":
+          case "chatForbidden":
+          case "channelForbidden":
+            yield chat;
+            break;
+        }
+      }
+    }
+  }
+}
+function determinePartSize(fileSize) {
+  if (fileSize <= 262078465) return 128;
+  if (fileSize <= 786432e3) return 256;
+  if (fileSize <= 2097152e3) return 512;
+  throw new platform.MtArgumentError("File is too large");
+}
+function isProbablyPlainText(buf) {
+  return !buf.some(
+    (it) => !(it >= 32 && it < 127 || it === 13 || it === 10 || it === 9)
+  );
+}
+function JPEG_HEADER() {
+  return platform.getPlatform().hexDecode(
+    "ffd8ffe000104a46494600010100000100010000ffdb004300281c1e231e19282321232d2b28303c64413c37373c7b585d4964918099968f808c8aa0b4e6c3a0aadaad8a8cc8ffcbdaeef5ffffff9bc1fffffffaffe6fdfff8ffdb0043012b2d2d3c353c76414176f8a58ca5f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8ffc00011080000000003012200021101031101ffc4001f0000010501010101010100000000000000000102030405060708090a0bffc400b5100002010303020403050504040000017d01020300041105122131410613516107227114328191a1082342b1c11552d1f02433627282090a161718191a25262728292a3435363738393a434445464748494a535455565758595a636465666768696a737475767778797a838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae1e2e3e4e5e6e7e8e9eaf1f2f3f4f5f6f7f8f9faffc4001f0100030101010101010101010000000000000102030405060708090a0bffc400b51100020102040403040705040400010277000102031104052131061241510761711322328108144291a1b1c109233352f0156272d10a162434e125f11718191a262728292a35363738393a434445464748494a535455565758595a636465666768696a737475767778797a82838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae2e3e4e5e6e7e8e9eaf2f3f4f5f6f7f8f9faffda000c03010002110311003f00"
+  );
+}
+let JPEG_HEADER_BYTES = null;
+const JPEG_FOOTER = new Uint8Array([255, 217]);
+function strippedPhotoToJpg(stripped) {
+  if (stripped.length < 3 || stripped[0] !== 1) {
+    throw new platform.MtArgumentError("Invalid stripped JPEG");
+  }
+  if (JPEG_HEADER_BYTES === null) {
+    JPEG_HEADER_BYTES = JPEG_HEADER();
+  }
+  const result = concatBuffers([JPEG_HEADER_BYTES, stripped.slice(3), JPEG_FOOTER]);
+  result[164] = stripped[1];
+  result[166] = stripped[2];
+  return result;
+}
+const SVG_LOOKUP = "AACAAAAHAAALMAAAQASTAVAAAZaacaaaahaaalmaaaqastava.az0123456789-,";
+function inflateSvgPath(encoded) {
+  let path = "M";
+  const len = encoded.length;
+  for (let i = 0; i < len; i++) {
+    const num = encoded[i];
+    if (num >= 192) {
+      path += SVG_LOOKUP[num - 192];
+    } else {
+      if (num >= 128) {
+        path += ",";
+      } else if (num >= 64) {
+        path += "-";
+      }
+      path += num & 63;
+    }
+  }
+  path += "z";
+  return path;
+}
+function svgPathToFile(path, size) {
+  return platform.getPlatform().utf8Encode(
+    `<?xml version="1.0" encoding="utf-8"?><svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"viewBox="0 0 ${size?.w ?? 512} ${size?.h ?? 512}" xml:space="preserve"><path d="${path}"/></svg>`
+  );
+}
+function extractFileName(path) {
+  if (path.startsWith("file:")) path = path.slice(5);
+  return path.split(/[\\/]/).pop().split("?")[0];
+}
+function parseInlineMessageId(id) {
+  const buf = platform.getPlatform().base64Decode(id, true);
+  const reader = tlRuntime.TlBinaryReader.manual(buf);
+  if (buf.length === 20) {
+    return {
+      _: "inputBotInlineMessageID",
+      dcId: reader.int(),
+      id: reader.long(),
+      accessHash: reader.long()
+    };
+  }
+  return {
+    _: "inputBotInlineMessageID64",
+    dcId: reader.int(),
+    ownerId: reader.long(),
+    id: reader.int(),
+    accessHash: reader.long()
+  };
+}
+function encodeInlineMessageId(id) {
+  let writer;
+  switch (id._) {
+    case "inputBotInlineMessageID":
+      writer = tlRuntime.TlBinaryWriter.manual(20);
+      writer.int(id.dcId);
+      writer.long(id.id);
+      writer.long(id.accessHash);
+      break;
+    case "inputBotInlineMessageID64":
+      writer = tlRuntime.TlBinaryWriter.manual(24);
+      writer.int(id.dcId);
+      writer.long(id.ownerId);
+      writer.int(id.id);
+      writer.long(id.accessHash);
+      break;
+    default:
+      assertNever();
+  }
+  return platform.getPlatform().base64Encode(writer.result(), true);
+}
+function normalizeInlineId(id) {
+  if (typeof id === "string") {
+    return parseInlineMessageId(id);
+  }
+  return id;
+}
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+function getAllGettersNames(obj) {
+  const getters = [];
+  do {
+    Object.getOwnPropertyNames(obj).forEach((prop) => {
+      if (prop !== "__proto__" && Object.getOwnPropertyDescriptor(obj, prop)?.get && !getters.includes(prop)) {
+        getters.push(prop);
+      }
+    });
+  } while (obj = Object.getPrototypeOf(obj));
+  return getters;
+}
+function makeInspectable(obj, props, hide) {
+  const getters = props || [];
+  for (const key of getAllGettersNames(obj.prototype)) {
+    if (!hide || !hide.includes(key)) getters.push(key);
+  }
+  const proto = { [obj.name]: class {
+  } }[obj.name].prototype;
+  obj.prototype.toJSON = function() {
+    const ret = Object.create(proto);
+    getters.forEach((it) => {
+      try {
+        let val = this[it];
+        if (val && typeof val === "object") {
+          if (val instanceof Uint8Array) {
+            val = platform.getPlatform().base64Encode(val);
+          } else if (Long.isLong(val)) {
+            val = val.toString();
+          } else if (typeof val.toJSON === "function") {
+            val = val.toJSON(true);
+          }
+        }
+        ret[it] = val;
+      } catch (e) {
+        ret[it] = `Error: ${e.message}`;
+      }
+    });
+    return ret;
+  };
+  obj.prototype[customInspectSymbol] = obj.prototype.toJSON;
+  return obj;
+}
+function normalizePhoneNumber(phone) {
+  phone = phone.trim().replace(/[+()\s-]/g, "");
+  if (!phone.match(/^\d+$/)) throw new platform.MtArgumentError("Invalid phone number");
+  return phone;
+}
+async function resolveMaybeDynamic(val) {
+  return val instanceof Function ? await val() : await val;
+}
+function makeArrayWithTotal(arr, total) {
+  const a = arr;
+  a.total = total;
+  return a;
+}
+function makeArrayPaginated(arr, total, next) {
+  const a = arr;
+  a.total = total;
+  a.next = next;
+  return a;
+}
+function normalizeDate(date) {
+  return date ? ~~((typeof date === "number" ? date : date.getTime()) / 1e3) : void 0;
+}
+function normalizeMessageId(msg) {
+  if (!msg) return void 0;
+  return typeof msg === "number" ? msg : msg.id;
+}
+const MIN_INITIAL_CAPACITY = 8;
+function arraycopy(src, srcPos, dest, destPos, length) {
+  for (let i = 0; i < length; i++) {
+    dest[destPos + i] = src[srcPos + i];
+  }
+}
+class Deque {
+  constructor(maxLength = Infinity, minCapacity = maxLength === Infinity ? MIN_INITIAL_CAPACITY : maxLength) {
+    this.maxLength = maxLength;
+    let capacity = minCapacity;
+    if (capacity < MIN_INITIAL_CAPACITY) {
+      capacity = MIN_INITIAL_CAPACITY;
+    }
+    if (capacity !== MIN_INITIAL_CAPACITY) {
+      capacity |= capacity >>> 1;
+      capacity |= capacity >>> 2;
+      capacity |= capacity >>> 4;
+      capacity |= capacity >>> 8;
+      capacity |= capacity >>> 16;
+      capacity += 1;
+      if (capacity < 0) {
+        capacity >>>= 1;
+      }
+    }
+    this._elements = new Array(capacity);
+    this._capacity = capacity;
+  }
+  // another implementation variant would be to use
+  // blocks of fixed size instead of a single array
+  // to avoid copying stuff around
+  _elements;
+  _head = 0;
+  _tail = 0;
+  _capacity;
+  _resize() {
+    const p = this._head;
+    const n = this._capacity;
+    const r = n - p;
+    const newCapacity = n << 1;
+    if (newCapacity < 0) throw new Error("Deque is too big");
+    const arr = new Array(newCapacity);
+    arraycopy(this._elements, p, arr, 0, r);
+    arraycopy(this._elements, 0, arr, r, p);
+    this._elements = arr;
+    this._head = 0;
+    this._tail = n;
+    this._capacity = newCapacity;
+  }
+  pushBack(item) {
+    if (item === void 0) throw new Error("item can not be undefined");
+    this._elements[this._tail] = item;
+    if ((this._tail = this._tail + 1 & this._capacity - 1) === this._head) {
+      this._resize();
+    }
+    if (this.length > this.maxLength) {
+      this.popFront();
+    }
+  }
+  pushFront(item) {
+    if (item === void 0) throw new Error("item can not be undefined");
+    this._elements[this._head = this._head - 1 & this._capacity - 1] = item;
+    if (this._head === this._tail) {
+      this._resize();
+    }
+    if (this.length > this.maxLength) {
+      this.popBack();
+    }
+  }
+  popFront() {
+    const h = this._head;
+    const res = this._elements[h];
+    if (res === void 0) return void 0;
+    this._elements[h] = void 0;
+    this._head = h + 1 & this._capacity - 1;
+    return res;
+  }
+  popBack() {
+    const t = this._tail - 1 & this._capacity - 1;
+    const res = this._elements[t];
+    if (res === void 0) return void 0;
+    this._elements[t] = void 0;
+    this._tail = t;
+    return res;
+  }
+  peekFront() {
+    return this._elements[this._head];
+  }
+  peekBack() {
+    return this._elements[this._tail - 1 & this._capacity - 1];
+  }
+  get length() {
+    return this._tail - this._head & this._capacity - 1;
+  }
+  toArray() {
+    const sz = this.length;
+    if (sz === 0) return [];
+    const arr = new Array(sz);
+    if (this._head < this._tail) {
+      arraycopy(this._elements, this._head, arr, 0, sz);
+    } else {
+      const headPortion = this._capacity - this._head;
+      arraycopy(this._elements, this._head, arr, 0, headPortion);
+      arraycopy(this._elements, 0, arr, headPortion, this._tail);
+    }
+    return arr;
+  }
+  _delete(i) {
+    const els = this._elements;
+    const mask = this._capacity - 1;
+    const h = this._head;
+    const t = this._tail;
+    const front = i - h & mask;
+    const back = t - i & mask;
+    if (front < back) {
+      if (h <= i) {
+        arraycopy(els, h, els, h + 1, front);
+      } else {
+        arraycopy(els, 0, els, 1, i);
+        els[0] = els[mask];
+        arraycopy(els, h, els, h + 1, mask - h);
+      }
+      els[h] = void 0;
+      this._head = h + 1 & mask;
+    } else if (i < t) {
+      arraycopy(els, i + 1, els, i, back);
+      this._tail = t - 1;
+    } else {
+      arraycopy(els, i + 1, els, i, mask - i);
+      els[mask] = els[0];
+      arraycopy(els, 1, els, 0, t);
+      this._tail = t - 1 & mask;
+    }
+  }
+  remove(item) {
+    const mask = this._capacity - 1;
+    let i = this._head;
+    let val;
+    while ((val = this._elements[i]) !== void 0) {
+      if (item === val) {
+        this._delete(i);
+        return;
+      }
+      i = i + 1 & mask;
+    }
+  }
+  removeBy(pred) {
+    const mask = this._capacity - 1;
+    let i = this._head;
+    let val;
+    while ((val = this._elements[i]) !== void 0) {
+      if (pred(val)) {
+        this._delete(i);
+        return;
+      }
+      i = i + 1 & mask;
+    }
+  }
+  at(idx) {
+    return this._elements[this._head + idx & this._capacity - 1];
+  }
+  *iter() {
+    const sz = this.length;
+    if (sz === 0) return;
+    if (this._head < this._tail) {
+      for (let i = 0; i < sz; i++) {
+        yield this._elements[this._head + i];
+      }
+    } else {
+      const headPortion = this._capacity - this._head;
+      for (let i = 0; i < headPortion; i++) {
+        yield this._elements[this._head + i];
+      }
+      for (let i = 0; i < this._tail; i++) {
+        yield this._elements[i];
+      }
+    }
+  }
+  clear() {
+    this._elements = new Array(this._capacity);
+    this._head = this._tail = 0;
+  }
+}
+class AsyncLock {
+  _queue = new Deque();
+  async acquire() {
+    let info;
+    while (info = this._queue.peekFront()) {
+      await info[0];
+    }
+    let unlock;
+    const prom = new Promise((resolve) => {
+      unlock = resolve;
+    });
+    this._queue.pushBack([prom, unlock]);
+  }
+  release() {
+    if (!this._queue.length) throw new Error("Nothing to release");
+    this._queue.popFront()[1]();
+  }
+  with(func) {
+    let err = null;
+    return this.acquire().then(() => func()).catch((e) => void (err = e)).then(() => {
+      this.release();
+      if (err) throw err;
+    });
+  }
+}
+function bufferToStream(buf) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(buf);
+      controller.close();
+    }
+  });
+}
+async function streamToBuffer(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return concatBuffers(chunks);
+}
+function createChunkedReader(stream, chunkSize) {
+  const reader = stream.getReader();
+  const lock = new AsyncLock();
+  const buffer = [];
+  let bufferLength = 0;
+  let next;
+  let first = true;
+  async function readInner() {
+    const { value } = await reader.read();
+    if (first) {
+      first = false;
+      const { value: nextValue } = await reader.read();
+      next = nextValue;
+      return value;
+    }
+    const tmp = next;
+    next = value;
+    return tmp;
+  }
+  async function read() {
+    if (bufferLength > chunkSize) {
+      const chunks = [];
+      let length = 0;
+      while (length < chunkSize && buffer.length) {
+        const chunk = buffer.shift();
+        length += chunk.length;
+        chunks.push(chunk);
+      }
+      if (length > chunkSize) {
+        const lastChunk = chunks.pop();
+        const diff = length - chunkSize;
+        chunks.push(lastChunk.subarray(0, lastChunk.length - diff));
+        buffer.unshift(lastChunk.subarray(lastChunk.length - diff));
+        length = chunkSize;
+      }
+      if (length === chunkSize) {
+        bufferLength -= chunkSize;
+        return concatBuffers(chunks);
+      }
+    } else if (next === void 0 && bufferLength > 0) {
+      bufferLength = 0;
+      return concatBuffers(buffer);
+    }
+    const value = await readInner();
+    if (!value) return null;
+    if (bufferLength > 0) {
+      buffer.push(value);
+      bufferLength += value.length;
+      return read();
+    }
+    if (value.length > chunkSize) {
+      const rest = value.subarray(chunkSize);
+      buffer.push(rest);
+      bufferLength += rest.length;
+      return value.subarray(0, chunkSize);
+    }
+    if (value.length === chunkSize) {
+      return value;
+    }
+    buffer.push(value);
+    bufferLength += value.length;
+    return read();
+  }
+  async function readLocked() {
+    await lock.acquire();
+    let res = null;
+    let err = null;
+    try {
+      res = await read();
+    } catch (e) {
+      err = e;
+    }
+    lock.release();
+    if (err) throw err;
+    return res;
+  }
+  return {
+    ended: () => bufferLength === 0 && next === void 0,
+    read: readLocked
+  };
+}
+function decodeWaveform(wf) {
+  const bitsCount = wf.length * 8;
+  const valuesCount = ~~(bitsCount / 5);
+  if (!valuesCount) return [];
+  const lastIdx = valuesCount - 1;
+  const result = [];
+  const dv = dataViewFromBuffer(wf);
+  for (let i = 0, j = 0; i < lastIdx; i++, j += 5) {
+    const byteIdx = ~~(j / 8);
+    const bitShift = j % 8;
+    result[i] = dv.getUint16(byteIdx, true) >> bitShift & 31;
+  }
+  const lastByteIdx = ~~(lastIdx * 5 / 8);
+  const lastBitShift = lastIdx * 5 % 8;
+  const lastValue = lastByteIdx === wf.length - 1 ? wf[lastByteIdx] : dv.getUint16(lastByteIdx, true);
+  result[lastIdx] = lastValue >> lastBitShift & 31;
+  return result;
+}
+function encodeWaveform(wf) {
+  const bitsCount = wf.length * 5;
+  const bytesCount = ~~((bitsCount + 7) / 8);
+  const result = new Uint8Array(bytesCount + 1);
+  const dv = dataViewFromBuffer(result);
+  for (let i = 0, j = 0; i < wf.length; i++, j += 5) {
+    const byteIdx = ~~(j / 8);
+    const bitShift = j % 8;
+    const value = (wf[i] & 31) << bitShift;
+    dv.setUint16(byteIdx, dv.getUint16(byteIdx, true) | value, true);
+  }
+  return result.slice(0, bytesCount);
+}
+class ConditionVariable {
+  _notify;
+  _timeout;
+  wait(timeout) {
+    const prom = new Promise((resolve) => {
+      this._notify = resolve;
+    });
+    if (timeout) {
+      this._timeout = setTimeoutWrap(() => {
+        this._notify?.();
+        this._timeout = void 0;
+      }, timeout);
+    }
+    return prom;
+  }
+  notify() {
+    this._notify?.();
+    if (this._timeout) clearTimeoutWrap(this._timeout);
+    this._notify = void 0;
+  }
+}
+exports.AsyncLock = AsyncLock;
+exports.ConditionVariable = ConditionVariable;
+exports.Deque = Deque;
+exports.INVITE_LINK_REGEX = INVITE_LINK_REGEX;
+exports.LongMap = LongMap;
+exports.LongSet = LongSet;
+exports.LruMap = LruMap;
+exports.assertNever = assertNever;
+exports.bufferToReversed = bufferToReversed;
+exports.bufferToStream = bufferToStream;
+exports.buffersEqual = buffersEqual;
+exports.clearImmediateWrapExported = clearImmediateWrapExported;
+exports.clearIntervalWrap = clearIntervalWrap;
+exports.clearTimeoutWrap = clearTimeoutWrap;
+exports.cloneBuffer = cloneBuffer;
+exports.compareLongs = compareLongs;
+exports.concatBuffers = concatBuffers;
+exports.createChunkedReader = createChunkedReader;
+exports.dataViewFromBuffer = dataViewFromBuffer;
+exports.decodeWaveform = decodeWaveform;
+exports.determinePartSize = determinePartSize;
+exports.encodeInlineMessageId = encodeInlineMessageId;
+exports.encodeWaveform = encodeWaveform;
+exports.extractFileName = extractFileName;
+exports.extractUsernames = extractUsernames;
+exports.getAllPeersFrom = getAllPeersFrom;
+exports.getBarePeerId = getBarePeerId;
+exports.getMarkedPeerId = getMarkedPeerId;
+exports.getRandomInt = getRandomInt;
+exports.inflateSvgPath = inflateSvgPath;
+exports.inputPeerToPeer = inputPeerToPeer;
+exports.isInputPeerChannel = isInputPeerChannel;
+exports.isInputPeerChat = isInputPeerChat;
+exports.isInputPeerUser = isInputPeerUser;
+exports.isProbablyPlainText = isProbablyPlainText;
+exports.longFromBuffer = longFromBuffer;
+exports.longFromFastString = longFromFastString;
+exports.longToFastString = longToFastString;
+exports.makeArrayPaginated = makeArrayPaginated;
+exports.makeArrayWithTotal = makeArrayWithTotal;
+exports.makeInspectable = makeInspectable;
+exports.normalizeDate = normalizeDate;
+exports.normalizeInlineId = normalizeInlineId;
+exports.normalizeMessageId = normalizeMessageId;
+exports.normalizePhoneNumber = normalizePhoneNumber;
+exports.parseInlineMessageId = parseInlineMessageId;
+exports.parseMarkedPeerId = parseMarkedPeerId;
+exports.randomLong = randomLong;
+exports.removeFromLongArray = removeFromLongArray;
+exports.resolveMaybeDynamic = resolveMaybeDynamic;
+exports.setImmediateWrapExported = setImmediateWrapExported;
+exports.setIntervalWrap = setIntervalWrap;
+exports.setTimeoutWrap = setTimeoutWrap;
+exports.sleep = sleep;
+exports.sleepWithAbort = sleepWithAbort;
+exports.streamToBuffer = streamToBuffer;
+exports.strippedPhotoToJpg = strippedPhotoToJpg;
+exports.svgPathToFile = svgPathToFile;
+exports.timers = timers;
+exports.toInputChannel = toInputChannel;
+exports.toInputPeer = toInputPeer;
+exports.toInputUser = toInputUser;
+exports.toggleChannelIdMark = toggleChannelIdMark;