@mtcute/core 0.16.6 → 0.16.9

package/index.js

@@ -1 +1,1279 @@
-export * from './esm/index.js'
+import Long from "long";
+import { default as default2 } from "long";
+import { concatBuffers, dataViewFromBuffer, getRandomInt, bufferToReversed } from "./chunks/es/DY1E3mHM.js";
+import { assertNever, getAllPeersFrom, getBarePeerId, getMarkedPeerId, parseMarkedPeerId, toggleChannelIdMark } from "./chunks/es/DY1E3mHM.js";
+import { mtp, tl } from "@mtcute/tl";
+import { TransportError, basic } from "./chunks/es/BbjNWA_t.js";
+import { BotChatJoinRequestUpdate$2, BotReactionCountUpdate$2, BotReactionUpdate$2, BotStoppedUpdate$2, BusinessCallbackQuery$2, BusinessMessage, CallbackQuery$2, ChatJoinRequestUpdate$2, ChatMemberUpdate$2, ChosenInlineResult$2, Conversation, DeleteBusinessMessageUpdate$2, DeleteMessageUpdate$1, DeleteStoryUpdate$2, HistoryReadUpdate$1, InlineCallbackQuery$2, InlineQuery$2, MtClient, PollUpdate$2, PollVoteUpdate$2, PreCheckoutQuery$2, SessionConnection, StorageManager, StoryUpdate$2, TelegramStorageManager, TransportState, UpdatesManager, UserStatusUpdate$2, UserTypingUpdate$1, defaultReconnectionStrategy } from "./chunks/es/BbjNWA_t.js";
+import { normalizeInputReaction } from "./chunks/es/CPnecqvf.js";
+import { AllStories$2, Audio$2, Boost$2, BoostSlot$2, BoostStats$1, factories$1, factories, factories$2, BotKeyboardBuilder, BusinessAccount$2, BusinessChatLink$2, BusinessConnection$2, BusinessIntro$2, BusinessWorkHours$2, Chat$2, ChatEvent$2, ChatInviteLink$2, ChatInviteLinkMember$2, ChatLocation$2, ChatMember$2, ChatPermissions$1, ChatPhoto$2, ChatPhotoSize$2, ChatPreview$2, ChatlistPreview$2, CollectibleInfo$1, Contact$1, Dialog$2, Dice$1, Document$2, DraftMessage$2, ExtendedMediaPreview$2, FactCheck$2, FileLocation$1, ForumTopic$2, FullChat$2, Game$2, GameHighScore$2, Invoice$2, LiveLocation$1, Location$1, MASK_POSITION_POINT_TO_TL, MediaStory$1, Message$2, MessageEffect$2, MessageEntity$2, MessageForwardInfo$2, MessageReactions$2, MessageRepliesInfo$2, PaidMedia$2, PaidPeerReaction$2, PeerReaction$2, PeerStories$2, Photo$2, Poll$2, PollAnswer$2, RawDocument, RawLocation, RepliedMessageInfo$2, SearchFilters, SentCode$1, StarsStatus$2, StarsTransaction$2, Sticker$2, StickerSet$2, StoriesStealthMode$1, Story$2, StoryInteractions$2, StoryInteractiveChannelPost$2, StoryInteractiveLocation$2, StoryInteractiveReaction$1, StoryInteractiveUrl, StoryInteractiveVenue$2, StoryInteractiveWeather$1, StoryRepost, StoryViewer$2, StoryViewersList$2, TakeoutSession$1, Thumbnail$2, User$2, Venue$2, Video$2, Voice$2, WebDocument$1, WebPage$2, _actionFromTl, _callDiscardReasonFromTl, _callDiscardReasonToTl, _messageActionFromTl, _messageMediaFromTl, _storyInteractiveElementFromTl, businessWorkHoursDaysToRaw, inputTextToTl, isUploadedFile, normalizeInputMessageId, normalizeInputStickerSet, parsePeer, toReactionEmoji } from "./chunks/es/CPnecqvf.js";
+import { isTlRpcError } from "./chunks/es/BN3qj7tU.js";
+import { MtEmptyError, MtInvalidPeerTypeError, MtMessageNotFoundError, MtPeerNotFoundError } from "./chunks/es/BN3qj7tU.js";
+import { PeersIndex } from "./chunks/es/N3PMYmCL.js";
+import "@mtcute/tl-runtime";
+import EventEmitter from "node:events";
+import { getPlatform, MtcuteError } from "./chunks/es/DBMBgE7t.js";
+import { MtArgumentError, MtSecurityError, MtTimeoutError, MtTypeAssertionError, MtUnsupportedError } from "./chunks/es/DBMBgE7t.js";
+import { __tlReaderMap } from "@mtcute/tl/binary/reader.js";
+import { __tlWriterMap } from "@mtcute/tl/binary/writer.js";
+import { CurrentUserService, UpdatesStateService, DefaultDcsService } from "./chunks/es/CO4G3ySK.js";
+const default_ = {
+  _: "botCommandScopeDefault"
+};
+const allPrivate = {
+  _: "botCommandScopeUsers"
+};
+const allGroups = {
+  _: "botCommandScopeChats"
+};
+const allGroupAdmins = {
+  _: "botCommandScopeChatAdmins"
+};
+function peer(peer2) {
+  return {
+    type: "peer",
+    peer: peer2
+  };
+}
+function groupAdmins(peer2) {
+  return {
+    type: "peer_admins",
+    peer: peer2
+  };
+}
+function groupMember(chat, user) {
+  return {
+    type: "member",
+    chat,
+    user
+  };
+}
+function cmd(command, description) {
+  return {
+    _: "botCommand",
+    command,
+    description
+  };
+}
+const inner = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  allGroupAdmins,
+  allGroups,
+  allPrivate,
+  cmd,
+  default_,
+  groupAdmins,
+  groupMember,
+  peer
+}, Symbol.toStringTag, { value: "Module" }));
+class StoryElement {
+  constructor(_position) {
+    this._position = _position;
+  }
+  static at(params) {
+    return new StoryElement({
+      _: "mediaAreaCoordinates",
+      x: params.x,
+      y: params.y,
+      w: params.width,
+      h: params.height,
+      rotation: params.rotation ?? 0
+    });
+  }
+  venue(params) {
+    return {
+      _: "mediaAreaVenue",
+      coordinates: this._position,
+      geo: {
+        _: "geoPoint",
+        lat: params.latitude,
+        long: params.longitude,
+        accessHash: Long.ZERO
+      },
+      title: params.title,
+      address: params.address,
+      provider: params.source.provider ?? "foursquare",
+      venueId: params.source.id,
+      venueType: params.source.type
+    };
+  }
+  venueFromInline(queryId, resultId) {
+    return {
+      _: "inputMediaAreaVenue",
+      coordinates: this._position,
+      queryId,
+      resultId
+    };
+  }
+  location(params) {
+    return {
+      _: "mediaAreaGeoPoint",
+      coordinates: this._position,
+      geo: {
+        _: "geoPoint",
+        lat: params.latitude,
+        long: params.longitude,
+        accessHash: Long.ZERO
+      }
+    };
+  }
+  reaction(reaction, params = {}) {
+    this._position.h *= 9 / 16;
+    return {
+      _: "mediaAreaSuggestedReaction",
+      coordinates: this._position,
+      reaction: normalizeInputReaction(reaction),
+      dark: params.dark,
+      flipped: params.flipped
+    };
+  }
+  url(url) {
+    return {
+      _: "mediaAreaUrl",
+      coordinates: this._position,
+      url
+    };
+  }
+}
+function animation(file, params = {}) {
+  const ret = params;
+  ret.type = "video";
+  ret.file = file;
+  ret.isAnimated = true;
+  return ret;
+}
+function audio(file, params = {}) {
+  const ret = params;
+  ret.type = "audio";
+  ret.file = file;
+  return ret;
+}
+function document(file, params = {}) {
+  const ret = params;
+  ret.type = "document";
+  ret.file = file;
+  return ret;
+}
+function photo(file, params = {}) {
+  const ret = params;
+  ret.type = "photo";
+  ret.file = file;
+  return ret;
+}
+function video(file, params = {}) {
+  const ret = params;
+  ret.type = "video";
+  ret.file = file;
+  return ret;
+}
+function voice(file, params = {}) {
+  const ret = params;
+  ret.type = "voice";
+  ret.file = file;
+  return ret;
+}
+function sticker(file, params = {}) {
+  const ret = params;
+  ret.type = "sticker";
+  ret.file = file;
+  return ret;
+}
+function venue(params) {
+  const ret = params;
+  ret.type = "venue";
+  return ret;
+}
+function geo(latitude, longitude, params = {}) {
+  const ret = params;
+  ret.type = "geo";
+  ret.latitude = latitude;
+  ret.longitude = longitude;
+  return ret;
+}
+function geoLive(latitude, longitude, params = {}) {
+  const ret = params;
+  ret.type = "geo_live";
+  ret.latitude = latitude;
+  ret.longitude = longitude;
+  return ret;
+}
+function dice(emoji, params) {
+  const ret = params;
+  ret.type = "dice";
+  return ret;
+}
+function contact(params) {
+  const ret = params;
+  ret.type = "contact";
+  return ret;
+}
+function game(game2) {
+  return {
+    type: "game",
+    game: game2
+  };
+}
+function invoice(params) {
+  const ret = params;
+  ret.type = "invoice";
+  return ret;
+}
+function poll(params) {
+  const ret = params;
+  ret.type = "poll";
+  return ret;
+}
+function quiz(params) {
+  const ret = params;
+  ret.type = "quiz";
+  return ret;
+}
+function story(params) {
+  const ret = params;
+  ret.type = "story";
+  return ret;
+}
+function webpage(url, params = {}) {
+  const ret = params;
+  ret.type = "webpage";
+  ret.url = url;
+  return ret;
+}
+function paid(params) {
+  const ret = params;
+  ret.type = "paid";
+  return ret;
+}
+function auto(file, params = {}) {
+  const ret = params;
+  ret.type = "auto";
+  ret.file = file;
+  return ret;
+}
+const factories2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  animation,
+  audio,
+  auto,
+  contact,
+  dice,
+  document,
+  game,
+  geo,
+  geoLive,
+  invoice,
+  paid,
+  photo,
+  poll,
+  quiz,
+  sticker,
+  story,
+  venue,
+  video,
+  voice,
+  webpage
+}, Symbol.toStringTag, { value: "Module" }));
+const all$1 = { _: "inputPrivacyValueAllowAll" };
+const contacts$1 = { _: "inputPrivacyValueAllowContacts" };
+const closeFriends = {
+  _: "inputPrivacyValueAllowCloseFriends"
+};
+function users$1(users2) {
+  return {
+    allow: true,
+    users: Array.isArray(users2) ? users2 : [users2]
+  };
+}
+function chatParticipants$1(chats) {
+  return {
+    allow: true,
+    chats: Array.isArray(chats) ? chats : [chats]
+  };
+}
+const allow = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  all: all$1,
+  chatParticipants: chatParticipants$1,
+  closeFriends,
+  contacts: contacts$1,
+  users: users$1
+}, Symbol.toStringTag, { value: "Module" }));
+const all = { _: "inputPrivacyValueDisallowAll" };
+const contacts = { _: "inputPrivacyValueDisallowContacts" };
+function users(users2) {
+  return {
+    allow: false,
+    users: Array.isArray(users2) ? users2 : [users2]
+  };
+}
+function chatParticipants(chats) {
+  return {
+    allow: false,
+    chats: Array.isArray(chats) ? chats : [chats]
+  };
+}
+const disallow = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  all,
+  chatParticipants,
+  contacts,
+  users
+}, Symbol.toStringTag, { value: "Module" }));
+const bundle$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  allow,
+  disallow
+}, Symbol.toStringTag, { value: "Module" }));
+class StreamedCodec extends EventEmitter {
+  _stream = new Uint8Array(0);
+  feed(data) {
+    this._stream = concatBuffers([this._stream, data]);
+    while (this._packetAvailable()) {
+      if (!this._handlePacket()) break;
+    }
+  }
+  reset() {
+    this._stream = new Uint8Array(0);
+  }
+}
+const TAG = new Uint8Array([238, 238, 238, 238]);
+const PADDED_TAG = new Uint8Array([221, 221, 221, 221]);
+class IntermediatePacketCodec extends StreamedCodec {
+  tag() {
+    return TAG;
+  }
+  encode(packet) {
+    const ret = new Uint8Array(packet.length + 4);
+    const dv = dataViewFromBuffer(ret);
+    dv.setUint32(0, packet.length, true);
+    ret.set(packet, 4);
+    return ret;
+  }
+  _packetAvailable() {
+    return this._stream.length >= 8;
+  }
+  _handlePacket() {
+    const dv = dataViewFromBuffer(this._stream);
+    const payloadLength = dv.getUint32(0, true);
+    if (payloadLength <= this._stream.length - 4) {
+      if (payloadLength === 4) {
+        const code = dv.getInt32(4, true) * -1;
+        this.emit("error", new TransportError(code));
+      } else {
+        const payload = this._stream.subarray(4, payloadLength + 4);
+        this.emit("packet", payload);
+      }
+      this._stream = this._stream.subarray(payloadLength + 4);
+      return true;
+    }
+    return false;
+  }
+}
+class PaddedIntermediatePacketCodec extends IntermediatePacketCodec {
+  tag() {
+    return PADDED_TAG;
+  }
+  _crypto;
+  setup(crypto) {
+    this._crypto = crypto;
+  }
+  encode(packet) {
+    const padSize = getRandomInt(16);
+    const ret = new Uint8Array(packet.length + 4 + padSize);
+    const dv = dataViewFromBuffer(ret);
+    dv.setUint32(0, packet.length + padSize, true);
+    ret.set(packet, 4);
+    this._crypto.randomFill(ret.subarray(4 + packet.length));
+    return ret;
+  }
+}
+class WrappedCodec extends EventEmitter {
+  _crypto;
+  _inner;
+  constructor(inner2) {
+    super();
+    this._inner = inner2;
+    this._inner.on("error", (err) => this.emit("error", err));
+    this._inner.on("packet", (buf) => this.emit("packet", buf));
+  }
+  removeAllListeners() {
+    super.removeAllListeners();
+    this._inner.removeAllListeners();
+    return this;
+  }
+  setup(crypto, log) {
+    this._crypto = crypto;
+    this._inner.setup?.(crypto, log);
+  }
+}
+class ObfuscatedPacketCodec extends WrappedCodec {
+  _encryptor;
+  _decryptor;
+  _proxy;
+  constructor(inner2, proxy) {
+    super(inner2);
+    this._proxy = proxy;
+  }
+  async tag() {
+    let random;
+    let dv;
+    for (; ; ) {
+      random = this._crypto.randomBytes(64);
+      if (random[0] === 239) continue;
+      dv = dataViewFromBuffer(random);
+      const firstInt = dv.getUint32(0, true);
+      if (firstInt === 1145128264 || firstInt === 1414745936 || firstInt === 542393671 || firstInt === 1230262351 || firstInt === 3722304989 || firstInt === 4008636142 || firstInt === 33620758) {
+        continue;
+      }
+      if (dv.getInt32(4, true) === 0) continue;
+      break;
+    }
+    let innerTag = await this._inner.tag();
+    if (innerTag.length !== 4) {
+      const b = innerTag[0];
+      innerTag = new Uint8Array([b, b, b, b]);
+    }
+    random.set(innerTag, 56);
+    if (this._proxy) {
+      let dcId = this._proxy.dcId;
+      if (this._proxy.test) dcId += 1e4;
+      if (this._proxy.media) dcId = -dcId;
+      dv.setInt16(60, dcId, true);
+    }
+    const randomRev = bufferToReversed(random, 8, 56);
+    let encryptKey = random.subarray(8, 40);
+    const encryptIv = random.subarray(40, 56);
+    let decryptKey = randomRev.subarray(0, 32);
+    const decryptIv = randomRev.subarray(32, 48);
+    if (this._proxy) {
+      encryptKey = this._crypto.sha256(concatBuffers([encryptKey, this._proxy.secret]));
+      decryptKey = this._crypto.sha256(concatBuffers([decryptKey, this._proxy.secret]));
+    }
+    this._encryptor = this._crypto.createAesCtr(encryptKey, encryptIv, true);
+    this._decryptor = this._crypto.createAesCtr(decryptKey, decryptIv, false);
+    const encrypted = this._encryptor.process(random);
+    random.set(encrypted.subarray(56, 64), 56);
+    return random;
+  }
+  async encode(packet) {
+    return this._encryptor.process(await this._inner.encode(packet));
+  }
+  feed(data) {
+    const dec = this._decryptor.process(data);
+    this._inner.feed(dec);
+  }
+  reset() {
+    this._inner.reset();
+    this._encryptor?.close?.();
+    this._decryptor?.close?.();
+    this._encryptor = void 0;
+    this._decryptor = void 0;
+  }
+}
+function onRpcError(handler) {
+  return async (ctx, next) => {
+    let res = await next(ctx);
+    if (isTlRpcError(res)) {
+      const handlerRes = await handler(ctx, res);
+      if (handlerRes !== void 0) {
+        res = handlerRes;
+      }
+    }
+    return res;
+  };
+}
+function onMethod(method, middleware) {
+  return async (ctx, next) => {
+    if (ctx.request._ !== method) {
+      return next(ctx);
+    }
+    return middleware(ctx, next);
+  };
+}
+const bundle = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  basic,
+  onMethod,
+  onRpcError
+}, Symbol.toStringTag, { value: "Module" }));
+class BaseStorageDriver {
+  _loadedTimes = 0;
+  _destroyed = false;
+  _log;
+  setup(log) {
+    this._log = log.create("sqlite");
+  }
+  get loaded() {
+    return this._loadedTimes > 0;
+  }
+  async load() {
+    if (this._loadedTimes === 0) {
+      await this._load();
+      this._destroyed = false;
+    }
+    this._loadedTimes++;
+  }
+  async destroy() {
+    if (this._destroyed) {
+      return;
+    }
+    this._loadedTimes--;
+    if (this._loadedTimes === 0) {
+      await this._destroy();
+      this._destroyed = true;
+    }
+  }
+  save() {
+    return this._save?.();
+  }
+}
+class MemoryStorageDriver {
+  states = /* @__PURE__ */ new Map();
+  getState(repo, def) {
+    if (!this.states.has(repo)) {
+      this.states.set(repo, def());
+    }
+    return this.states.get(repo);
+  }
+  load() {
+  }
+}
+class MemoryAuthKeysRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this.state = this._driver.getState("authKeys", () => ({
+      authKeys: /* @__PURE__ */ new Map(),
+      authKeysTemp: /* @__PURE__ */ new Map(),
+      authKeysTempExpiry: /* @__PURE__ */ new Map()
+    }));
+  }
+  state;
+  set(dc, key) {
+    if (key) {
+      this.state.authKeys.set(dc, key);
+    } else {
+      this.state.authKeys.delete(dc);
+    }
+  }
+  get(dc) {
+    return this.state.authKeys.get(dc) ?? null;
+  }
+  setTemp(dc, idx, key, expires) {
+    const k = `${dc}:${idx}`;
+    if (key) {
+      this.state.authKeysTemp.set(k, key);
+      this.state.authKeysTempExpiry.set(k, expires);
+    } else {
+      this.state.authKeysTemp.delete(k);
+      this.state.authKeysTempExpiry.delete(k);
+    }
+  }
+  getTemp(dc, idx, now) {
+    const k = `${dc}:${idx}`;
+    if (now > (this.state.authKeysTempExpiry.get(k) ?? 0)) {
+      return null;
+    }
+    return this.state.authKeysTemp.get(k) ?? null;
+  }
+  deleteByDc(dc) {
+    this.state.authKeys.delete(dc);
+    for (const key of this.state.authKeysTemp.keys()) {
+      if (key.startsWith(`${dc}:`)) {
+        this.state.authKeysTemp.delete(key);
+        this.state.authKeysTempExpiry.delete(key);
+      }
+    }
+  }
+  deleteAll() {
+    this.state.authKeys.clear();
+    this.state.authKeysTemp.clear();
+    this.state.authKeysTempExpiry.clear();
+  }
+}
+class MemoryKeyValueRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this.state = this._driver.getState("kv", () => /* @__PURE__ */ new Map());
+  }
+  state;
+  set(key, value) {
+    this.state.set(key, value);
+  }
+  get(key) {
+    return this.state.get(key) ?? null;
+  }
+  delete(key) {
+    this.state.delete(key);
+  }
+  deleteAll() {
+    this.state.clear();
+  }
+}
+class MemoryPeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this.state = this._driver.getState("peers", () => ({
+      entities: /* @__PURE__ */ new Map(),
+      usernameIndex: /* @__PURE__ */ new Map(),
+      phoneIndex: /* @__PURE__ */ new Map()
+    }));
+  }
+  state;
+  store(peer2) {
+    const old = this.state.entities.get(peer2.id);
+    if (old) {
+      old.usernames.forEach((username) => {
+        this.state.usernameIndex.delete(username);
+      });
+      if (old.phone) {
+        this.state.phoneIndex.delete(old.phone);
+      }
+    }
+    if (peer2.usernames) {
+      for (const username of peer2.usernames) {
+        this.state.usernameIndex.set(username, peer2.id);
+      }
+    }
+    if (peer2.phone) this.state.phoneIndex.set(peer2.phone, peer2.id);
+    this.state.entities.set(peer2.id, peer2);
+  }
+  getById(id) {
+    return this.state.entities.get(id) ?? null;
+  }
+  getByUsername(username) {
+    const id = this.state.usernameIndex.get(username.toLowerCase());
+    if (!id) return null;
+    return this.state.entities.get(id) ?? null;
+  }
+  getByPhone(phone) {
+    const id = this.state.phoneIndex.get(phone);
+    if (!id) return null;
+    return this.state.entities.get(id) ?? null;
+  }
+  deleteAll() {
+    this.state.entities.clear();
+    this.state.phoneIndex.clear();
+    this.state.usernameIndex.clear();
+  }
+}
+class MemoryRefMessagesRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this.state = this._driver.getState("refMessages", () => ({
+      refs: /* @__PURE__ */ new Map()
+    }));
+  }
+  state;
+  store(peerId, chatId, msgId) {
+    if (!this.state.refs.has(peerId)) {
+      this.state.refs.set(peerId, /* @__PURE__ */ new Set());
+    }
+    this.state.refs.get(peerId).add(`${chatId}:${msgId}`);
+  }
+  getByPeer(peerId) {
+    const refs = this.state.refs.get(peerId);
+    if (!refs?.size) return null;
+    const [ref] = refs;
+    const [chatId, msgId] = ref.split(":");
+    return [Number(chatId), Number(msgId)];
+  }
+  delete(chatId, msgIds) {
+    for (const refs of this.state.refs.values()) {
+      for (const msg of msgIds) {
+        refs.delete(`${chatId}:${msg}`);
+      }
+    }
+  }
+  deleteByPeer(peerId) {
+    this.state.refs.delete(peerId);
+  }
+  deleteAll() {
+    this.state.refs.clear();
+  }
+}
+class MemoryStorage {
+  driver = new MemoryStorageDriver();
+  kv = new MemoryKeyValueRepository(this.driver);
+  authKeys = new MemoryAuthKeysRepository(this.driver);
+  peers = new MemoryPeersRepository(this.driver);
+  refMessages = new MemoryRefMessagesRepository(this.driver);
+}
+const MIGRATIONS_TABLE_NAME = "mtcute_migrations";
+const MIGRATIONS_TABLE_SQL = `
+create table if not exists ${MIGRATIONS_TABLE_NAME} (
+    repo text not null primary key,
+    version integer not null
+);
+`.trim();
+class BaseSqliteStorageDriver extends BaseStorageDriver {
+  db;
+  _pending = [];
+  _runMany;
+  _cleanup;
+  _migrations = /* @__PURE__ */ new Map();
+  _maxVersion = /* @__PURE__ */ new Map();
+  // todo: remove in 1.0.0
+  _legacyMigrations = /* @__PURE__ */ new Map();
+  registerLegacyMigration(repo, migration) {
+    if (this.loaded) {
+      throw new Error("Cannot register migrations after loading");
+    }
+    this._legacyMigrations.set(repo, migration);
+  }
+  registerMigration(repo, version, migration) {
+    if (this.loaded) {
+      throw new Error("Cannot register migrations after loading");
+    }
+    let map = this._migrations.get(repo);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this._migrations.set(repo, map);
+    }
+    if (map.has(version)) {
+      throw new Error(`Migration for ${repo} version ${version} is already registered`);
+    }
+    map.set(version, migration);
+    const prevMax = this._maxVersion.get(repo) ?? 0;
+    if (version > prevMax) {
+      this._maxVersion.set(repo, version);
+    }
+  }
+  _onLoad = /* @__PURE__ */ new Set();
+  onLoad(cb) {
+    if (this.loaded) {
+      cb(this.db);
+    } else {
+      this._onLoad.add(cb);
+    }
+  }
+  _writeLater(stmt, params) {
+    this._pending.push([stmt, params]);
+  }
+  _runLegacyMigrations = false;
+  _initialize() {
+    const hasLegacyTables = this.db.prepare("select name from sqlite_master where type = 'table' and name = 'kv'").get();
+    if (hasLegacyTables) {
+      this._log.info("legacy tables detected, will run migrations");
+      this._runLegacyMigrations = true;
+    }
+    this.db.exec(MIGRATIONS_TABLE_SQL);
+    const writeVersion = this.db.prepare(
+      `insert or replace into ${MIGRATIONS_TABLE_NAME} (repo, version) values (?, ?)`
+    );
+    const getVersion = this.db.prepare(`select version from ${MIGRATIONS_TABLE_NAME} where repo = ?`);
+    const didUpgrade = /* @__PURE__ */ new Set();
+    for (const repo of this._migrations.keys()) {
+      const res = getVersion.get(repo);
+      const startVersion = res?.version ?? 0;
+      let fromVersion = startVersion;
+      const migrations = this._migrations.get(repo);
+      const targetVer = this._maxVersion.get(repo);
+      while (fromVersion < targetVer) {
+        const nextVersion = fromVersion + 1;
+        const migration = migrations.get(nextVersion);
+        if (!migration) {
+          throw new Error(`No migration for ${repo} to version ${nextVersion}`);
+        }
+        migration(this.db);
+        fromVersion = nextVersion;
+        didUpgrade.add(repo);
+      }
+      if (fromVersion !== startVersion) {
+        writeVersion.run(repo, targetVer);
+      }
+    }
+  }
+  async _load() {
+    this.db = this._createDatabase();
+    this._runMany = this.db.transaction((stmts) => {
+      stmts.forEach((stmt) => {
+        stmt[0].run(stmt[1]);
+      });
+    });
+    this.db.transaction(() => this._initialize())();
+    this._cleanup = getPlatform().beforeExit(() => {
+      this._save();
+      this._destroy();
+    });
+    for (const cb of this._onLoad) cb(this.db);
+    if (this._runLegacyMigrations) {
+      this.db.transaction(() => {
+        for (const migration of this._legacyMigrations.values()) {
+          migration(this.db);
+        }
+        this._runMany(this._pending);
+      })();
+    }
+  }
+  _save() {
+    if (!this._pending.length) return;
+    this._runMany(this._pending);
+    this._pending = [];
+  }
+  _destroy() {
+    this.db.close();
+    this._cleanup?.();
+    this._cleanup = void 0;
+  }
+}
+class SqliteAuthKeysRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("auth_keys", 1, (db) => {
+      db.exec(`
+                create table if not exists auth_keys (
+                    dc integer primary key,
+                    key blob not null
+                );
+                create table if not exists temp_auth_keys (
+                    dc integer not null,
+                    idx integer not null,
+                    key blob not null,
+                    expires integer not null,
+                    primary key (dc, idx)
+                );
+            `);
+    });
+    _driver.onLoad((db) => {
+      this._get = db.prepare("select key from auth_keys where dc = ?");
+      this._getTemp = db.prepare("select key from temp_auth_keys where dc = ? and idx = ? and expires > ?");
+      this._set = db.prepare("insert or replace into auth_keys (dc, key) values (?, ?)");
+      this._setTemp = this._driver.db.prepare(
+        "insert or replace into temp_auth_keys (dc, idx, key, expires) values (?, ?, ?, ?)"
+      );
+      this._del = db.prepare("delete from auth_keys where dc = ?");
+      this._delTemp = db.prepare("delete from temp_auth_keys where dc = ? and idx = ?");
+      this._delTempAll = db.prepare("delete from temp_auth_keys where dc = ?");
+      this._delAll = db.prepare("delete from auth_keys");
+    });
+  }
+  _set;
+  _del;
+  set(dc, key) {
+    if (!key) {
+      this._del.run(dc);
+      return;
+    }
+    this._set.run(dc, key);
+  }
+  _get;
+  get(dc) {
+    const row = this._get.get(dc);
+    if (!row) return null;
+    return row.key;
+  }
+  _setTemp;
+  _delTemp;
+  setTemp(dc, idx, key, expires) {
+    if (!key) {
+      this._delTemp.run(dc, idx);
+      return;
+    }
+    this._setTemp.run(dc, idx, key, expires);
+  }
+  _getTemp;
+  getTemp(dc, idx, now) {
+    const row = this._getTemp.get(dc, idx, now);
+    if (!row) return null;
+    return row.key;
+  }
+  _delTempAll;
+  deleteByDc(dc) {
+    this._del.run(dc);
+    this._delTempAll.run(dc);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+class SqliteKeyValueRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("kv", 1, (db) => {
+      db.exec(`
+                create table key_value (
+                    key text primary key,
+                    value blob not null
+                );
+            `);
+    });
+    _driver.onLoad((db) => {
+      this._get = db.prepare("select value from key_value where key = ?");
+      this._set = db.prepare("insert or replace into key_value (key, value) values (?, ?)");
+      this._del = db.prepare("delete from key_value where key = ?");
+      this._delAll = db.prepare("delete from key_value");
+    });
+    _driver.registerLegacyMigration("kv", (db) => {
+      const all2 = db.prepare("select key, value from kv").all();
+      const obj = {};
+      for (const { key, value } of all2) {
+        obj[key] = JSON.parse(value);
+      }
+      db.exec("drop table kv");
+      const options = {
+        driver: this._driver,
+        readerMap: __tlReaderMap,
+        writerMap: __tlWriterMap,
+        log: this._driver["_log"]
+      };
+      if (obj.self) {
+        new CurrentUserService(this, options).store({
+          userId: obj.self.userId,
+          isBot: obj.self.isBot,
+          isPremium: false,
+          usernames: []
+        });
+      }
+      if (obj.pts) {
+        const svc = new UpdatesStateService(this, options);
+        svc.setPts(obj.pts);
+        if (obj.qts) svc.setQts(obj.qts);
+        if (obj.date) svc.setDate(obj.date);
+        if (obj.seq) svc.setSeq(obj.seq);
+        const channels = db.prepare("select * from pts").all();
+        for (const channel of channels) {
+          svc.setChannelPts(channel.channel_id, channel.pts);
+        }
+      }
+      db.exec("drop table pts");
+      if (obj.def_dc) {
+        new DefaultDcsService(this, options).store(obj.def_dc);
+      }
+    });
+  }
+  _set;
+  set(key, value) {
+    this._driver._writeLater(this._set, [key, value]);
+  }
+  _get;
+  get(key) {
+    const res = this._get.get(key);
+    if (!res) return null;
+    return res.value;
+  }
+  _del;
+  delete(key) {
+    this._del.run(key);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+function mapPeerDto(dto) {
+  return {
+    id: dto.id,
+    accessHash: dto.hash,
+    usernames: JSON.parse(dto.usernames),
+    updated: dto.updated,
+    phone: dto.phone || void 0,
+    complete: dto.complete
+  };
+}
+class SqlitePeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("peers", 1, (db) => {
+      db.exec(`
+                create table peers (
+                    id integer primary key,
+                    hash text not null,
+                    usernames json not null,
+                    updated integer not null,
+                    phone text,
+                    complete blob
+                );
+                create index idx_peers_usernames on peers (usernames);
+                create index idx_peers_phone on peers (phone);
+            `);
+    });
+    _driver.onLoad((db) => {
+      this._loaded = true;
+      this._store = db.prepare(
+        "insert or replace into peers (id, hash, usernames, updated, phone, complete) values (?, ?, ?, ?, ?, ?)"
+      );
+      this._getById = db.prepare("select * from peers where id = ?");
+      this._getByUsername = db.prepare(
+        "select * from peers where exists (select 1 from json_each(usernames) where value = ?)"
+      );
+      this._getByPhone = db.prepare("select * from peers where phone = ?");
+      this._delAll = db.prepare("delete from peers");
+    });
+    _driver.registerLegacyMigration("peers", (db) => {
+      db.exec("drop table entities");
+    });
+  }
+  _loaded = false;
+  _ensureLoaded() {
+    if (!this._loaded) {
+      throw new MtcuteError("Peers repository is not loaded. Have you called client.start() (or similar)?");
+    }
+  }
+  _store;
+  store(peer2) {
+    this._driver._writeLater(this._store, [
+      peer2.id,
+      peer2.accessHash,
+      JSON.stringify(peer2.usernames),
+      peer2.updated,
+      peer2.phone ?? null,
+      peer2.complete
+    ]);
+  }
+  _getById;
+  getById(id) {
+    this._ensureLoaded();
+    const row = this._getById.get(id);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _getByUsername;
+  getByUsername(username) {
+    this._ensureLoaded();
+    const row = this._getByUsername.get(username);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _getByPhone;
+  getByPhone(phone) {
+    this._ensureLoaded();
+    const row = this._getByPhone.get(phone);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+class SqliteRefMessagesRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("ref_messages", 1, (db) => {
+      db.exec(`
+                create table if not exists message_refs (
+                    peer_id integer not null,
+                    chat_id integer not null,
+                    msg_id integer not null
+                );
+                create index if not exists idx_message_refs_peer on message_refs (peer_id);
+                create index if not exists idx_message_refs on message_refs (chat_id, msg_id);
+            `);
+    });
+    _driver.onLoad(() => {
+      this._store = this._driver.db.prepare(
+        "insert or replace into message_refs (peer_id, chat_id, msg_id) values (?, ?, ?)"
+      );
+      this._getByPeer = this._driver.db.prepare("select chat_id, msg_id from message_refs where peer_id = ?");
+      this._del = this._driver.db.prepare("delete from message_refs where chat_id = ? and msg_id = ?");
+      this._delByPeer = this._driver.db.prepare("delete from message_refs where peer_id = ?");
+      this._delAll = this._driver.db.prepare("delete from message_refs");
+    });
+  }
+  _store;
+  store(peerId, chatId, msgId) {
+    this._store.run(peerId, chatId, msgId);
+  }
+  _getByPeer;
+  getByPeer(peerId) {
+    const res = this._getByPeer.get(peerId);
+    if (!res) return null;
+    const res_ = res;
+    return [res_.chat_id, res_.msg_id];
+  }
+  _del;
+  delete(chatId, msgIds) {
+    for (const msgId of msgIds) {
+      this._driver._writeLater(this._del, [chatId, msgId]);
+    }
+  }
+  _delByPeer;
+  deleteByPeer(peerId) {
+    this._delByPeer.run(peerId);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+class BaseSqliteStorage {
+  constructor(driver) {
+    this.driver = driver;
+    this.authKeys = new SqliteAuthKeysRepository(this.driver);
+    this.kv = new SqliteKeyValueRepository(this.driver);
+    this.refMessages = new SqliteRefMessagesRepository(this.driver);
+    this.peers = new SqlitePeersRepository(this.driver);
+  }
+  authKeys;
+  kv;
+  refMessages;
+  peers;
+}
+export {
+  AllStories$2 as AllStories,
+  Audio$2 as Audio,
+  BaseSqliteStorage,
+  BaseSqliteStorageDriver,
+  BaseStorageDriver,
+  Boost$2 as Boost,
+  BoostSlot$2 as BoostSlot,
+  BoostStats$1 as BoostStats,
+  BotChatJoinRequestUpdate$2 as BotChatJoinRequestUpdate,
+  inner as BotCommands,
+  factories$1 as BotInline,
+  factories as BotInlineMessage,
+  factories$2 as BotKeyboard,
+  BotKeyboardBuilder,
+  BotReactionCountUpdate$2 as BotReactionCountUpdate,
+  BotReactionUpdate$2 as BotReactionUpdate,
+  BotStoppedUpdate$2 as BotStoppedUpdate,
+  BusinessAccount$2 as BusinessAccount,
+  BusinessCallbackQuery$2 as BusinessCallbackQuery,
+  BusinessChatLink$2 as BusinessChatLink,
+  BusinessConnection$2 as BusinessConnection,
+  BusinessIntro$2 as BusinessIntro,
+  BusinessMessage,
+  BusinessWorkHours$2 as BusinessWorkHours,
+  CallbackQuery$2 as CallbackQuery,
+  Chat$2 as Chat,
+  ChatEvent$2 as ChatEvent,
+  ChatInviteLink$2 as ChatInviteLink,
+  ChatInviteLinkMember$2 as ChatInviteLinkMember,
+  ChatJoinRequestUpdate$2 as ChatJoinRequestUpdate,
+  ChatLocation$2 as ChatLocation,
+  ChatMember$2 as ChatMember,
+  ChatMemberUpdate$2 as ChatMemberUpdate,
+  ChatPermissions$1 as ChatPermissions,
+  ChatPhoto$2 as ChatPhoto,
+  ChatPhotoSize$2 as ChatPhotoSize,
+  ChatPreview$2 as ChatPreview,
+  ChatlistPreview$2 as ChatlistPreview,
+  ChosenInlineResult$2 as ChosenInlineResult,
+  CollectibleInfo$1 as CollectibleInfo,
+  Contact$1 as Contact,
+  Conversation,
+  DeleteBusinessMessageUpdate$2 as DeleteBusinessMessageUpdate,
+  DeleteMessageUpdate$1 as DeleteMessageUpdate,
+  DeleteStoryUpdate$2 as DeleteStoryUpdate,
+  Dialog$2 as Dialog,
+  Dice$1 as Dice,
+  Document$2 as Document,
+  DraftMessage$2 as DraftMessage,
+  ExtendedMediaPreview$2 as ExtendedMediaPreview,
+  FactCheck$2 as FactCheck,
+  FileLocation$1 as FileLocation,
+  ForumTopic$2 as ForumTopic,
+  FullChat$2 as FullChat,
+  Game$2 as Game,
+  GameHighScore$2 as GameHighScore,
+  HistoryReadUpdate$1 as HistoryReadUpdate,
+  InlineCallbackQuery$2 as InlineCallbackQuery,
+  InlineQuery$2 as InlineQuery,
+  factories2 as InputMedia,
+  IntermediatePacketCodec,
+  Invoice$2 as Invoice,
+  LiveLocation$1 as LiveLocation,
+  Location$1 as Location,
+  default2 as Long,
+  MASK_POSITION_POINT_TO_TL,
+  MediaStory$1 as MediaStory,
+  MemoryStorage,
+  MemoryStorageDriver,
+  Message$2 as Message,
+  MessageEffect$2 as MessageEffect,
+  MessageEntity$2 as MessageEntity,
+  MessageForwardInfo$2 as MessageForwardInfo,
+  MessageReactions$2 as MessageReactions,
+  MessageRepliesInfo$2 as MessageRepliesInfo,
+  MtArgumentError,
+  MtClient,
+  MtEmptyError,
+  MtInvalidPeerTypeError,
+  MtMessageNotFoundError,
+  MtPeerNotFoundError,
+  MtSecurityError,
+  MtTimeoutError,
+  MtTypeAssertionError,
+  MtUnsupportedError,
+  MtcuteError,
+  ObfuscatedPacketCodec,
+  PaddedIntermediatePacketCodec,
+  PaidMedia$2 as PaidMedia,
+  PaidPeerReaction$2 as PaidPeerReaction,
+  PeerReaction$2 as PeerReaction,
+  PeerStories$2 as PeerStories,
+  PeersIndex,
+  Photo$2 as Photo,
+  Poll$2 as Poll,
+  PollAnswer$2 as PollAnswer,
+  PollUpdate$2 as PollUpdate,
+  PollVoteUpdate$2 as PollVoteUpdate,
+  PreCheckoutQuery$2 as PreCheckoutQuery,
+  bundle$1 as PrivacyRule,
+  RawDocument,
+  RawLocation,
+  RepliedMessageInfo$2 as RepliedMessageInfo,
+  SearchFilters,
+  SentCode$1 as SentCode,
+  SessionConnection,
+  StarsStatus$2 as StarsStatus,
+  StarsTransaction$2 as StarsTransaction,
+  Sticker$2 as Sticker,
+  StickerSet$2 as StickerSet,
+  StorageManager,
+  StoriesStealthMode$1 as StoriesStealthMode,
+  Story$2 as Story,
+  StoryElement,
+  StoryInteractions$2 as StoryInteractions,
+  StoryInteractiveChannelPost$2 as StoryInteractiveChannelPost,
+  StoryInteractiveLocation$2 as StoryInteractiveLocation,
+  StoryInteractiveReaction$1 as StoryInteractiveReaction,
+  StoryInteractiveUrl,
+  StoryInteractiveVenue$2 as StoryInteractiveVenue,
+  StoryInteractiveWeather$1 as StoryInteractiveWeather,
+  StoryRepost,
+  StoryUpdate$2 as StoryUpdate,
+  StoryViewer$2 as StoryViewer,
+  StoryViewersList$2 as StoryViewersList,
+  StreamedCodec,
+  TakeoutSession$1 as TakeoutSession,
+  TelegramStorageManager,
+  Thumbnail$2 as Thumbnail,
+  TransportError,
+  TransportState,
+  UpdatesManager,
+  User$2 as User,
+  UserStatusUpdate$2 as UserStatusUpdate,
+  UserTypingUpdate$1 as UserTypingUpdate,
+  Venue$2 as Venue,
+  Video$2 as Video,
+  Voice$2 as Voice,
+  WebDocument$1 as WebDocument,
+  WebPage$2 as WebPage,
+  WrappedCodec,
+  _actionFromTl,
+  _callDiscardReasonFromTl,
+  _callDiscardReasonToTl,
+  _messageActionFromTl,
+  _messageMediaFromTl,
+  _storyInteractiveElementFromTl,
+  assertNever,
+  businessWorkHoursDaysToRaw,
+  defaultReconnectionStrategy,
+  getAllPeersFrom,
+  getBarePeerId,
+  getMarkedPeerId,
+  inputTextToTl,
+  isUploadedFile,
+  mtp,
+  bundle as networkMiddlewares,
+  normalizeInputMessageId,
+  normalizeInputReaction,
+  normalizeInputStickerSet,
+  parseMarkedPeerId,
+  parsePeer,
+  tl,
+  toReactionEmoji,
+  toggleChannelIdMark
+};