@mtcute/core 0.16.7 → 0.16.9

package/chunks/es/CO4G3ySK.js

@@ -0,0 +1,985 @@
+import { TlBinaryWriter, TlBinaryReader, TlSerializationCounter } from "@mtcute/tl-runtime";
+import { assertTypeIs } from "./BN3qj7tU.js";
+import { extractUsernames, dataViewFromBuffer, bufferToReversed, concatBuffers, clearTimeoutWrap, setImmediateWrapExported, setTimeoutWrap, clearImmediateWrapExported, LongSet } from "./DY1E3mHM.js";
+import { MtArgumentError, getPlatform } from "./DBMBgE7t.js";
+import { __publicKeyIndex } from "@mtcute/tl/binary/rsa-keys.js";
+class BaseService {
+  _driver;
+  _readerMap;
+  _writerMap;
+  _log;
+  constructor(opts) {
+    this._driver = opts.driver;
+    this._readerMap = opts.readerMap;
+    this._writerMap = opts.writerMap;
+    this._log = opts.log;
+  }
+  _serializeTl(obj) {
+    return TlBinaryWriter.serializeObject(this._writerMap, obj);
+  }
+  _deserializeTl(data) {
+    try {
+      return TlBinaryReader.deserializeObject(this._readerMap, data);
+    } catch {
+      return null;
+    }
+  }
+}
+const KV_CURRENT_USER = "current_user";
+function serialize(info) {
+  if (!info) return new Uint8Array(0);
+  const hasUsernames = info.usernames.length > 0;
+  let usernamesOverhead = hasUsernames ? 4 : 0;
+  for (const username of info.usernames) {
+    usernamesOverhead += TlSerializationCounter.countBytesOverhead(username.length) + username.length;
+  }
+  const writer = TlBinaryWriter.manual(16 + usernamesOverhead);
+  writer.int(1);
+  let flags = 0;
+  if (info.isBot) flags |= 1;
+  if (hasUsernames) flags |= 2;
+  if (info.isPremium) flags |= 4;
+  writer.int(flags);
+  writer.int53(info.userId);
+  if (hasUsernames) {
+    writer.int(info.usernames.length);
+    for (const username of info.usernames) {
+      writer.string(username);
+    }
+  }
+  return writer.result();
+}
+function parse(data) {
+  if (data.length === 0) return null;
+  const reader = TlBinaryReader.manual(data);
+  if (reader.int() !== 1) return null;
+  const flags = reader.int();
+  const userId = reader.int53();
+  let usernames = [];
+  if (flags & 2) {
+    const len = reader.int();
+    usernames = new Array(len);
+    for (let i = 0; i < len; i++) {
+      usernames[i] = reader.string();
+    }
+  }
+  return {
+    userId,
+    isBot: (flags & 1) !== 0,
+    isPremium: (flags & 4) !== 0,
+    usernames
+  };
+}
+class CurrentUserService extends BaseService {
+  constructor(_kv, opts) {
+    super(opts);
+    this._kv = _kv;
+  }
+  _cached;
+  async store(info) {
+    if (info && this._cached) {
+      if (this._cached.userId === info.userId) {
+        return;
+      }
+      this._cached.userId = info.userId;
+      this._cached.isBot = info.isBot;
+    } else {
+      this._cached = info;
+    }
+    await this._kv.set(KV_CURRENT_USER, serialize(info));
+    await this._driver.save?.();
+  }
+  async storeFrom(user) {
+    assertTypeIs("storeFrom", user, "user");
+    const obj = {
+      userId: user.id,
+      isBot: user.bot,
+      isPremium: user.premium,
+      usernames: extractUsernames(user)
+    };
+    await this.store(obj);
+    return obj;
+  }
+  async fetch() {
+    if (this._cached) return this._cached;
+    const data = await this._kv.get(KV_CURRENT_USER);
+    if (!data) return null;
+    const info = parse(data);
+    this._cached = info;
+    return info;
+  }
+  getCached(safe = false) {
+    if (this._cached === void 0) {
+      if (safe) return null;
+      throw new MtArgumentError("User info is not cached yet");
+    }
+    return this._cached;
+  }
+  async update(params) {
+    const info = await this.fetch();
+    if (!info) return;
+    const { username, usernames, isPremium } = params;
+    if (isPremium !== void 0) info.isPremium = isPremium;
+    if (username !== void 0) {
+      info.usernames[0] = username;
+    } else if (usernames !== void 0) {
+      info.usernames = usernames;
+    }
+    return this.store(info);
+  }
+}
+const KV_PTS = "updates_pts";
+const KV_QTS = "updates_qts";
+const KV_DATE = "updates_date";
+const KV_SEQ = "updates_seq";
+const KV_CHANNEL_PREFIX = "updates_channel:";
+class UpdatesStateService extends BaseService {
+  constructor(_kv, opts) {
+    super(opts);
+    this._kv = _kv;
+  }
+  async _getInt(key) {
+    const val = await this._kv.get(key);
+    if (!val) return null;
+    return dataViewFromBuffer(val).getInt32(0, true);
+  }
+  async _setInt(key, val) {
+    const buf = new Uint8Array(4);
+    dataViewFromBuffer(buf).setInt32(0, val, true);
+    await this._kv.set(key, buf);
+  }
+  async getState() {
+    const [pts, qts, date, seq] = await Promise.all([
+      this._getInt(KV_PTS),
+      this._getInt(KV_QTS),
+      this._getInt(KV_DATE),
+      this._getInt(KV_SEQ)
+    ]);
+    if (pts === null || qts === null || date === null || seq === null) {
+      return null;
+    }
+    return [pts, qts, date, seq];
+  }
+  async setPts(pts) {
+    await this._setInt(KV_PTS, pts);
+  }
+  async setQts(qts) {
+    await this._setInt(KV_QTS, qts);
+  }
+  async setDate(date) {
+    await this._setInt(KV_DATE, date);
+  }
+  async setSeq(seq) {
+    await this._setInt(KV_SEQ, seq);
+  }
+  async getChannelPts(channelId) {
+    const val = await this._kv.get(KV_CHANNEL_PREFIX + channelId);
+    if (!val) return null;
+    return dataViewFromBuffer(val).getUint32(0, true);
+  }
+  async setChannelPts(channelId, pts) {
+    const buf = new Uint8Array(4);
+    dataViewFromBuffer(buf).setUint32(0, pts, true);
+    await this._kv.set(KV_CHANNEL_PREFIX + channelId, buf);
+  }
+  async setManyChannelPts(cpts) {
+    const promises = [];
+    for (const [channelId, pts] of cpts.entries()) {
+      promises.push(this.setChannelPts(channelId, pts));
+    }
+    await Promise.all(promises);
+  }
+}
+function serializeBasicDcOption(dc) {
+  const writer = TlBinaryWriter.manual(64);
+  const flags = (dc.ipv6 ? 1 : 0) | (dc.mediaOnly ? 2 : 0);
+  writer.raw(
+    new Uint8Array([
+      1,
+      // version
+      dc.id,
+      flags
+    ])
+  );
+  writer.string(dc.ipAddress);
+  writer.int(dc.port);
+  return writer.result();
+}
+function parseBasicDcOption(data) {
+  const reader = TlBinaryReader.manual(data);
+  const [version, id, flags] = reader.raw(3);
+  if (version !== 1) return null;
+  const ipAddress = reader.string();
+  const port = reader.int();
+  return {
+    id,
+    ipAddress,
+    port,
+    ipv6: (flags & 1) !== 0,
+    mediaOnly: (flags & 2) !== 0
+  };
+}
+const defaultProductionDc = {
+  main: {
+    ipAddress: "149.154.167.50",
+    port: 443,
+    id: 2
+  },
+  media: {
+    ipAddress: "149.154.167.222",
+    port: 443,
+    id: 2,
+    mediaOnly: true
+  }
+};
+const defaultProductionIpv6Dc = {
+  main: {
+    ipAddress: "2001:067c:04e8:f002:0000:0000:0000:000a",
+    ipv6: true,
+    port: 443,
+    id: 2
+  },
+  media: {
+    ipAddress: "2001:067c:04e8:f002:0000:0000:0000:000b",
+    ipv6: true,
+    port: 443,
+    id: 2,
+    mediaOnly: true
+  }
+};
+const defaultTestDc = {
+  main: {
+    ipAddress: "149.154.167.40",
+    port: 443,
+    id: 2
+  },
+  media: {
+    ipAddress: "149.154.167.40",
+    port: 443,
+    id: 2,
+    mediaOnly: true
+  }
+};
+const defaultTestIpv6Dc = {
+  main: {
+    ipAddress: "2001:67c:4e8:f002::e",
+    port: 443,
+    ipv6: true,
+    id: 2
+  },
+  media: {
+    ipAddress: "2001:67c:4e8:f002::e",
+    port: 443,
+    ipv6: true,
+    id: 2,
+    mediaOnly: true
+  }
+};
+const KV_MAIN = "dc_main";
+const KV_MEDIA = "dc_media";
+class DefaultDcsService extends BaseService {
+  constructor(_kv, opts) {
+    super(opts);
+    this._kv = _kv;
+  }
+  _cached;
+  async store(dcs) {
+    if (this._cached) {
+      if (this._cached.main === dcs.main && this._cached.media === dcs.media) {
+        return;
+      }
+    }
+    this._cached = dcs;
+    const { main, media } = dcs;
+    const mainData = serializeBasicDcOption(main);
+    await this._kv.set(KV_MAIN, mainData);
+    if (media !== main) {
+      const mediaData = serializeBasicDcOption(media);
+      await this._kv.set(KV_MEDIA, mediaData);
+    } else {
+      await this._kv.delete(KV_MEDIA);
+    }
+  }
+  async fetch() {
+    if (this._cached) return this._cached;
+    const [mainData, mediaData] = await Promise.all([
+      this._kv.get(KV_MAIN),
+      this._kv.get(KV_MEDIA)
+    ]);
+    if (!mainData) return null;
+    const main = parseBasicDcOption(mainData);
+    if (!main) return null;
+    const dcs = { main, media: main };
+    if (mediaData) {
+      const media = parseBasicDcOption(mediaData);
+      if (media) {
+        dcs.media = media;
+      }
+    }
+    this._cached = dcs;
+    return dcs;
+  }
+}
+function bigIntBitLength(n) {
+  const i = (n.toString(16).length - 1) * 4;
+  return i + 32 - Math.clz32(Number(n >> BigInt(i)));
+}
+function bigIntToBuffer(value, length = 0, le = false) {
+  const bits = bigIntBitLength(value);
+  const bytes = Math.ceil(bits / 8);
+  if (length !== 0 && bytes > length) {
+    throw new Error("Value out of bounds");
+  }
+  if (length === 0) length = bytes;
+  const buf = new ArrayBuffer(length);
+  const u8 = new Uint8Array(buf);
+  const unaligned = length % 8;
+  const dv = new DataView(buf, 0, length - unaligned);
+  for (let i = 0; i < dv.byteLength; i += 8) {
+    dv.setBigUint64(i, value & 0xFFFFFFFFFFFFFFFFn, true);
+    value >>= 64n;
+  }
+  if (unaligned > 0) {
+    for (let i = length - unaligned; i < length; i++) {
+      u8[i] = Number(value & 0xFFn);
+      value >>= 8n;
+    }
+  }
+  if (!le) u8.reverse();
+  return u8;
+}
+function bufferToBigInt(buffer, le = false) {
+  if (le) buffer = bufferToReversed(buffer);
+  const unaligned = buffer.length % 8;
+  const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength - unaligned);
+  let res = 0n;
+  for (let i = 0; i < dv.byteLength; i += 8) {
+    res = res << 64n | BigInt(dv.getBigUint64(i, false));
+  }
+  if (unaligned > 0) {
+    for (let i = buffer.length - unaligned; i < buffer.length; i++) {
+      res = res << 8n | BigInt(buffer[i]);
+    }
+  }
+  return res;
+}
+function randomBigInt(crypto, size) {
+  return bufferToBigInt(crypto.randomBytes(size));
+}
+function randomBigIntBits(crypto, bits) {
+  let num = randomBigInt(crypto, Math.ceil(bits / 8));
+  const bitLength = bigIntBitLength(num);
+  if (bitLength > bits) {
+    const toTrim = bitLength - bits;
+    num >>= BigInt(toTrim);
+  }
+  return num;
+}
+function randomBigIntInRange(crypto, max, min = 1n) {
+  const interval = max - min;
+  if (interval < 0n) throw new Error("expected min < max");
+  const byteSize = Math.ceil(bigIntBitLength(interval) / 8);
+  let result = randomBigInt(crypto, byteSize);
+  while (result > interval) result -= interval;
+  return min + result;
+}
+function twoMultiplicity(n) {
+  if (n === 0n) return 0n;
+  let m = 0n;
+  let pow = 1n;
+  while (true) {
+    if ((n & pow) !== 0n) return m;
+    m += 1n;
+    pow <<= 1n;
+  }
+}
+function bigIntMin(a, b) {
+  return a < b ? a : b;
+}
+function bigIntAbs(a) {
+  return a < 0n ? -a : a;
+}
+function bigIntGcd(a, b) {
+  while (b !== 0n) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+function bigIntModPow(base, exp, mod) {
+  base %= mod;
+  let result = 1n;
+  while (exp > 0n) {
+    if (exp % 2n === 1n) {
+      result = result * base % mod;
+    }
+    exp >>= 1n;
+    base = base ** 2n % mod;
+  }
+  return result;
+}
+function eGcd(a, b) {
+  let x = 0n;
+  let y = 1n;
+  let u = 1n;
+  let v = 0n;
+  while (a !== 0n) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    const n = y - v * q;
+    b = a;
+    a = r;
+    x = u;
+    y = v;
+    u = m;
+    v = n;
+  }
+  return [b, x, y];
+}
+function toZn(a, n) {
+  if (typeof a === "number") a = BigInt(a);
+  if (typeof n === "number") n = BigInt(n);
+  if (n <= 0n) {
+    throw new RangeError("n must be > 0");
+  }
+  const aZn = a % n;
+  return aZn < 0n ? aZn + n : aZn;
+}
+function bigIntModInv(a, n) {
+  const [g, x] = eGcd(toZn(a, n), n);
+  if (g !== 1n) {
+    throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`);
+  } else {
+    return toZn(x, n);
+  }
+}
+function composeMiddlewares(middlewares, final) {
+  middlewares = middlewares.slice();
+  middlewares.push(final);
+  function dispatch(i, ctx) {
+    const fn = middlewares[i];
+    if (!fn) return final(ctx);
+    return fn(ctx, boundDispatches[i + 1]);
+  }
+  const boundDispatches = [];
+  for (let i = 0; i < middlewares.length; i++) {
+    boundDispatches.push(dispatch.bind(null, i));
+  }
+  return function(context) {
+    return boundDispatches[0](context);
+  };
+}
+function parsePemContents(pem) {
+  return getPlatform().base64Decode(pem.replace(/^-----(?:BEGIN|END)(?: RSA)? PUBLIC KEY-----$|\n/gm, ""));
+}
+const ELOOPN = 102;
+const ELOOP = `iterated over ${ELOOPN} elements (probably a malformed file)`;
+const EDEEPN = 60;
+const EDEEP = `element nested over ${EDEEPN} layers deep (probably a malformed file)`;
+const CTYPES = {
+  48: true,
+  49: true,
+  160: true,
+  161: true
+};
+const VTYPES = {
+  1: true,
+  2: true,
+  5: true,
+  6: true,
+  12: true,
+  130: true
+};
+function parseAsn1(data) {
+  function parseAsn1Inner(buf, depth, eager = false) {
+    if (depth.length >= EDEEPN) {
+      throw new Error(EDEEP);
+    }
+    let index = 2;
+    const asn12 = { type: buf[0], lengthSize: 0, length: buf[1] };
+    let child;
+    let iters = 0;
+    let adjust = 0;
+    let adjustedLen = 0;
+    if (128 & asn12.length) {
+      asn12.lengthSize = 127 & asn12.length;
+      asn12.length = Number.parseInt(getPlatform().hexEncode(buf.subarray(index, index + asn12.lengthSize)), 16);
+      index += asn12.lengthSize;
+    }
+    if (buf[index] === 0 && (asn12.type === 2 || asn12.type === 3)) {
+      if (asn12.length > 1) {
+        index += 1;
+        adjust = -1;
+      }
+    }
+    adjustedLen = asn12.length + adjust;
+    function parseChildren(eager2 = false) {
+      asn12.children = [];
+      while (iters < ELOOPN && index < 2 + asn12.length + asn12.lengthSize) {
+        iters += 1;
+        depth.length += 1;
+        child = parseAsn1Inner(buf.subarray(index, index + adjustedLen), depth, eager2);
+        depth.length -= 1;
+        index += 2 + child.lengthSize + child.length;
+        if (index > 2 + asn12.lengthSize + asn12.length) {
+          throw new Error(
+            `Parse error: child value length (${child.length}) is greater than remaining parent length (${asn12.length - index} = ${asn12.length} - ${index})`
+          );
+        }
+        asn12.children.push(child);
+      }
+      if (index !== 2 + asn12.lengthSize + asn12.length) {
+        throw new Error("Unexpected EOF");
+      }
+      if (iters >= ELOOPN) {
+        throw new Error(ELOOP);
+      }
+      delete asn12.value;
+      return asn12;
+    }
+    if (CTYPES[asn12.type]) {
+      return parseChildren(eager);
+    }
+    asn12.value = buf.subarray(index, index + adjustedLen);
+    if (VTYPES[asn12.type]) {
+      return asn12;
+    }
+    try {
+      return parseChildren(true);
+    } catch {
+      if (asn12.children) asn12.children.length = 0;
+      return asn12;
+    }
+  }
+  const asn1 = parseAsn1Inner(data, []);
+  const len = data.length;
+  if (len !== 2 + asn1.lengthSize + asn1.length) {
+    throw new Error("Length of buffer does not match length of ASN.1 sequence.");
+  }
+  return asn1;
+}
+function parsePublicKey(crypto, key, old = false) {
+  const asn1 = parseAsn1(parsePemContents(key));
+  const modulus = asn1.children?.[0].value;
+  const exponent = asn1.children?.[1].value;
+  if (!modulus || !exponent) throw new Error("Invalid public key");
+  const writer = TlBinaryWriter.manual(512);
+  writer.bytes(modulus);
+  writer.bytes(exponent);
+  const platform = getPlatform();
+  const data = writer.result();
+  const sha = crypto.sha1(data);
+  const fp = platform.hexEncode(sha.slice(-8).reverse());
+  return {
+    modulus: platform.hexEncode(modulus),
+    exponent: platform.hexEncode(exponent),
+    fingerprint: fp,
+    old
+  };
+}
+function addPublicKey(crypto, key, old = false) {
+  const parsed = parsePublicKey(crypto, key, old);
+  __publicKeyIndex[parsed.fingerprint] = parsed;
+}
+function findKeyByFingerprints(fingerprints, allowOld = false) {
+  for (let fp of fingerprints) {
+    if (typeof fp !== "string") {
+      fp = fp.toUnsigned().toString(16);
+    }
+    if (fp in __publicKeyIndex) {
+      if (__publicKeyIndex[fp].old && !allowOld) continue;
+      return __publicKeyIndex[fp];
+    }
+  }
+  if (!allowOld) return findKeyByFingerprints(fingerprints, true);
+  return null;
+}
+function millerRabin(crypto, n, rounds = 20) {
+  if (n < 4n) return n > 1n;
+  if (n % 2n === 0n || n < 0n) return false;
+  const nBits = bigIntBitLength(n);
+  const nSub = n - 1n;
+  const r = twoMultiplicity(nSub);
+  const d = nSub >> r;
+  for (let i = 0; i < rounds; i++) {
+    let base;
+    do {
+      base = randomBigIntBits(crypto, nBits);
+    } while (base <= 1n || base >= nSub);
+    let x = bigIntModPow(base, d, n);
+    if (x === 1n || x === nSub) continue;
+    let i2 = 0n;
+    let y;
+    while (i2 < r) {
+      y = bigIntModPow(x, 2n, n);
+      if (x === 1n) return false;
+      if (x === nSub) break;
+      i2 += 1n;
+      x = y;
+    }
+    if (i2 === r) return false;
+  }
+  return true;
+}
+function generateKeyAndIvFromNonce(crypto, serverNonce, newNonce) {
+  const hash1 = crypto.sha1(concatBuffers([newNonce, serverNonce]));
+  const hash2 = crypto.sha1(concatBuffers([serverNonce, newNonce]));
+  const hash3 = crypto.sha1(concatBuffers([newNonce, newNonce]));
+  const key = concatBuffers([hash1, hash2.subarray(0, 12)]);
+  const iv = concatBuffers([hash2.subarray(12, 20), hash3, newNonce.subarray(0, 4)]);
+  return [key, iv];
+}
+function createAesIgeForMessage(crypto, authKey, messageKey, client) {
+  const x = client ? 0 : 8;
+  const sha256a = crypto.sha256(concatBuffers([messageKey, authKey.subarray(x, 36 + x)]));
+  const sha256b = crypto.sha256(concatBuffers([authKey.subarray(40 + x, 76 + x), messageKey]));
+  const key = concatBuffers([sha256a.subarray(0, 8), sha256b.subarray(8, 24), sha256a.subarray(24, 32)]);
+  const iv = concatBuffers([sha256b.subarray(0, 8), sha256a.subarray(8, 24), sha256b.subarray(24, 32)]);
+  return crypto.createAesIge(key, iv);
+}
+function createAesIgeForMessageOld(crypto, authKey, messageKey, client) {
+  const x = client ? 0 : 8;
+  const sha1a = crypto.sha1(concatBuffers([messageKey, authKey.subarray(x, 32 + x)]));
+  const sha1b = crypto.sha1(
+    concatBuffers([authKey.subarray(32 + x, 48 + x), messageKey, authKey.subarray(48 + x, 64 + x)])
+  );
+  const sha1c = crypto.sha1(concatBuffers([authKey.subarray(64 + x, 96 + x), messageKey]));
+  const sha1d = crypto.sha1(concatBuffers([messageKey, authKey.subarray(96 + x, 128 + x)]));
+  const key = concatBuffers([sha1a.subarray(0, 8), sha1b.subarray(8, 20), sha1c.subarray(4, 16)]);
+  const iv = concatBuffers([
+    sha1a.subarray(8, 20),
+    sha1b.subarray(0, 8),
+    sha1c.subarray(16, 20),
+    sha1d.subarray(0, 8)
+  ]);
+  return crypto.createAesIge(key, iv);
+}
+function xorBuffer(data, key) {
+  const ret = new Uint8Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    ret[i] = data[i] ^ key[i];
+  }
+  return ret;
+}
+function xorBufferInPlace(data, key) {
+  for (let i = 0; i < data.length; i++) {
+    data[i] ^= key[i];
+  }
+}
+class EarlyTimer {
+  _timeout;
+  _immediate;
+  _timeoutTs;
+  _handler = () => {
+  };
+  constructor() {
+    this.emitNow = this.emitNow.bind(this);
+  }
+  /**
+   * Emit the timer when the event loop is idle
+   * (basically `setImmediate()`)
+   */
+  emitWhenIdle() {
+    if (this._immediate) return;
+    clearTimeoutWrap(this._timeout);
+    this._timeoutTs = Date.now();
+    if (typeof setImmediateWrapExported !== "undefined") {
+      this._immediate = setImmediateWrapExported(this.emitNow);
+    } else {
+      this._timeout = setTimeoutWrap(this.emitNow, 0);
+    }
+  }
+  /**
+   * Emit the timer before the next given milliseconds
+   *
+   * Shorthand for `emitBefore(Date.now() + ms)`
+   *
+   * @param ms  Milliseconds to schedule for
+   */
+  emitBeforeNext(ms) {
+    return this.emitBefore(Date.now() + ms);
+  }
+  /**
+   * Emit the timer before the given time
+   *
+   * @param ts  Unix time in MS
+   */
+  emitBefore(ts) {
+    if (!this._timeoutTs || ts < this._timeoutTs) {
+      this.reset();
+      this._timeout = setTimeoutWrap(this.emitNow, ts - Date.now());
+      this._timeoutTs = ts;
+    }
+  }
+  /**
+   * Emit the timer right now
+   */
+  emitNow() {
+    this.reset();
+    this._handler();
+  }
+  /**
+   * Cancel the timer
+   */
+  reset() {
+    if (this._immediate) {
+      clearImmediateWrapExported(this._immediate);
+      this._immediate = void 0;
+    } else {
+      clearTimeoutWrap(this._timeout);
+    }
+    this._timeoutTs = void 0;
+  }
+  /**
+   * Set timeout handler
+   */
+  onTimeout(handler) {
+    this._handler = handler;
+  }
+}
+function throttle(func, delay) {
+  let timeout;
+  const res = function() {
+    if (timeout) {
+      return;
+    }
+    const later = () => {
+      timeout = null;
+      func();
+    };
+    timeout = setTimeoutWrap(later, delay);
+  };
+  res.reset = () => {
+    if (timeout) {
+      clearTimeoutWrap(timeout);
+      timeout = null;
+    }
+  };
+  return res;
+}
+function asyncResettable(func) {
+  let runningPromise = null;
+  let finished = false;
+  const run = function(...args) {
+    if (finished) return Promise.resolve();
+    if (runningPromise) {
+      return runningPromise;
+    }
+    runningPromise = func(...args);
+    void runningPromise.then(() => {
+      runningPromise = null;
+      finished = true;
+    });
+    return runningPromise;
+  };
+  return {
+    run,
+    finished: () => finished,
+    wait: () => runningPromise,
+    reset: () => {
+      finished = false;
+    }
+  };
+}
+class SortedLinkedList {
+  constructor(comparator) {
+    this.comparator = comparator;
+  }
+  _first;
+  _last;
+  _size = 0;
+  get length() {
+    return this._size;
+  }
+  _remove(item) {
+    if (this._first === item) {
+      this._first = item.n;
+    }
+    if (this._last === item) {
+      this._last = item.p;
+    }
+    if (item.p) item.p.n = item.n;
+    if (item.n) item.n.p = item.p;
+    this._size -= 1;
+  }
+  popFront() {
+    if (!this._first) return void 0;
+    const it = this._first;
+    this._first = this._first.n;
+    if (!this._first) this._last = void 0;
+    this._size -= 1;
+    return it.v;
+  }
+  add(item) {
+    const it = { v: item };
+    if (!this._first) {
+      this._first = this._last = it;
+    } else {
+      let cur = this._first;
+      while (cur && this.comparator(cur.v, it.v) < 0) {
+        cur = cur.n;
+      }
+      if (!cur) {
+        this._last.n = it;
+        it.p = this._last;
+        this._last = it;
+      } else {
+        it.n = cur;
+        it.p = cur.p;
+        if (cur.p) cur.p.n = it;
+        cur.p = it;
+        if (cur === this._first) this._first = it;
+      }
+    }
+    this._size += 1;
+  }
+  clear() {
+    this._first = this._last = void 0;
+    this._size = 0;
+  }
+}
+class LruSet {
+  _capacity;
+  _first;
+  _last;
+  _set;
+  constructor(capacity, forLong = false) {
+    this._capacity = capacity;
+    this._set = forLong ? new LongSet() : /* @__PURE__ */ new Set();
+  }
+  clear() {
+    this._first = this._last = void 0;
+    this._set.clear();
+  }
+  add(val) {
+    if (this._set.has(val)) return;
+    if (!this._first) this._first = { v: val };
+    if (!this._last) {
+      this._last = this._first;
+    } else {
+      this._last.n = { v: val };
+      this._last = this._last.n;
+    }
+    this._set.add(val);
+    if (this._set.size > this._capacity && this._first) {
+      this._set.delete(this._first.v);
+      this._first = this._first.n;
+    }
+  }
+  has(val) {
+    return this._set.has(val);
+  }
+}
+class SortedArray {
+  constructor(array = [], comparator) {
+    this.comparator = comparator;
+    this.raw = array.sort(comparator);
+    this.comparator = comparator;
+  }
+  raw;
+  get length() {
+    return this.raw.length;
+  }
+  insert(item) {
+    if (Array.isArray(item)) {
+      let ind = -1;
+      item.forEach((it) => {
+        ind = this.insert(it);
+      });
+      return ind;
+    }
+    if (this.raw.length === 0) {
+      this.raw.push(item);
+      return 0;
+    }
+    let lo = 0;
+    let hi = this.raw.length;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      if (this.comparator(this.raw[mid], item) > 0) {
+        hi = mid;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    this.raw.splice(lo, 0, item);
+    return lo;
+  }
+  // closest: return the closest value (right-hand side)
+  // meaning that raw[idx - 1] <= item <= raw[idx]
+  // in other words, smallest idx such that raw[idx] >= item
+  index(item, closest = false) {
+    let lo = 0;
+    let hi = this.raw.length;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      const cmp = this.comparator(this.raw[mid], item);
+      if (cmp === 0) {
+        return mid;
+      }
+      if (cmp > 0) {
+        hi = mid;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return closest ? lo : -1;
+  }
+  remove(item) {
+    const idx = this.index(item);
+    if (idx === -1) return;
+    this.raw.splice(idx, 1);
+  }
+  includes(item) {
+    return this.index(item) !== -1;
+  }
+  find(item) {
+    const ind = this.index(item);
+    return ind === -1 ? null : this.raw[ind];
+  }
+  clear() {
+    this.raw.length = 0;
+  }
+}
+export {
+  BaseService,
+  CurrentUserService,
+  DefaultDcsService,
+  EarlyTimer,
+  LruSet,
+  SortedArray,
+  SortedLinkedList,
+  UpdatesStateService,
+  addPublicKey,
+  asyncResettable,
+  bigIntAbs,
+  bigIntBitLength,
+  bigIntGcd,
+  bigIntMin,
+  bigIntModInv,
+  bigIntModPow,
+  bigIntToBuffer,
+  bufferToBigInt,
+  composeMiddlewares,
+  createAesIgeForMessage,
+  createAesIgeForMessageOld,
+  defaultProductionDc,
+  defaultProductionIpv6Dc,
+  defaultTestDc,
+  defaultTestIpv6Dc,
+  findKeyByFingerprints,
+  generateKeyAndIvFromNonce,
+  millerRabin,
+  parseBasicDcOption,
+  parsePublicKey,
+  randomBigInt,
+  randomBigIntBits,
+  randomBigIntInRange,
+  serializeBasicDcOption,
+  throttle,
+  twoMultiplicity,
+  xorBuffer,
+  xorBufferInPlace
+};