@mtcute/web 0.16.7 → 0.16.13

package/index.cjs

@@ -0,0 +1,965 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/web] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/web] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const client_js = require("@mtcute/core/client.js");
+const platform_js = require("@mtcute/core/platform.js");
+const utils_js = require("@mtcute/core/utils.js");
+const wasm = require("@mtcute/wasm");
+const core = require("@mtcute/core");
+const EventEmitter = require("node:events");
+const worker_js = require("@mtcute/core/worker.js");
+async function loadWasmBinary(input) {
+  if (typeof input === "undefined") {
+    input = wasm.getWasmUrl();
+  }
+  if (typeof input === "string" || typeof Request === "function" && input instanceof Request || typeof URL === "function" && input instanceof URL) {
+    input = await fetch(input);
+  }
+  if (typeof Response === "function" && input instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        const { instance: instance2 } = await WebAssembly.instantiateStreaming(input);
+        return instance2;
+      } catch (e) {
+        if (input.headers.get("Content-Type") !== "application/wasm") {
+          console.warn(
+            "`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+            e
+          );
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await input.arrayBuffer();
+    const { instance } = await WebAssembly.instantiate(bytes);
+    return instance;
+  }
+  return WebAssembly.instantiate(input);
+}
+const ALGO_TO_SUBTLE = {
+  sha256: "SHA-256",
+  sha1: "SHA-1",
+  sha512: "SHA-512"
+};
+class WebCryptoProvider extends utils_js.BaseCryptoProvider {
+  crypto;
+  _wasmInput;
+  sha1(data) {
+    return wasm.sha1(data);
+  }
+  sha256(data) {
+    return wasm.sha256(data);
+  }
+  createAesCtr(key, iv) {
+    const ctx = wasm.createCtr256(key, iv);
+    return {
+      process: (data) => wasm.ctr256(ctx, data),
+      close: () => wasm.freeCtr256(ctx)
+    };
+  }
+  createAesIge(key, iv) {
+    return {
+      encrypt: (data) => wasm.ige256Encrypt(data, key, iv),
+      decrypt: (data) => wasm.ige256Decrypt(data, key, iv)
+    };
+  }
+  gzip(data, maxSize) {
+    return wasm.deflateMaxSize(data, maxSize);
+  }
+  gunzip(data) {
+    return wasm.gunzip(data);
+  }
+  constructor(params) {
+    super();
+    const crypto = params?.crypto ?? globalThis.crypto;
+    if (!crypto || !crypto.subtle) {
+      throw new Error("WebCrypto is not available");
+    }
+    this.crypto = crypto;
+    this._wasmInput = params?.wasmInput;
+  }
+  async initialize() {
+    wasm.initSync(await loadWasmBinary(this._wasmInput));
+  }
+  async pbkdf2(password, salt, iterations, keylen, algo) {
+    const keyMaterial = await this.crypto.subtle.importKey("raw", password, "PBKDF2", false, ["deriveBits"]);
+    return this.crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        salt,
+        iterations,
+        hash: algo ? ALGO_TO_SUBTLE[algo] : "SHA-512"
+      },
+      keyMaterial,
+      (keylen || 64) * 8
+    ).then((result) => new Uint8Array(result));
+  }
+  async hmacSha256(data, key) {
+    const keyMaterial = await this.crypto.subtle.importKey(
+      "raw",
+      key,
+      { name: "HMAC", hash: { name: "SHA-256" } },
+      false,
+      ["sign"]
+    );
+    const res = await this.crypto.subtle.sign({ name: "HMAC" }, keyMaterial, data);
+    return new Uint8Array(res);
+  }
+  randomFill(buf) {
+    this.crypto.getRandomValues(buf);
+  }
+}
+function txToPromise(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function reqToPromise(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+const REPO_VERSION_PREFIX = "__version:";
+class IdbStorageDriver extends core.BaseStorageDriver {
+  constructor(_dbName) {
+    super();
+    this._dbName = _dbName;
+    if (typeof indexedDB === "undefined") {
+      throw new core.MtUnsupportedError("IndexedDB is not available");
+    }
+  }
+  db;
+  _pendingWrites = [];
+  _pendingWritesOses = /* @__PURE__ */ new Set();
+  _migrations = /* @__PURE__ */ new Map();
+  _maxVersion = /* @__PURE__ */ new Map();
+  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);
+    }
+  }
+  writeLater(os, obj) {
+    this._pendingWrites.push([os, obj]);
+    this._pendingWritesOses.add(os);
+  }
+  async _load() {
+    this.db = await new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, Date.now());
+      req.onerror = () => reject(req.error);
+      const postUpgrade = [];
+      req.onsuccess = async () => {
+        try {
+          for (const cb of postUpgrade) {
+            await cb(req.result);
+          }
+          resolve(req.result);
+        } catch (e) {
+          reject(e);
+        }
+      };
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        const didUpgrade = /* @__PURE__ */ new Set();
+        const doUpgrade = (repo, fromVersion) => {
+          const migrations = this._migrations.get(repo);
+          if (!migrations) return;
+          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}`);
+            }
+            const result = migration(db);
+            if (result) {
+              postUpgrade.push(result);
+            }
+            fromVersion = nextVersion;
+          }
+          didUpgrade.add(repo);
+          db.createObjectStore(`${REPO_VERSION_PREFIX}${repo}:${targetVer}`);
+        };
+        for (const key of db.objectStoreNames) {
+          if (!key.startsWith(REPO_VERSION_PREFIX)) continue;
+          const [, repo, version] = key.split(":");
+          const currentVer = Number(version);
+          db.deleteObjectStore(key);
+          doUpgrade(repo, currentVer);
+          didUpgrade.add(repo);
+        }
+        for (const repo of this._migrations.keys()) {
+          if (didUpgrade.has(repo)) continue;
+          doUpgrade(repo, 0);
+        }
+      };
+    });
+  }
+  async _save() {
+    if (this._pendingWritesOses.size === 0) return;
+    const writes = this._pendingWrites;
+    const oses = this._pendingWritesOses;
+    this._pendingWrites = [];
+    this._pendingWritesOses = /* @__PURE__ */ new Set();
+    const tx = this.db.transaction(oses, "readwrite");
+    const osMap = /* @__PURE__ */ new Map();
+    for (const table of oses) {
+      osMap.set(table, tx.objectStore(table));
+    }
+    for (const [table, obj] of writes) {
+      const os = osMap.get(table);
+      if (obj === null) {
+        os.delete(table);
+      } else {
+        os.put(obj);
+      }
+    }
+    await txToPromise(tx);
+  }
+  _destroy() {
+    this.db.close();
+  }
+}
+const TABLE_AUTH_KEYS = "authKeys";
+const TABLE_TEMP_AUTH_KEYS = "tempAuthKeys";
+class IdbAuthKeysRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE_AUTH_KEYS, 1, (db) => {
+      db.createObjectStore(TABLE_AUTH_KEYS, { keyPath: "dc" });
+      db.createObjectStore(TABLE_TEMP_AUTH_KEYS, { keyPath: ["dc", "idx"] });
+    });
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE_AUTH_KEYS, mode).objectStore(TABLE_AUTH_KEYS);
+  }
+  async set(dc, key) {
+    const os = this.os("readwrite");
+    if (key === null) {
+      return reqToPromise(os.delete(dc));
+    }
+    await reqToPromise(os.put({ dc, key }));
+  }
+  async get(dc) {
+    const os = this.os();
+    const it = await reqToPromise(os.get(dc));
+    if (it === void 0) return null;
+    return it.key;
+  }
+  osTemp(mode) {
+    return this._driver.db.transaction(TABLE_TEMP_AUTH_KEYS, mode).objectStore(TABLE_TEMP_AUTH_KEYS);
+  }
+  async setTemp(dc, idx, key, expires) {
+    const os = this.osTemp("readwrite");
+    if (!key) {
+      return reqToPromise(os.delete([dc, idx]));
+    }
+    await reqToPromise(os.put({ dc, idx, key, expiresAt: expires }));
+  }
+  async getTemp(dc, idx, now) {
+    const os = this.osTemp();
+    const row = await reqToPromise(os.get([dc, idx]));
+    if (row === void 0 || row.expiresAt < now) return null;
+    return row.key;
+  }
+  async deleteByDc(dc) {
+    const tx = this._driver.db.transaction([TABLE_AUTH_KEYS, TABLE_TEMP_AUTH_KEYS], "readwrite");
+    tx.objectStore(TABLE_AUTH_KEYS).delete(dc);
+    const tempOs = tx.objectStore(TABLE_TEMP_AUTH_KEYS);
+    const keys = await reqToPromise(tempOs.getAllKeys());
+    for (const key of keys) {
+      if (key[0] === dc) {
+        tempOs.delete(key);
+      }
+    }
+    await txToPromise(tx);
+  }
+  deleteAll() {
+    const tx = this._driver.db.transaction([TABLE_AUTH_KEYS, TABLE_TEMP_AUTH_KEYS], "readwrite");
+    tx.objectStore(TABLE_AUTH_KEYS).clear();
+    tx.objectStore(TABLE_TEMP_AUTH_KEYS).clear();
+    return txToPromise(tx);
+  }
+}
+const KV_TABLE = "kv";
+class IdbKvRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(KV_TABLE, 1, (db) => {
+      db.createObjectStore(KV_TABLE, { keyPath: "key" });
+    });
+  }
+  set(key, value) {
+    this._driver.writeLater(KV_TABLE, { key, value });
+  }
+  os(mode) {
+    return this._driver.db.transaction(KV_TABLE, mode).objectStore(KV_TABLE);
+  }
+  async get(key) {
+    const os = this.os();
+    const res = await reqToPromise(os.get(key));
+    if (res === void 0) return null;
+    return res.value;
+  }
+  async delete(key) {
+    await reqToPromise(this.os("readwrite").delete(key));
+  }
+  async deleteAll() {
+    await reqToPromise(this.os("readwrite").clear());
+  }
+}
+const TABLE$1 = "peers";
+class IdbPeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE$1, 1, (db) => {
+      const os = db.createObjectStore(TABLE$1, { keyPath: "id" });
+      os.createIndex("by_username", "usernames", { unique: true, multiEntry: true });
+      os.createIndex("by_phone", "phone", { unique: true });
+    });
+  }
+  store(peer) {
+    this._driver.writeLater(TABLE$1, peer);
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE$1, mode).objectStore(TABLE$1);
+  }
+  async getById(id, allowMin) {
+    const it = await reqToPromise(this.os().get(id));
+    if (!it) return null;
+    if (it.isMin && !allowMin) return null;
+    return it;
+  }
+  async getByUsername(username) {
+    const it = await reqToPromise(
+      this.os().index("by_username").get(username)
+    );
+    if (!it || it.isMin) return null;
+    return it;
+  }
+  async getByPhone(phone) {
+    const it = await reqToPromise(this.os().index("by_phone").get(phone));
+    if (!it || it.isMin) return null;
+    return it;
+  }
+  deleteAll() {
+    return reqToPromise(this.os("readwrite").clear());
+  }
+}
+const TABLE = "messageRefs";
+class IdbRefMsgRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE, 1, (db) => {
+      const os = db.createObjectStore(TABLE, { keyPath: ["peerId", "chatId", "msgId"] });
+      os.createIndex("by_peer", "peerId");
+      os.createIndex("by_msg", ["chatId", "msgId"]);
+    });
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE, mode).objectStore(TABLE);
+  }
+  async store(peerId, chatId, msgId) {
+    const os = this.os("readwrite");
+    await reqToPromise(os.put({ peerId, chatId, msgId }));
+  }
+  async getByPeer(peerId) {
+    const os = this.os();
+    const index = os.index("by_peer");
+    const it = await reqToPromise(index.get(peerId));
+    if (!it) return null;
+    return [it.chatId, it.msgId];
+  }
+  async delete(chatId, msgIds) {
+    const tx = this._driver.db.transaction(TABLE, "readwrite");
+    const os = tx.objectStore(TABLE);
+    const index = os.index("by_msg");
+    for (const msgId of msgIds) {
+      const keys = await reqToPromise(index.getAllKeys([chatId, msgId]));
+      for (const key of keys) {
+        os.delete(key);
+      }
+    }
+    return txToPromise(tx);
+  }
+  async deleteByPeer(peerId) {
+    const tx = this._driver.db.transaction(TABLE, "readwrite");
+    const os = tx.objectStore(TABLE);
+    const index = os.index("by_peer");
+    const req = index.openCursor(peerId);
+    let cursor = await reqToPromise(req);
+    while (cursor) {
+      cursor.delete();
+      cursor.continue();
+      cursor = await reqToPromise(req);
+    }
+    return txToPromise(tx);
+  }
+  async deleteAll() {
+    await reqToPromise(this.os("readwrite").clear());
+  }
+}
+class IdbStorage {
+  constructor(dbName) {
+    this.dbName = dbName;
+    this.driver = new IdbStorageDriver(this.dbName);
+    this.kv = new IdbKvRepository(this.driver);
+    this.authKeys = new IdbAuthKeysRepository(this.driver);
+    this.peers = new IdbPeersRepository(this.driver);
+    this.refMessages = new IdbRefMsgRepository(this.driver);
+  }
+  driver;
+  kv;
+  authKeys;
+  peers;
+  refMessages;
+}
+const lookup = [];
+const revLookup = [];
+const code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (let i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+  revLookup[code.charCodeAt(i)] = i;
+}
+function getLens(b64) {
+  const len = b64.length;
+  if (len % 4 > 0) {
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  }
+  let validLen = b64.indexOf("=");
+  if (validLen === -1) validLen = len;
+  const placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+  return [validLen, placeHoldersLen];
+}
+function _byteLength(b64, validLen, placeHoldersLen) {
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64, arr) {
+  let tmp;
+  const lens = getLens(b64);
+  const validLen = lens[0];
+  const placeHoldersLen = lens[1];
+  let curByte = 0;
+  const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+  let i;
+  for (i = 0; i < len; i += 4) {
+    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+    arr[curByte++] = tmp >> 16 & 255;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 2) {
+    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 1) {
+    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  return arr;
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  let tmp;
+  const output = [];
+  for (let i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  let tmp;
+  const len = uint8.length;
+  const extraBytes = len % 3;
+  const parts = [];
+  const maxChunkLength = 16383;
+  for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(`${lookup[tmp >> 2] + lookup[tmp << 4 & 63]}==`);
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(`${lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63]}=`);
+  }
+  return parts.join("");
+}
+function base64Encode(buf, url = false) {
+  const str = fromByteArray(buf);
+  if (url) return str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  return str;
+}
+function base64Decode(string, url = false) {
+  if (url) {
+    string = string.replace(/-/g, "+").replace(/_/g, "/");
+    while (string.length % 4) string += "=";
+  }
+  const buf = new Uint8Array(_byteLength(string, ...getLens(string)));
+  toByteArray(string, buf);
+  return buf;
+}
+const hexSliceLookupTable = function() {
+  const alphabet = "0123456789abcdef";
+  const table = Array.from({ length: 256 });
+  for (let i = 0; i < 16; ++i) {
+    const i16 = i * 16;
+    for (let j = 0; j < 16; ++j) {
+      table[i16 + j] = alphabet[i] + alphabet[j];
+    }
+  }
+  return table;
+}();
+const hexCharValueTable = {
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  8: 8,
+  9: 9,
+  a: 10,
+  b: 11,
+  c: 12,
+  d: 13,
+  e: 14,
+  f: 15,
+  A: 10,
+  B: 11,
+  C: 12,
+  D: 13,
+  E: 14,
+  F: 15
+};
+function hexEncode(buf) {
+  let out = "";
+  for (let i = 0; i < buf.byteLength; ++i) {
+    out += hexSliceLookupTable[buf[i]];
+  }
+  return out;
+}
+function hexDecodeInner(buf, string) {
+  const strLen = string.length;
+  const length = Math.min(buf.length, strLen / 2);
+  let i;
+  for (i = 0; i < length; ++i) {
+    const a = hexCharValueTable[string[i * 2]];
+    const b = hexCharValueTable[string[i * 2 + 1]];
+    if (a === void 0 || b === void 0) {
+      return;
+    }
+    buf[i] = a << 4 | b;
+  }
+}
+function hexDecode(string) {
+  const buf = new Uint8Array(Math.ceil(string.length / 2));
+  hexDecodeInner(buf, string);
+  return buf;
+}
+const BASE_FORMAT = "%s [%c%s%c] [%c%s%c] ";
+const LEVEL_NAMES = [
+  "",
+  // OFF
+  "ERR",
+  "WRN",
+  "INF",
+  "DBG",
+  "VRB"
+];
+const COLORS = [
+  "",
+  // OFF
+  "color: #7a5f9d",
+  "color: #8d7041",
+  "color: #396c9e",
+  "color: #437761",
+  "color: #7a5f9d"
+];
+const TAG_COLORS = [
+  "color: #437761",
+  "color: #537a36",
+  "color: #8d7041",
+  "color: #396c9e",
+  "color: #7a5f9d",
+  "color: #7a5f9d"
+];
+const defaultLoggingHandler = (color, level, tag, fmt, args) => {
+  console.log(
+    BASE_FORMAT + fmt,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    COLORS[level],
+    LEVEL_NAMES[level],
+    "",
+    TAG_COLORS[color],
+    tag,
+    "",
+    ...args
+  );
+};
+const sharedEncoder = new TextEncoder();
+const sharedDecoder = new TextDecoder("utf8");
+function utf8ByteLength(str) {
+  let s = str.length;
+  for (let i = str.length - 1; i >= 0; i--) {
+    const code2 = str.charCodeAt(i);
+    if (code2 > 127 && code2 <= 2047) s++;
+    else if (code2 > 2047 && code2 <= 65535) s += 2;
+    if (code2 >= 56320 && code2 <= 57343) i--;
+  }
+  return s;
+}
+function utf8Decode(buf) {
+  return sharedDecoder.decode(buf);
+}
+function utf8Encode(str) {
+  return sharedEncoder.encode(str);
+}
+const callbacks = /* @__PURE__ */ new Set();
+let registered = false;
+function beforeExit(fn) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  if (!registered) {
+    registered = true;
+    window.addEventListener("beforeunload", () => {
+      for (const callback of callbacks) {
+        callback();
+      }
+    });
+  }
+  callbacks.add(fn);
+  return () => {
+    callbacks.delete(fn);
+  };
+}
+class WebPlatform {
+  getDeviceModel() {
+    if (typeof navigator === "undefined") return "Browser";
+    return navigator.userAgent;
+  }
+  getDefaultLogLevel() {
+    if (typeof localStorage !== "undefined") {
+      const localLogLevel = Number.parseInt(localStorage.MTCUTE_LOG_LEVEL);
+      if (!Number.isNaN(localLogLevel)) {
+        return localLogLevel;
+      }
+    }
+    return null;
+  }
+  onNetworkChanged(fn) {
+    if (!("onLine" in navigator)) return () => {
+    };
+    const onlineHandler = () => fn(navigator.onLine);
+    window.addEventListener("online", onlineHandler);
+    window.addEventListener("offline", onlineHandler);
+    return () => {
+      window.removeEventListener("online", onlineHandler);
+      window.removeEventListener("offline", onlineHandler);
+    };
+  }
+  isOnline() {
+    return navigator.onLine;
+  }
+}
+WebPlatform.prototype.log = defaultLoggingHandler;
+WebPlatform.prototype.beforeExit = beforeExit;
+WebPlatform.prototype.utf8ByteLength = utf8ByteLength;
+WebPlatform.prototype.utf8Encode = utf8Encode;
+WebPlatform.prototype.utf8Decode = utf8Decode;
+WebPlatform.prototype.hexEncode = hexEncode;
+WebPlatform.prototype.hexDecode = hexDecode;
+WebPlatform.prototype.base64Encode = base64Encode;
+WebPlatform.prototype.base64Decode = base64Decode;
+const subdomainsMap = {
+  1: "pluto",
+  2: "venus",
+  3: "aurora",
+  4: "vesta",
+  5: "flora"
+};
+class BaseWebSocketTransport extends EventEmitter {
+  _currentDc = null;
+  _state = core.TransportState.Idle;
+  _socket = null;
+  _crypto;
+  log;
+  packetCodecInitialized = false;
+  _baseDomain;
+  _subdomains;
+  _WebSocket;
+  constructor({
+    ws = WebSocket,
+    baseDomain = "web.telegram.org",
+    subdomains = subdomainsMap
+  } = {}) {
+    super();
+    if (!ws) {
+      throw new core.MtUnsupportedError(
+        "To use WebSocket transport with NodeJS, install `ws` package and pass it to constructor"
+      );
+    }
+    if ("default" in ws) {
+      ws = ws.default;
+    }
+    this._baseDomain = baseDomain;
+    this._subdomains = subdomains;
+    this._WebSocket = ws;
+  }
+  _updateLogPrefix() {
+    if (this._currentDc) {
+      this.log.prefix = `[WS:${this._subdomains[this._currentDc.id]}.${this._baseDomain}] `;
+    } else {
+      this.log.prefix = "[WS:disconnected] ";
+    }
+  }
+  setup(crypto, log) {
+    this._crypto = crypto;
+    this.log = log.create("ws");
+  }
+  state() {
+    return this._state;
+  }
+  currentDc() {
+    return this._currentDc;
+  }
+  connect(dc, testMode) {
+    if (this._state !== core.TransportState.Idle) {
+      throw new core.MtcuteError("Transport is not IDLE");
+    }
+    if (!this.packetCodecInitialized) {
+      this._packetCodec.setup?.(this._crypto, this.log);
+      this._packetCodec.on("error", (err) => this.emit("error", err));
+      this._packetCodec.on("packet", (buf) => this.emit("message", buf));
+      this.packetCodecInitialized = true;
+    }
+    this._state = core.TransportState.Connecting;
+    this._currentDc = dc;
+    this._socket = new this._WebSocket(
+      `wss://${this._subdomains[dc.id]}.${this._baseDomain}/apiws${testMode ? "_test" : ""}`,
+      "binary"
+    );
+    this._updateLogPrefix();
+    this.log.debug("connecting to %s (%j)", this._socket.url, dc);
+    this._socket.binaryType = "arraybuffer";
+    this._socket.addEventListener("message", (evt) => this._packetCodec.feed(new Uint8Array(evt.data)));
+    this._socket.addEventListener("open", this.handleConnect.bind(this));
+    this._socket.addEventListener("error", this.handleError.bind(this));
+    this._socket.addEventListener("close", this.handleClosed.bind(this));
+  }
+  _closeWaiters = [];
+  async close() {
+    if (this._state === core.TransportState.Idle) return;
+    const promise = utils_js.createControllablePromise();
+    this._closeWaiters.push(promise);
+    this._socket.close();
+    return promise;
+  }
+  handleClosed() {
+    this.log.info("connection closed");
+    this._state = core.TransportState.Idle;
+    this._socket = null;
+    this._currentDc = null;
+    this._packetCodec.reset();
+    this.emit("close");
+    for (const waiter of this._closeWaiters) {
+      waiter.resolve();
+    }
+    this._closeWaiters = [];
+  }
+  handleError(event) {
+    const error = "error" in event ? event.error : new Error("unknown WebSocket error");
+    this.log.error("error: %s", error.stack);
+    this.emit("error", error);
+  }
+  handleConnect() {
+    this.log.info("connected");
+    Promise.resolve(this._packetCodec.tag()).then((initialMessage) => {
+      this._socket.send(initialMessage);
+      this._state = core.TransportState.Ready;
+      this.emit("ready");
+    }).catch((err) => this.emit("error", err));
+  }
+  async send(bytes) {
+    if (this._state !== core.TransportState.Ready) {
+      throw new core.MtcuteError("Transport is not READY");
+    }
+    const framed = await this._packetCodec.encode(bytes);
+    this._socket.send(framed);
+  }
+}
+class WebSocketTransport extends BaseWebSocketTransport {
+  _packetCodec = new core.ObfuscatedPacketCodec(new core.IntermediatePacketCodec());
+}
+class BaseTelegramClient extends client_js.BaseTelegramClient {
+  constructor(opts) {
+    if (!opts.platformless) platform_js.setPlatform(new WebPlatform());
+    super({
+      crypto: new WebCryptoProvider(),
+      transport: () => new WebSocketTransport(),
+      ...opts,
+      storage: typeof opts.storage === "string" ? new IdbStorage(opts.storage) : opts.storage ?? new IdbStorage("client.session")
+    });
+  }
+}
+class TelegramClient extends client_js.TelegramClient {
+  constructor(opts) {
+    if ("client" in opts) {
+      super(opts);
+      return;
+    }
+    super({
+      client: new BaseTelegramClient(opts),
+      disableUpdates: opts.disableUpdates,
+      skipConversationUpdates: opts.skipConversationUpdates,
+      updates: opts.updates
+    });
+  }
+}
+let _registered = false;
+class TelegramWorker extends worker_js.TelegramWorker {
+  registerWorker(handler) {
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
+      const connections = [];
+      const broadcast = (message) => {
+        for (const port of connections) {
+          port.postMessage(message);
+        }
+      };
+      self.onconnect = (event) => {
+        const port = event.ports[0];
+        connections.push(port);
+        const respond = port.postMessage.bind(port);
+        const onClose = () => {
+          port.close();
+          const idx = connections.indexOf(port);
+          if (idx >= 0) {
+            connections.splice(connections.indexOf(port), 1);
+          }
+        };
+        const onTimeout = () => {
+          console.warn("some connection timed out!");
+          respond({ __type__: "timeout" });
+          onClose();
+        };
+        let timeout = setTimeout(onTimeout, 6e4);
+        port.addEventListener("message", (message) => {
+          if (message.data.__type__ === "close") {
+            onClose();
+            return;
+          }
+          if (message.data.__type__ === "ping") {
+            clearTimeout(timeout);
+            timeout = setTimeout(onTimeout, 6e4);
+            return;
+          }
+          handler(message.data, respond);
+        });
+        port.start();
+      };
+      return broadcast;
+    }
+    if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
+      const respond = self.postMessage.bind(self);
+      self.addEventListener("message", (message) => handler(message.data, respond));
+      return respond;
+    }
+    throw new Error("TelegramWorker must be created from a worker");
+  }
+}
+const platform = new WebPlatform();
+class TelegramWorkerPort extends worker_js.TelegramWorkerPort {
+  constructor(options) {
+    platform_js.setPlatform(platform);
+    super(options);
+    this.options = options;
+  }
+  connectToWorker(worker, handler) {
+    if (worker instanceof Worker) {
+      const send = worker.postMessage.bind(worker);
+      const messageHandler = (ev) => {
+        handler(ev.data);
+      };
+      worker.addEventListener("message", messageHandler);
+      return [
+        send,
+        () => {
+          worker.removeEventListener("message", messageHandler);
+        }
+      ];
+    }
+    if (worker instanceof SharedWorker) {
+      const send = worker.port.postMessage.bind(worker.port);
+      const pingInterval = setInterval(() => {
+        worker.port.postMessage({ __type__: "ping" });
+      }, 1e4);
+      const messageHandler = (ev) => {
+        if (ev.data.__type__ === "timeout") {
+          location.reload();
+          return;
+        }
+        handler(ev.data);
+      };
+      worker.port.addEventListener("message", messageHandler);
+      worker.port.start();
+      let cancelBeforeExit;
+      const close = () => {
+        clearInterval(pingInterval);
+        worker.port.postMessage({ __type__: "close" });
+        worker.port.removeEventListener("message", messageHandler);
+        worker.port.close();
+        cancelBeforeExit();
+      };
+      cancelBeforeExit = platform.beforeExit(close);
+      return [send, close];
+    }
+    throw new Error("Only workers and shared workers are supported");
+  }
+}
+exports.BaseTelegramClient = BaseTelegramClient;
+exports.BaseWebSocketTransport = BaseWebSocketTransport;
+exports.IdbStorage = IdbStorage;
+exports.IdbStorageDriver = IdbStorageDriver;
+exports.TelegramClient = TelegramClient;
+exports.TelegramWorker = TelegramWorker;
+exports.TelegramWorkerPort = TelegramWorkerPort;
+exports.WebCryptoProvider = WebCryptoProvider;
+exports.WebPlatform = WebPlatform;
+exports.WebSocketTransport = WebSocketTransport;
+Object.keys(core).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => core[k]
+  });
+});