@mtcute/core 0.16.6 → 0.16.9

package/index.cjs

@@ -0,0 +1,1284 @@
+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 Long = require("long");
+const conditionVariable = require("./chunks/cjs/eX3zeDAz.js");
+const tl = require("@mtcute/tl");
+const client = require("./chunks/cjs/CS5mxbeO.js");
+const storyViewer = require("./chunks/cjs/UVFvMVPt.js");
+const controllablePromise = require("./chunks/cjs/CZAB54t2.js");
+const peersIndex = require("./chunks/cjs/ija5tZ1t.js");
+require("@mtcute/tl-runtime");
+const EventEmitter = require("node:events");
+const platform = require("./chunks/cjs/j7rWn_1y.js");
+const reader_js = require("@mtcute/tl/binary/reader.js");
+const writer_js = require("@mtcute/tl/binary/writer.js");
+const sortedArray = require("./chunks/cjs/C1cFqHcW.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: storyViewer.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 factories = /* @__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 = conditionVariable.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 = conditionVariable.dataViewFromBuffer(ret);
+    dv.setUint32(0, packet.length, true);
+    ret.set(packet, 4);
+    return ret;
+  }
+  _packetAvailable() {
+    return this._stream.length >= 8;
+  }
+  _handlePacket() {
+    const dv = conditionVariable.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 client.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 = conditionVariable.getRandomInt(16);
+    const ret = new Uint8Array(packet.length + 4 + padSize);
+    const dv = conditionVariable.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 = conditionVariable.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 = conditionVariable.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(conditionVariable.concatBuffers([encryptKey, this._proxy.secret]));
+      decryptKey = this._crypto.sha256(conditionVariable.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 (controllablePromise.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: client.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 = platform.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: reader_js.__tlReaderMap,
+        writerMap: writer_js.__tlWriterMap,
+        log: this._driver["_log"]
+      };
+      if (obj.self) {
+        new sortedArray.CurrentUserService(this, options).store({
+          userId: obj.self.userId,
+          isBot: obj.self.isBot,
+          isPremium: false,
+          usernames: []
+        });
+      }
+      if (obj.pts) {
+        const svc = new sortedArray.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 sortedArray.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 platform.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;
+}
+exports.Long = Long;
+exports.assertNever = conditionVariable.assertNever;
+exports.getAllPeersFrom = conditionVariable.getAllPeersFrom;
+exports.getBarePeerId = conditionVariable.getBarePeerId;
+exports.getMarkedPeerId = conditionVariable.getMarkedPeerId;
+exports.parseMarkedPeerId = conditionVariable.parseMarkedPeerId;
+exports.toggleChannelIdMark = conditionVariable.toggleChannelIdMark;
+Object.defineProperty(exports, "mtp", {
+  enumerable: true,
+  get: () => tl.mtp
+});
+Object.defineProperty(exports, "tl", {
+  enumerable: true,
+  get: () => tl.tl
+});
+exports.BotChatJoinRequestUpdate = client.BotChatJoinRequestUpdate$2;
+exports.BotReactionCountUpdate = client.BotReactionCountUpdate$2;
+exports.BotReactionUpdate = client.BotReactionUpdate$2;
+exports.BotStoppedUpdate = client.BotStoppedUpdate$2;
+exports.BusinessCallbackQuery = client.BusinessCallbackQuery$2;
+exports.BusinessMessage = client.BusinessMessage;
+exports.CallbackQuery = client.CallbackQuery$2;
+exports.ChatJoinRequestUpdate = client.ChatJoinRequestUpdate$2;
+exports.ChatMemberUpdate = client.ChatMemberUpdate$2;
+exports.ChosenInlineResult = client.ChosenInlineResult$2;
+exports.Conversation = client.Conversation;
+exports.DeleteBusinessMessageUpdate = client.DeleteBusinessMessageUpdate$2;
+exports.DeleteMessageUpdate = client.DeleteMessageUpdate$1;
+exports.DeleteStoryUpdate = client.DeleteStoryUpdate$2;
+exports.HistoryReadUpdate = client.HistoryReadUpdate$1;
+exports.InlineCallbackQuery = client.InlineCallbackQuery$2;
+exports.InlineQuery = client.InlineQuery$2;
+exports.MtClient = client.MtClient;
+exports.PollUpdate = client.PollUpdate$2;
+exports.PollVoteUpdate = client.PollVoteUpdate$2;
+exports.PreCheckoutQuery = client.PreCheckoutQuery$2;
+exports.SessionConnection = client.SessionConnection;
+exports.StorageManager = client.StorageManager;
+exports.StoryUpdate = client.StoryUpdate$2;
+exports.TelegramStorageManager = client.TelegramStorageManager;
+exports.TransportError = client.TransportError;
+exports.TransportState = client.TransportState;
+exports.UpdatesManager = client.UpdatesManager;
+exports.UserStatusUpdate = client.UserStatusUpdate$2;
+exports.UserTypingUpdate = client.UserTypingUpdate$1;
+exports.defaultReconnectionStrategy = client.defaultReconnectionStrategy;
+exports.AllStories = storyViewer.AllStories$2;
+exports.Audio = storyViewer.Audio$2;
+exports.Boost = storyViewer.Boost$2;
+exports.BoostSlot = storyViewer.BoostSlot$2;
+exports.BoostStats = storyViewer.BoostStats$1;
+exports.BotInline = storyViewer.factories$1;
+exports.BotInlineMessage = storyViewer.factories;
+exports.BotKeyboard = storyViewer.factories$2;
+exports.BotKeyboardBuilder = storyViewer.BotKeyboardBuilder;
+exports.BusinessAccount = storyViewer.BusinessAccount$2;
+exports.BusinessChatLink = storyViewer.BusinessChatLink$2;
+exports.BusinessConnection = storyViewer.BusinessConnection$2;
+exports.BusinessIntro = storyViewer.BusinessIntro$2;
+exports.BusinessWorkHours = storyViewer.BusinessWorkHours$2;
+exports.Chat = storyViewer.Chat$2;
+exports.ChatEvent = storyViewer.ChatEvent$2;
+exports.ChatInviteLink = storyViewer.ChatInviteLink$2;
+exports.ChatInviteLinkMember = storyViewer.ChatInviteLinkMember$2;
+exports.ChatLocation = storyViewer.ChatLocation$2;
+exports.ChatMember = storyViewer.ChatMember$2;
+exports.ChatPermissions = storyViewer.ChatPermissions$1;
+exports.ChatPhoto = storyViewer.ChatPhoto$2;
+exports.ChatPhotoSize = storyViewer.ChatPhotoSize$2;
+exports.ChatPreview = storyViewer.ChatPreview$2;
+exports.ChatlistPreview = storyViewer.ChatlistPreview$2;
+exports.CollectibleInfo = storyViewer.CollectibleInfo$1;
+exports.Contact = storyViewer.Contact$1;
+exports.Dialog = storyViewer.Dialog$2;
+exports.Dice = storyViewer.Dice$1;
+exports.Document = storyViewer.Document$2;
+exports.DraftMessage = storyViewer.DraftMessage$2;
+exports.ExtendedMediaPreview = storyViewer.ExtendedMediaPreview$2;
+exports.FactCheck = storyViewer.FactCheck$2;
+exports.FileLocation = storyViewer.FileLocation$1;
+exports.ForumTopic = storyViewer.ForumTopic$2;
+exports.FullChat = storyViewer.FullChat$2;
+exports.Game = storyViewer.Game$2;
+exports.GameHighScore = storyViewer.GameHighScore$2;
+exports.Invoice = storyViewer.Invoice$2;
+exports.LiveLocation = storyViewer.LiveLocation$1;
+exports.Location = storyViewer.Location$1;
+exports.MASK_POSITION_POINT_TO_TL = storyViewer.MASK_POSITION_POINT_TO_TL;
+exports.MediaStory = storyViewer.MediaStory$1;
+exports.Message = storyViewer.Message$2;
+exports.MessageEffect = storyViewer.MessageEffect$2;
+exports.MessageEntity = storyViewer.MessageEntity$2;
+exports.MessageForwardInfo = storyViewer.MessageForwardInfo$2;
+exports.MessageReactions = storyViewer.MessageReactions$2;
+exports.MessageRepliesInfo = storyViewer.MessageRepliesInfo$2;
+exports.PaidMedia = storyViewer.PaidMedia$2;
+exports.PaidPeerReaction = storyViewer.PaidPeerReaction$2;
+exports.PeerReaction = storyViewer.PeerReaction$2;
+exports.PeerStories = storyViewer.PeerStories$2;
+exports.Photo = storyViewer.Photo$2;
+exports.Poll = storyViewer.Poll$2;
+exports.PollAnswer = storyViewer.PollAnswer$2;
+exports.RawDocument = storyViewer.RawDocument;
+exports.RawLocation = storyViewer.RawLocation;
+exports.RepliedMessageInfo = storyViewer.RepliedMessageInfo$2;
+exports.SearchFilters = storyViewer.SearchFilters;
+exports.SentCode = storyViewer.SentCode$1;
+exports.StarsStatus = storyViewer.StarsStatus$2;
+exports.StarsTransaction = storyViewer.StarsTransaction$2;
+exports.Sticker = storyViewer.Sticker$2;
+exports.StickerSet = storyViewer.StickerSet$2;
+exports.StoriesStealthMode = storyViewer.StoriesStealthMode$1;
+exports.Story = storyViewer.Story$2;
+exports.StoryInteractions = storyViewer.StoryInteractions$2;
+exports.StoryInteractiveChannelPost = storyViewer.StoryInteractiveChannelPost$2;
+exports.StoryInteractiveLocation = storyViewer.StoryInteractiveLocation$2;
+exports.StoryInteractiveReaction = storyViewer.StoryInteractiveReaction$1;
+exports.StoryInteractiveUrl = storyViewer.StoryInteractiveUrl;
+exports.StoryInteractiveVenue = storyViewer.StoryInteractiveVenue$2;
+exports.StoryInteractiveWeather = storyViewer.StoryInteractiveWeather$1;
+exports.StoryRepost = storyViewer.StoryRepost;
+exports.StoryViewer = storyViewer.StoryViewer$2;
+exports.StoryViewersList = storyViewer.StoryViewersList$2;
+exports.TakeoutSession = storyViewer.TakeoutSession$1;
+exports.Thumbnail = storyViewer.Thumbnail$2;
+exports.User = storyViewer.User$2;
+exports.Venue = storyViewer.Venue$2;
+exports.Video = storyViewer.Video$2;
+exports.Voice = storyViewer.Voice$2;
+exports.WebDocument = storyViewer.WebDocument$1;
+exports.WebPage = storyViewer.WebPage$2;
+exports._actionFromTl = storyViewer._actionFromTl;
+exports._callDiscardReasonFromTl = storyViewer._callDiscardReasonFromTl;
+exports._callDiscardReasonToTl = storyViewer._callDiscardReasonToTl;
+exports._messageActionFromTl = storyViewer._messageActionFromTl;
+exports._messageMediaFromTl = storyViewer._messageMediaFromTl;
+exports._storyInteractiveElementFromTl = storyViewer._storyInteractiveElementFromTl;
+exports.businessWorkHoursDaysToRaw = storyViewer.businessWorkHoursDaysToRaw;
+exports.inputTextToTl = storyViewer.inputTextToTl;
+exports.isUploadedFile = storyViewer.isUploadedFile;
+exports.normalizeInputMessageId = storyViewer.normalizeInputMessageId;
+exports.normalizeInputReaction = storyViewer.normalizeInputReaction;
+exports.normalizeInputStickerSet = storyViewer.normalizeInputStickerSet;
+exports.parsePeer = storyViewer.parsePeer;
+exports.toReactionEmoji = storyViewer.toReactionEmoji;
+exports.MtEmptyError = controllablePromise.MtEmptyError;
+exports.MtInvalidPeerTypeError = controllablePromise.MtInvalidPeerTypeError;
+exports.MtMessageNotFoundError = controllablePromise.MtMessageNotFoundError;
+exports.MtPeerNotFoundError = controllablePromise.MtPeerNotFoundError;
+exports.PeersIndex = peersIndex.PeersIndex;
+exports.MtArgumentError = platform.MtArgumentError;
+exports.MtSecurityError = platform.MtSecurityError;
+exports.MtTimeoutError = platform.MtTimeoutError;
+exports.MtTypeAssertionError = platform.MtTypeAssertionError;
+exports.MtUnsupportedError = platform.MtUnsupportedError;
+exports.MtcuteError = platform.MtcuteError;
+exports.BaseSqliteStorage = BaseSqliteStorage;
+exports.BaseSqliteStorageDriver = BaseSqliteStorageDriver;
+exports.BaseStorageDriver = BaseStorageDriver;
+exports.BotCommands = inner;
+exports.InputMedia = factories;
+exports.IntermediatePacketCodec = IntermediatePacketCodec;
+exports.MemoryStorage = MemoryStorage;
+exports.MemoryStorageDriver = MemoryStorageDriver;
+exports.ObfuscatedPacketCodec = ObfuscatedPacketCodec;
+exports.PaddedIntermediatePacketCodec = PaddedIntermediatePacketCodec;
+exports.PrivacyRule = bundle$1;
+exports.StoryElement = StoryElement;
+exports.StreamedCodec = StreamedCodec;
+exports.WrappedCodec = WrappedCodec;
+exports.networkMiddlewares = bundle;