@mtcute/core 0.17.0 → 0.18.0-rc.5

package/chunks/es/CO4G3ySK.js

@@ -1,985 +0,0 @@
-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
-};