@tma.js/sdk-react 2.0.3 → 2.1.1

package/dist/index.js

@@ -0,0 +1,2991 @@
+import { jsx as vt } from "react/jsx-runtime";
+import { createContext as te, useContext as ee, useMemo as st, useRef as lt, useState as se, useCallback as _t, useEffect as M } from "react";
+var ne = Object.defineProperty, re = (e, t, s) => t in e ? ne(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, c = (e, t, s) => (re(e, typeof t != "symbol" ? t + "" : t, s), s);
+function yt(e, t) {
+  let s;
+  const n = () => {
+    s !== void 0 && t && t(s), s = void 0;
+  };
+  return [() => s === void 0 ? s = e(n) : s, n];
+}
+function Et(e) {
+  const t = G(), { count: s } = t;
+  t.unsubscribe(e), s && !t.count && Te();
+}
+function ie(e) {
+  return G().subscribe(e), () => Et(e);
+}
+class oe {
+  constructor(t, s = {}) {
+    this.scope = t, this.options = s;
+  }
+  /**
+   * Prints message into a console in case, logger is currently enabled.
+   * @param level - log level.
+   * @param args - arguments.
+   */
+  print(t, ...s) {
+    const n = /* @__PURE__ */ new Date(), r = Intl.DateTimeFormat("en-GB", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3,
+      timeZone: "UTC"
+    }).format(n), { textColor: i, bgColor: o } = this.options, a = "font-weight: bold;padding: 0 5px;border-radius:5px";
+    console[t](
+      `%c${r}%c / %c${this.scope}`,
+      `${a};background-color: lightblue;color:black`,
+      "",
+      `${a};${i ? `color:${i};` : ""}${o ? `background-color:${o}` : ""}`,
+      ...s
+    );
+  }
+  /**
+   * Prints error message into a console.
+   * @param args
+   */
+  error(...t) {
+    this.print("error", ...t);
+  }
+  /**
+   * Prints log message into a console.
+   * @param args
+   */
+  log(...t) {
+    this.print("log", ...t);
+  }
+}
+const H = new oe("SDK", {
+  bgColor: "forestgreen",
+  textColor: "white"
+});
+let X = !1;
+const gt = ({ event: e, args: [t] }) => {
+  H.log("Event received:", t === void 0 ? { name: e } : { name: e, data: t });
+};
+function ae(e) {
+  X !== e && (X = e, e ? ie(gt) : Et(gt));
+}
+function ce(...e) {
+  X && H.log(...e);
+}
+class U {
+  constructor() {
+    c(this, "listeners", /* @__PURE__ */ new Map()), c(this, "listenersCount", 0), c(this, "subscribeListeners", []);
+  }
+  /**
+   * Removes all event listeners.
+   */
+  clear() {
+    this.listeners.clear(), this.subscribeListeners = [];
+  }
+  /**
+   * Returns count of bound listeners.
+   */
+  get count() {
+    return this.listenersCount + this.subscribeListeners.length;
+  }
+  emit(t, ...s) {
+    this.subscribeListeners.forEach((n) => n({
+      event: t,
+      args: s
+    })), (this.listeners.get(t) || []).forEach(([n, r]) => {
+      n(...s), r && this.off(t, n);
+    });
+  }
+  /**
+   * Adds new event listener.
+   * @param event - event name.
+   * @param listener - event listener.
+   * @param once - should listener be called only once.
+   * @returns Function to remove bound event listener.
+   */
+  on(t, s, n) {
+    let r = this.listeners.get(t);
+    return r || this.listeners.set(t, r = []), r.push([s, n]), this.listenersCount += 1, () => this.off(t, s);
+  }
+  /**
+   * Removes event listener. In case, specified listener was bound several times, it removes
+   * only a single one.
+   * @param event - event name.
+   * @param listener - event listener.
+   */
+  off(t, s) {
+    const n = this.listeners.get(t) || [];
+    for (let r = 0; r < n.length; r += 1)
+      if (s === n[r][0]) {
+        n.splice(r, 1), this.listenersCount -= 1;
+        return;
+      }
+  }
+  /**
+   * Adds a new event listener for all events.
+   * @param listener - event listener.
+   * @returns Function to remove event listener.
+   */
+  subscribe(t) {
+    return this.subscribeListeners.push(t), () => this.unsubscribe(t);
+  }
+  /**
+   * Removes global event listener. In case, specified listener was bound several times, it removes
+   * only a single one.
+   * @param listener - event listener.
+   */
+  unsubscribe(t) {
+    for (let s = 0; s < this.subscribeListeners.length; s += 1)
+      if (this.subscribeListeners[s] === t) {
+        this.subscribeListeners.splice(s, 1);
+        return;
+      }
+  }
+}
+function tt(e, t, s) {
+  return window.addEventListener(e, t, s), () => window.removeEventListener(e, t, s);
+}
+class W extends Error {
+  constructor(t, s, n) {
+    super(s, { cause: n }), this.type = t, Object.setPrototypeOf(this, W.prototype);
+  }
+}
+function l(e, t, s) {
+  return new W(e, t, s);
+}
+const he = "ERR_METHOD_UNSUPPORTED", pe = "ERR_METHOD_PARAMETER_UNSUPPORTED", ue = "ERR_UNKNOWN_ENV", de = "ERR_INVOKE_CUSTOM_METHOD_RESPONSE", le = "ERR_TIMED_OUT", _e = "ERR_UNEXPECTED_TYPE", Pt = "ERR_PARSE", ge = "ERR_NAVIGATION_LIST_EMPTY", we = "ERR_NAVIGATION_CURSOR_INVALID", _n = "ERR_NAVIGATION_ITEM_INVALID", nt = "ERR_SSR_INIT", fe = "ERR_SSR_POST_EVENT", me = "ERR_INVALID_PATH_BASE";
+function T() {
+  return l(_e, "Value has unexpected type");
+}
+class j {
+  constructor(t, s, n) {
+    this.parser = t, this.isOptional = s, this.type = n;
+  }
+  /**
+   * Attempts to parse passed value
+   * @param value - value to parse.
+   * @throws {SDKError} ERR_PARSE
+   * @see ERR_PARSE
+   */
+  parse(t) {
+    if (!(this.isOptional && t === void 0))
+      try {
+        return this.parser(t);
+      } catch (s) {
+        throw l(
+          Pt,
+          `Unable to parse value${this.type ? ` as ${this.type}` : ""}`,
+          s
+        );
+      }
+  }
+  optional() {
+    return this.isOptional = !0, this;
+  }
+}
+function A(e, t) {
+  return () => new j(e, !1, t);
+}
+const P = A((e) => {
+  if (typeof e == "boolean")
+    return e;
+  const t = String(e);
+  if (t === "1" || t === "true")
+    return !0;
+  if (t === "0" || t === "false")
+    return !1;
+  throw T();
+}, "boolean");
+function Rt(e, t) {
+  const s = {};
+  for (const n in e) {
+    const r = e[n];
+    if (!r)
+      continue;
+    let i, o;
+    if (typeof r == "function" || "parse" in r)
+      i = n, o = typeof r == "function" ? r : r.parse.bind(r);
+    else {
+      const { type: a } = r;
+      i = r.from || n, o = typeof a == "function" ? a : a.parse.bind(a);
+    }
+    try {
+      const a = o(t(i));
+      a !== void 0 && (s[n] = a);
+    } catch (a) {
+      throw l(Pt, `Unable to parse field "${n}"`, a);
+    }
+  }
+  return s;
+}
+function rt(e) {
+  let t = e;
+  if (typeof t == "string" && (t = JSON.parse(t)), typeof t != "object" || t === null || Array.isArray(t))
+    throw T();
+  return t;
+}
+function f(e, t) {
+  return new j((s) => {
+    const n = rt(s);
+    return Rt(e, (r) => n[r]);
+  }, !1, t);
+}
+const x = A((e) => {
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "string") {
+    const t = Number(e);
+    if (!Number.isNaN(t))
+      return t;
+  }
+  throw T();
+}, "number");
+function it(e) {
+  return /^#[\da-f]{6}$/i.test(e);
+}
+function be(e) {
+  return /^#[\da-f]{3}$/i.test(e);
+}
+function xt(e) {
+  const t = e.replace(/\s/g, "").toLowerCase();
+  if (it(t))
+    return t;
+  if (be(t)) {
+    let n = "#";
+    for (let r = 0; r < 3; r += 1)
+      n += t[1 + r].repeat(2);
+    return n;
+  }
+  const s = t.match(/^rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)$/) || t.match(/^rgba\((\d{1,3}),(\d{1,3}),(\d{1,3}),\d{1,3}\)$/);
+  if (!s)
+    throw new Error(`Value "${e}" does not satisfy any of known RGB formats.`);
+  return s.slice(1).reduce((n, r) => {
+    const i = parseInt(r, 10).toString(16);
+    return n + (i.length === 1 ? "0" : "") + i;
+  }, "#");
+}
+const h = A((e) => {
+  if (typeof e == "string" || typeof e == "number")
+    return e.toString();
+  throw T();
+}, "string"), St = A((e) => xt(h().parse(e)), "rgb");
+function ve(e) {
+  return f({
+    eventType: h(),
+    eventData: (t) => t
+  }).parse(e);
+}
+function ye() {
+  ["TelegramGameProxy_receiveEvent", "TelegramGameProxy", "Telegram"].forEach((e) => {
+    delete window[e];
+  });
+}
+function Ee(e, t) {
+  window.dispatchEvent(new MessageEvent("message", {
+    data: JSON.stringify({ eventType: e, eventData: t }),
+    // We specify window.parent to imitate the case, the parent iframe sent us this event.
+    source: window.parent
+  }));
+}
+function Pe() {
+  [
+    ["TelegramGameProxy_receiveEvent"],
+    // Windows Phone.
+    ["TelegramGameProxy", "receiveEvent"],
+    // Desktop.
+    ["Telegram", "WebView", "receiveEvent"]
+    // Android and iOS.
+  ].forEach((e) => {
+    let t = window;
+    e.forEach((s, n, r) => {
+      if (n === r.length - 1) {
+        t[s] = Ee;
+        return;
+      }
+      s in t || (t[s] = {}), t = t[s];
+    });
+  });
+}
+const Re = f({
+  button_id: (e) => e == null ? void 0 : h().parse(e)
+}), xe = {
+  clipboard_text_received: f({
+    req_id: h(),
+    data: (e) => e === null ? e : h().optional().parse(e)
+  }),
+  custom_method_invoked: f({
+    req_id: h(),
+    result: (e) => e,
+    error: h().optional()
+  }),
+  invoice_closed: f({
+    slug: h(),
+    status: h()
+  }),
+  phone_requested: f({
+    status: h()
+  }),
+  popup_closed: {
+    parse: (e) => Re.parse(e ?? {})
+  },
+  qr_text_received: f({
+    data: h().optional()
+  }),
+  theme_changed: f({
+    theme_params: (e) => {
+      const t = St().optional();
+      return Object.entries(rt(e)).reduce((s, [n, r]) => (s[n] = t.parse(r), s), {});
+    }
+  }),
+  viewport_changed: f({
+    height: x(),
+    width: (e) => e == null ? window.innerWidth : x().parse(e),
+    is_state_stable: P(),
+    is_expanded: P()
+  }),
+  write_access_requested: f({
+    status: h()
+  })
+};
+function Se() {
+  const e = new U();
+  Pe();
+  let t = [
+    // Don't forget to remove created handlers.
+    ye,
+    // Add "resize" event listener to make sure, we always have fresh viewport information.
+    // Desktop version of Telegram is sometimes not sending the viewport_changed
+    // event. For example, when the MainButton is shown. That's why we should
+    // add our own listener to make sure, viewport information is always fresh.
+    // Issue: https://github.com/Telegram-Mini-Apps/tma.js/issues/10
+    tt("resize", () => {
+      e.emit("viewport_changed", {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        is_state_stable: !0,
+        is_expanded: !0
+      });
+    }),
+    // Add listener, which handles events sent from the Telegram web application and also events
+    // generated by the local emitEvent function.
+    tt("message", (s) => {
+      if (s.source !== window.parent)
+        return;
+      let n;
+      try {
+        n = ve(s.data);
+      } catch {
+        return;
+      }
+      const { eventType: r, eventData: i } = n, o = xe[r];
+      try {
+        const a = o ? o.parse(i) : i;
+        e.emit(...a ? [r, a] : [r]);
+      } catch (a) {
+        H.error(
+          `An error occurred processing the "${r}" event from the Telegram application. Please, file an issue here: https://github.com/Telegram-Mini-Apps/tma.js/issues/new/choose`,
+          n,
+          a
+        );
+      }
+    }),
+    // Clear emitter bound events.
+    () => e.clear()
+  ];
+  return [e, () => {
+    t.forEach((s) => s()), t = [];
+  }];
+}
+const [Ce, Te] = yt(
+  (e) => {
+    const [t, s] = Se(), n = t.off.bind(t);
+    return t.off = (r, i) => {
+      const { count: o } = t;
+      n(r, i), o && !t.count && e();
+    }, [t, s];
+  },
+  ([, e]) => e()
+);
+function G() {
+  return Ce()[0];
+}
+function z(e, t) {
+  G().off(e, t);
+}
+function E(e, t, s) {
+  return G().on(e, t, s);
+}
+function D(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function Ae(e, t) {
+  const s = e.split("."), n = t.split("."), r = Math.max(s.length, n.length);
+  for (let i = 0; i < r; i += 1) {
+    const o = parseInt(s[i] || "0", 10), a = parseInt(n[i] || "0", 10);
+    if (o !== a)
+      return o > a ? 1 : -1;
+  }
+  return 0;
+}
+function y(e, t) {
+  return Ae(e, t) <= 0;
+}
+function S(e, t, s) {
+  if (typeof s == "string") {
+    if (e === "web_app_open_link" && t === "try_instant_view")
+      return y("6.4", s);
+    if (e === "web_app_set_header_color" && t === "color")
+      return y("6.9", s);
+  }
+  switch (e) {
+    case "web_app_open_tg_link":
+    case "web_app_open_invoice":
+    case "web_app_setup_back_button":
+    case "web_app_set_background_color":
+    case "web_app_set_header_color":
+    case "web_app_trigger_haptic_feedback":
+      return y("6.1", t);
+    case "web_app_open_popup":
+      return y("6.2", t);
+    case "web_app_close_scan_qr_popup":
+    case "web_app_open_scan_qr_popup":
+    case "web_app_read_text_from_clipboard":
+      return y("6.4", t);
+    case "web_app_switch_inline_query":
+      return y("6.7", t);
+    case "web_app_invoke_custom_method":
+    case "web_app_request_write_access":
+    case "web_app_request_phone":
+      return y("6.9", t);
+    case "web_app_setup_settings_button":
+      return y("6.10", t);
+    case "web_app_biometry_get_info":
+    case "web_app_biometry_open_settings":
+    case "web_app_biometry_request_access":
+    case "web_app_biometry_request_auth":
+    case "web_app_biometry_update_token":
+      return y("7.2", t);
+    default:
+      return [
+        "iframe_ready",
+        "iframe_will_reload",
+        "web_app_close",
+        "web_app_data_send",
+        "web_app_expand",
+        "web_app_open_link",
+        "web_app_ready",
+        "web_app_request_theme",
+        "web_app_request_viewport",
+        "web_app_setup_main_button",
+        "web_app_setup_closing_behavior"
+      ].includes(e);
+  }
+}
+function ke(e) {
+  return "external" in e && D(e.external) && "notify" in e.external && typeof e.external.notify == "function";
+}
+function Ct(e) {
+  return "TelegramWebviewProxy" in e && D(e.TelegramWebviewProxy) && "postEvent" in e.TelegramWebviewProxy && typeof e.TelegramWebviewProxy.postEvent == "function";
+}
+function Tt() {
+  try {
+    return window.self !== window.top;
+  } catch {
+    return !0;
+  }
+}
+let At = "https://web.telegram.org";
+function gn(e) {
+  At = e;
+}
+function Ie() {
+  return At;
+}
+function q(e, t, s) {
+  let n = {}, r;
+  t === void 0 && s === void 0 ? n = {} : t !== void 0 && s !== void 0 ? (n = s, r = t) : t !== void 0 && ("targetOrigin" in t ? n = t : r = t);
+  const { targetOrigin: i = Ie() } = n;
+  if (ce("Posting event:", r ? { event: e, data: r } : { event: e }), Tt()) {
+    window.parent.postMessage(JSON.stringify({ eventType: e, eventData: r }), i);
+    return;
+  }
+  if (ke(window)) {
+    window.external.notify(JSON.stringify({ eventType: e, eventData: r }));
+    return;
+  }
+  if (Ct(window)) {
+    window.TelegramWebviewProxy.postEvent(e, JSON.stringify(r));
+    return;
+  }
+  throw l(
+    ue,
+    "Unable to determine current environment and possible way to send event. You are probably trying to use Mini Apps method outside of Telegram application environment."
+  );
+}
+function Oe(e) {
+  return (t, s) => {
+    if (!S(t, e))
+      throw l(he, `Method "${t}" is unsupported in Mini Apps version ${e}`);
+    if (D(s)) {
+      let n;
+      if (t === "web_app_open_link" && "try_instant_view" in s ? n = "try_instant_view" : t === "web_app_set_header_color" && "color" in s && (n = "color"), n && !S(t, n, e))
+        throw l(
+          pe,
+          `Parameter "${n}" of "${t}" method is unsupported in Mini Apps version ${e}`
+        );
+    }
+    return q(t, s);
+  };
+}
+function kt(e) {
+  return ({ req_id: t }) => t === e;
+}
+function It(e) {
+  return l(le, `Timeout reached: ${e}ms`);
+}
+function Ot(e, t) {
+  return Promise.race([
+    typeof e == "function" ? e() : e,
+    new Promise((s, n) => {
+      setTimeout(() => {
+        n(It(t));
+      }, t);
+    })
+  ]);
+}
+async function m(e) {
+  let t;
+  const s = new Promise((u) => {
+    t = u;
+  }), {
+    method: n,
+    event: r,
+    capture: i,
+    postEvent: o = q,
+    timeout: a
+  } = e, p = (Array.isArray(r) ? r : [r]).map(
+    (u) => E(u, (d) => (!i || i(d)) && t(d))
+  );
+  try {
+    return o(n, e.params), await (a ? Ot(s, a) : s);
+  } finally {
+    p.forEach((u) => u());
+  }
+}
+async function I(e, t, s, n = {}) {
+  const {
+    result: r,
+    error: i
+  } = await m({
+    ...n,
+    method: "web_app_invoke_custom_method",
+    event: "custom_method_invoked",
+    params: {
+      method: e,
+      params: t,
+      req_id: s
+    },
+    capture: kt(s)
+  });
+  if (i)
+    throw l(de, i);
+  return r;
+}
+function et(...e) {
+  return e.map((t) => {
+    if (typeof t == "string")
+      return t;
+    if (D(t))
+      return et(Object.entries(t).map((s) => s[1] && s[0]));
+    if (Array.isArray(t))
+      return et(...t);
+  }).filter(Boolean).join(" ");
+}
+function wn(...e) {
+  return e.reduce((t, s) => (D(s) && Object.entries(s).forEach(([n, r]) => {
+    const i = et(t[n], r);
+    i.length && (t[n] = i);
+  }), t), {});
+}
+function qt(e) {
+  const t = xt(e);
+  return Math.sqrt(
+    [0.299, 0.587, 0.114].reduce((s, n, r) => {
+      const i = parseInt(t.slice(1 + r * 2, 1 + (r + 1) * 2), 16);
+      return s + i * i * n;
+    }, 0)
+  ) < 120;
+}
+class qe {
+  constructor(t) {
+    c(this, "ee", new U()), c(this, "on", this.ee.on.bind(this.ee)), c(this, "off", this.ee.off.bind(this.ee)), this.state = t;
+  }
+  /**
+   * Clones current state and returns its copy.
+   */
+  clone() {
+    return { ...this.state };
+  }
+  set(t, s) {
+    Object.entries(typeof t == "string" ? { [t]: s } : t).reduce((n, [r, i]) => this.state[r] === i || i === void 0 ? n : (this.state[r] = i, this.ee.emit(`change:${r}`, i), !0), !1) && this.ee.emit("change", this.state);
+  }
+  /**
+   * Returns value by specified key.
+   * @param key - state key.
+   */
+  get(t) {
+    return this.state[t];
+  }
+}
+class ot {
+  constructor(t) {
+    c(this, "state"), c(this, "get"), c(this, "set"), c(this, "clone"), this.state = new qe(t), this.set = this.state.set.bind(this.state), this.get = this.state.get.bind(this.state), this.clone = this.state.clone.bind(this.state);
+  }
+}
+function Nt(e, t) {
+  return (s) => S(t[s], e);
+}
+class at extends ot {
+  constructor(t, s, n) {
+    super(t), c(this, "supports"), this.supports = Nt(s, n);
+  }
+}
+class Ne extends at {
+  constructor(t, s, n) {
+    super({ isVisible: t }, s, {
+      show: "web_app_setup_back_button",
+      hide: "web_app_setup_back_button"
+    }), c(this, "on", (r, i) => r === "click" ? E("back_button_pressed", i) : this.state.on(r, i)), c(this, "off", (r, i) => r === "click" ? z("back_button_pressed", i) : this.state.off(r, i)), this.postEvent = n;
+  }
+  set isVisible(t) {
+    this.set("isVisible", t), this.postEvent("web_app_setup_back_button", { is_visible: t });
+  }
+  /**
+   * True if BackButton is currently visible.
+   */
+  get isVisible() {
+    return this.get("isVisible");
+  }
+  /**
+   * Hides the BackButton.
+   */
+  hide() {
+    this.isVisible = !1;
+  }
+  /**
+   * Shows the BackButton.
+   */
+  show() {
+    this.isVisible = !0;
+  }
+}
+function C() {
+  return typeof window > "u";
+}
+const Dt = A((e) => e instanceof Date ? e : new Date(x().parse(e) * 1e3), "Date");
+function ct(e, t) {
+  return new j((s) => {
+    if (typeof s != "string" && !(s instanceof URLSearchParams))
+      throw T();
+    const n = typeof s == "string" ? new URLSearchParams(s) : s;
+    return Rt(e, (r) => {
+      const i = n.get(r);
+      return i === null ? void 0 : i;
+    });
+  }, !1, t);
+}
+const De = f({
+  id: x(),
+  type: h(),
+  title: h(),
+  photoUrl: {
+    type: h().optional(),
+    from: "photo_url"
+  },
+  username: h().optional()
+}, "Chat").optional(), wt = f({
+  addedToAttachmentMenu: {
+    type: P().optional(),
+    from: "added_to_attachment_menu"
+  },
+  allowsWriteToPm: {
+    type: P().optional(),
+    from: "allows_write_to_pm"
+  },
+  firstName: {
+    type: h(),
+    from: "first_name"
+  },
+  id: x(),
+  isBot: {
+    type: P().optional(),
+    from: "is_bot"
+  },
+  isPremium: {
+    type: P().optional(),
+    from: "is_premium"
+  },
+  languageCode: {
+    type: h().optional(),
+    from: "language_code"
+  },
+  lastName: {
+    type: h().optional(),
+    from: "last_name"
+  },
+  photoUrl: {
+    type: h().optional(),
+    from: "photo_url"
+  },
+  username: h().optional()
+}, "User").optional();
+function Vt() {
+  return ct({
+    authDate: {
+      type: Dt(),
+      from: "auth_date"
+    },
+    canSendAfter: {
+      type: x().optional(),
+      from: "can_send_after"
+    },
+    chat: De,
+    chatInstance: {
+      type: h().optional(),
+      from: "chat_instance"
+    },
+    chatType: {
+      type: h().optional(),
+      from: "chat_type"
+    },
+    hash: h(),
+    queryId: {
+      type: h().optional(),
+      from: "query_id"
+    },
+    receiver: wt,
+    startParam: {
+      type: h().optional(),
+      from: "start_param"
+    },
+    user: wt
+  }, "InitData");
+}
+function Ve(e) {
+  return e.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
+}
+function Be(e) {
+  return e.replace(/[A-Z]/g, (t) => `_${t.toLowerCase()}`);
+}
+const Bt = A(
+  (e) => {
+    const t = St().optional();
+    return Object.entries(rt(e)).reduce((s, [n, r]) => (s[Ve(n)] = t.parse(r), s), {});
+  },
+  "ThemeParams"
+);
+function Mt(e) {
+  return ct({
+    botInline: {
+      type: P().optional(),
+      from: "tgWebAppBotInline"
+    },
+    initData: {
+      type: Vt().optional(),
+      from: "tgWebAppData"
+    },
+    initDataRaw: {
+      type: h().optional(),
+      from: "tgWebAppData"
+    },
+    platform: {
+      type: h(),
+      from: "tgWebAppPlatform"
+    },
+    showSettings: {
+      type: P().optional(),
+      from: "tgWebAppShowSettings"
+    },
+    startParam: {
+      type: h().optional(),
+      from: "tgWebAppStartParam"
+    },
+    themeParams: {
+      type: Bt(),
+      from: "tgWebAppThemeParams"
+    },
+    version: {
+      type: h(),
+      from: "tgWebAppVersion"
+    }
+  }).parse(e);
+}
+function $t(e) {
+  return Mt(
+    e.replace(/^[^?#]*[?#]/, "").replace(/[?#]/g, "&")
+  );
+}
+function Me() {
+  return $t(window.location.href);
+}
+function Lt() {
+  return performance.getEntriesByType("navigation")[0];
+}
+function $e() {
+  const e = Lt();
+  if (!e)
+    throw new Error("Unable to get first navigation entry.");
+  return $t(e.name);
+}
+function Ht(e) {
+  return `tma.js/${e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`)}`;
+}
+function Ut(e, t) {
+  sessionStorage.setItem(Ht(e), JSON.stringify(t));
+}
+function Wt(e) {
+  const t = sessionStorage.getItem(Ht(e));
+  try {
+    return t ? JSON.parse(t) : void 0;
+  } catch {
+  }
+}
+function Le() {
+  return Mt(Wt("launchParams") || "");
+}
+function He(e) {
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries(e).map(([t, s]) => [Be(t), s])
+    )
+  );
+}
+function Ue(e) {
+  const {
+    initDataRaw: t,
+    themeParams: s,
+    platform: n,
+    version: r,
+    showSettings: i,
+    startParam: o,
+    botInline: a
+  } = e, p = new URLSearchParams();
+  return p.set("tgWebAppPlatform", n), p.set("tgWebAppThemeParams", He(s)), p.set("tgWebAppVersion", r), t && p.set("tgWebAppData", t), o && p.set("tgWebAppStartParam", o), typeof i == "boolean" && p.set("tgWebAppShowSettings", i ? "1" : "0"), typeof a == "boolean" && p.set("tgWebAppBotInline", a ? "1" : "0"), p.toString();
+}
+function We(e) {
+  Ut("launchParams", Ue(e));
+}
+function jt() {
+  for (const e of [
+    // Try to retrieve launch parameters from the current location. This method can return
+    // nothing in case, location was changed and then page was reloaded.
+    Me,
+    // Then, try using the lower level API - window.performance.
+    $e,
+    // Finally, try to extract launch parameters from the session storage.
+    Le
+  ])
+    try {
+      const t = e();
+      return We(t), t;
+    } catch {
+    }
+  throw new Error("Unable to retrieve launch parameters from any known source.");
+}
+function Gt() {
+  const e = Lt();
+  return !!(e && e.type === "reload");
+}
+function je() {
+  let e = 0;
+  return () => (e += 1).toString();
+}
+const [Ge] = yt(je);
+function _(e, t) {
+  return ({ ssr: s } = {}) => {
+    let n;
+    if (C()) {
+      if (!s)
+        throw l(
+          nt,
+          "ssr.options must be specified to initialize component on the server side"
+        );
+      n = s;
+    } else
+      n = jt();
+    const r = {
+      ...n,
+      postEvent: "version" in n ? Oe(n.version) : () => {
+        throw l(
+          fe,
+          "postEvent function is forbidden to be called on the server side."
+        );
+      },
+      createRequestId: Ge()
+    };
+    if (C() || typeof e == "function")
+      return typeof e == "function" ? e(r) : t(r);
+    const i = t({
+      ...r,
+      state: Gt() ? Wt(e) : void 0
+    }), o = (a) => (a.on("change", (p) => {
+      Ut(e, p);
+    }), a);
+    return i instanceof Promise ? i.then(o) : o(i);
+  };
+}
+const ze = _("backButton", ({
+  postEvent: e,
+  version: t,
+  state: s = { isVisible: !1 }
+}) => new Ne(s.isVisible, t, e));
+class V extends at {
+  constructor() {
+    super(...arguments), c(this, "on", this.state.on.bind(this.state)), c(this, "off", this.state.off.bind(this.state));
+  }
+}
+function zt(e) {
+  const t = e.available ? e : {
+    available: !1,
+    device_id: "",
+    token_saved: !1,
+    access_requested: !1,
+    access_granted: !1,
+    type: ""
+  };
+  return {
+    available: !0,
+    type: t.type,
+    deviceId: t.device_id,
+    tokenSaved: t.token_saved,
+    accessRequested: t.access_requested,
+    accessGranted: t.access_granted
+  };
+}
+class ft extends V {
+  constructor({ postEvent: t, version: s, ...n }) {
+    super(n, s, {
+      auth: "web_app_biometry_request_auth",
+      openSettings: "web_app_biometry_open_settings",
+      requestAccess: "web_app_biometry_request_access",
+      updateToken: "web_app_biometry_update_token"
+    }), c(this, "postEvent"), c(this, "authPromise"), c(this, "accessPromise"), this.postEvent = t;
+  }
+  /**
+   * Shows whether biometry is available.
+   */
+  get available() {
+    return this.get("available");
+  }
+  /**
+   * Shows whether permission to use biometrics has been granted.
+   */
+  get accessGranted() {
+    return this.get("accessGranted");
+  }
+  /**
+   * Shows whether if permission to use biometrics has been requested.
+   */
+  get accessRequested() {
+    return this.get("accessRequested");
+  }
+  /**
+   * Authenticates the user using biometrics.
+   * @param options - method options.
+   * @since 7.2
+   * @returns Token from the local secure storage, if authentication was successful.
+   */
+  async authenticate({
+    reason: t,
+    ...s
+  }) {
+    return this.authPromise || (this.authPromise = m({
+      ...s,
+      method: "web_app_biometry_request_auth",
+      event: "biometry_auth_requested",
+      postEvent: this.postEvent,
+      params: {
+        // TODO: Check if reason is empty works fine.
+        reason: (t || "").trim()
+      }
+    }).then(({ token: n }) => n).finally(() => this.authPromise = void 0)), this.authPromise;
+  }
+  /**
+   * A unique device identifier that can be used to match the token to the device.
+   */
+  get deviceId() {
+    return this.get("deviceId");
+  }
+  /**
+   * Opens the biometric access settings for bots. Useful when you need to request biometrics
+   * access to users who haven't granted it yet.
+   *
+   * _Note that this method can be called only in response to user interaction with the Mini App
+   * interface (e.g. a click inside the Mini App or on the main button)_.
+   * @since 7.2
+   */
+  openSettings() {
+    this.postEvent("web_app_biometry_open_settings");
+  }
+  /**
+   * Requests permission to use biometrics.
+   * @since 7.2
+   * @returns Promise with true, if access was granted.
+   */
+  requestAccess({ reason: t, ...s } = {}) {
+    return this.accessPromise || (this.accessPromise = m({
+      ...s,
+      postEvent: this.postEvent,
+      method: "web_app_biometry_request_access",
+      event: "biometry_info_received",
+      params: { reason: t || "" }
+    }).then((n) => {
+      const r = zt(n);
+      return this.set(r), r.accessGranted;
+    }).finally(() => this.accessPromise = void 0)), this.accessPromise;
+  }
+  /**
+   * The type of biometrics currently available on the device.
+   */
+  get biometryType() {
+    return this.get("biometryType");
+  }
+  /**
+   * Shows whether token was saved previously in the local secure storage.
+   */
+  get tokenSaved() {
+    return this.get("tokenSaved");
+  }
+  /**
+   * Updates the biometric token in a secure storage on the device.
+   * @returns Promise with `true`, if token was updated.
+   */
+  async updateToken({ token: t, ...s } = {}) {
+    return ["removed", "updated"].includes(
+      (await m({
+        ...s,
+        postEvent: this.postEvent,
+        method: "web_app_biometry_update_token",
+        event: "biometry_token_updated",
+        params: { token: t || "" }
+      })).status
+    );
+  }
+}
+async function Ke(e) {
+  return zt(
+    await m({
+      ...e || {},
+      method: "web_app_biometry_get_info",
+      event: "biometry_info_received"
+    })
+  );
+}
+const Je = _("biometryManager", async ({ postEvent: e, version: t, state: s }) => {
+  if (s)
+    return new ft({ ...s, version: t, postEvent: e });
+  if (C())
+    throw l(
+      nt,
+      "BiometryManager cannot be instantiated on the server side without passing the ssr.state object."
+    );
+  return new ft({
+    ...await Ke({ timeout: 1e3 }),
+    version: t,
+    postEvent: e
+  });
+});
+class ht extends ot {
+  constructor() {
+    super(...arguments), c(this, "on", this.state.on.bind(this.state)), c(this, "off", this.state.off.bind(this.state));
+  }
+}
+class Qe extends ht {
+  constructor(t, s) {
+    super({ isConfirmationNeeded: t }), this.postEvent = s;
+  }
+  set isConfirmationNeeded(t) {
+    this.set("isConfirmationNeeded", t), this.postEvent("web_app_setup_closing_behavior", { need_confirmation: t });
+  }
+  /**
+   * True, if the confirmation dialog should be shown while the user is trying to close
+   * the Mini App.
+   */
+  get isConfirmationNeeded() {
+    return this.get("isConfirmationNeeded");
+  }
+  /**
+   * Disables the confirmation dialog when closing the Mini App.
+   */
+  disableConfirmation() {
+    this.isConfirmationNeeded = !1;
+  }
+  /**
+   * Enables the confirmation dialog when closing the Mini App.
+   */
+  enableConfirmation() {
+    this.isConfirmationNeeded = !0;
+  }
+}
+const Fe = _("closingBehavior", ({
+  postEvent: e,
+  state: t = { isConfirmationNeeded: !1 }
+}) => new Qe(t.isConfirmationNeeded, e));
+class pt {
+  constructor(t, s) {
+    c(this, "supports"), this.supports = Nt(t, s);
+  }
+}
+function Ye(e) {
+  if (Array.isArray(e))
+    return e;
+  if (typeof e == "string")
+    try {
+      const t = JSON.parse(e);
+      if (Array.isArray(t))
+        return t;
+    } catch {
+    }
+  throw T();
+}
+class Ze extends j {
+  constructor(t, s, n) {
+    super(Ye, s, n), c(this, "itemParser"), this.itemParser = typeof t == "function" ? t : t.parse.bind(t);
+  }
+  /**
+   * Attempts to parse passed value
+   * @param value - value to parse.
+   * @throws {SDKError} ERR_PARSE
+   * @see ERR_PARSE
+   */
+  parse(t) {
+    const s = super.parse(t);
+    return s === void 0 ? s : s.map(this.itemParser);
+  }
+  of(t) {
+    return this.itemParser = typeof t == "function" ? t : t.parse.bind(t), this;
+  }
+}
+function Xe(e) {
+  return new Ze((t) => t, !1, e);
+}
+function mt(e, t) {
+  return Object.fromEntries(e.map((s) => [s, t]));
+}
+class ts extends pt {
+  constructor(t, s, n) {
+    super(t, {
+      delete: "web_app_invoke_custom_method",
+      get: "web_app_invoke_custom_method",
+      getKeys: "web_app_invoke_custom_method",
+      set: "web_app_invoke_custom_method"
+    }), this.createRequestId = s, this.postEvent = n;
+  }
+  /**
+   * Deletes specified key or keys from the cloud storage.
+   * @param keyOrKeys - key or keys to delete.
+   * @param options - request execution options.
+   */
+  async delete(t, s = {}) {
+    const n = Array.isArray(t) ? t : [t];
+    n.length && await I(
+      "deleteStorageValues",
+      { keys: n },
+      this.createRequestId(),
+      { ...s, postEvent: this.postEvent }
+    );
+  }
+  /**
+   * Returns list of all keys presented in the cloud storage.
+   * @param options - request execution options.
+   */
+  async getKeys(t = {}) {
+    return Xe().of(h()).parse(
+      await I(
+        "getStorageKeys",
+        {},
+        this.createRequestId(),
+        { ...t, postEvent: this.postEvent }
+      )
+    );
+  }
+  async get(t, s = {}) {
+    const n = Array.isArray(t) ? t : [t];
+    if (!n.length)
+      return mt(n, "");
+    const r = await I(
+      "getStorageValues",
+      { keys: n },
+      this.createRequestId(),
+      { ...s, postEvent: this.postEvent }
+    ), i = f(mt(n, h()), "CloudStorageData").parse(r);
+    return Array.isArray(t) ? i : i[t];
+  }
+  /**
+   * Saves specified value by key.
+   * @param key - storage key.
+   * @param value - storage value.
+   * @param options - request execution options.
+   */
+  async set(t, s, n = {}) {
+    await I(
+      "saveStorageValue",
+      { key: t, value: s },
+      this.createRequestId(),
+      { ...n, postEvent: this.postEvent }
+    );
+  }
+}
+const es = _(
+  ({ createRequestId: e, postEvent: t, version: s }) => new ts(s, e, t)
+);
+class ss extends pt {
+  constructor(t, s) {
+    super(t, {
+      impactOccurred: "web_app_trigger_haptic_feedback",
+      notificationOccurred: "web_app_trigger_haptic_feedback",
+      selectionChanged: "web_app_trigger_haptic_feedback"
+    }), this.postEvent = s;
+  }
+  /**
+   * A method tells that an impact occurred. The Telegram app may play the
+   * appropriate haptics based on style value passed.
+   * @param style - impact style.
+   */
+  impactOccurred(t) {
+    this.postEvent("web_app_trigger_haptic_feedback", {
+      type: "impact",
+      impact_style: t
+    });
+  }
+  /**
+   * A method tells that a task or action has succeeded, failed, or produced
+   * a warning. The Telegram app may play the appropriate haptics based on
+   * type value passed.
+   * @param type - notification type.
+   */
+  notificationOccurred(t) {
+    this.postEvent("web_app_trigger_haptic_feedback", {
+      type: "notification",
+      notification_type: t
+    });
+  }
+  /**
+   * A method tells that the user has changed a selection. The Telegram app
+   * may play the appropriate haptics.
+   *
+   * Do not use this feedback when the user makes or confirms a selection;
+   * use it only when the selection changes.
+   */
+  selectionChanged() {
+    this.postEvent("web_app_trigger_haptic_feedback", { type: "selection_change" });
+  }
+}
+const ns = _(
+  ({ version: e, postEvent: t }) => new ss(e, t)
+);
+class rs {
+  constructor(t) {
+    this.initData = t;
+  }
+  /**
+   * @see InitDataParsed.authDate
+   */
+  get authDate() {
+    return this.initData.authDate;
+  }
+  /**
+   * @see InitDataParsed.canSendAfter
+   */
+  get canSendAfter() {
+    return this.initData.canSendAfter;
+  }
+  /**
+   * Date after which it is allowed to call
+   * the [answerWebAppQuery](https://core.telegram.org/bots/api#answerwebappquery) method.
+   */
+  get canSendAfterDate() {
+    const { canSendAfter: t } = this;
+    return t ? new Date(this.authDate.getTime() + t * 1e3) : void 0;
+  }
+  /**
+   * @see InitDataParsed.chat
+   */
+  get chat() {
+    return this.initData.chat;
+  }
+  /**
+   * @see InitDataParsed.chatType
+   */
+  get chatType() {
+    return this.initData.chatType;
+  }
+  /**
+   * @see InitDataParsed.chatInstance
+   */
+  get chatInstance() {
+    return this.initData.chatInstance;
+  }
+  /**
+   * @see InitDataParsed.hash
+   */
+  get hash() {
+    return this.initData.hash;
+  }
+  /**
+   * @see InitDataParsed.queryId
+   */
+  get queryId() {
+    return this.initData.queryId;
+  }
+  /**
+   * @see InitDataParsed.receiver
+   */
+  get receiver() {
+    return this.initData.receiver;
+  }
+  /**
+   * @see InitDataParsed.startParam
+   */
+  get startParam() {
+    return this.initData.startParam;
+  }
+  /**
+   * @see InitDataParsed.user
+   */
+  get user() {
+    return this.initData.user;
+  }
+}
+const is = _(
+  ({ initData: e }) => e ? new rs(e) : void 0
+);
+function fn(e) {
+  return Vt().parse(e);
+}
+class os extends V {
+  constructor(t, s, n) {
+    super({ isOpened: t }, s, { open: "web_app_open_invoice" }), this.postEvent = n;
+  }
+  set isOpened(t) {
+    this.set("isOpened", t);
+  }
+  /**
+   * True if invoice is currently opened.
+   */
+  get isOpened() {
+    return this.get("isOpened");
+  }
+  async open(t, s) {
+    if (this.isOpened)
+      throw new Error("Invoice is already opened");
+    let n;
+    if (!s)
+      n = t;
+    else {
+      const { hostname: r, pathname: i } = new URL(t, window.location.href);
+      if (r !== "t.me")
+        throw new Error(`Incorrect hostname: ${r}`);
+      const o = i.match(/^\/(\$|invoice\/)([A-Za-z0-9\-_=]+)$/);
+      if (!o)
+        throw new Error('Link pathname has incorrect format. Expected to receive "/invoice/{slug}" or "/${slug}"');
+      [, , n] = o;
+    }
+    this.isOpened = !0;
+    try {
+      return (await m({
+        method: "web_app_open_invoice",
+        event: "invoice_closed",
+        params: { slug: n },
+        postEvent: this.postEvent,
+        capture(r) {
+          return n === r.slug;
+        }
+      })).status;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const as = _(
+  ({ version: e, postEvent: t }) => new os(!1, e, t)
+);
+class cs extends ot {
+  constructor({ postEvent: t, ...s }) {
+    super(s), c(this, "postEvent"), c(this, "on", (n, r) => n === "click" ? E("main_button_pressed", r) : this.state.on(n, r)), c(this, "off", (n, r) => n === "click" ? z("main_button_pressed", r) : this.state.off(n, r)), this.postEvent = t;
+  }
+  /**
+   * Sends current local state to the Telegram application.
+   */
+  commit() {
+    this.text !== "" && this.postEvent("web_app_setup_main_button", {
+      is_visible: this.isVisible,
+      is_active: this.isEnabled,
+      is_progress_visible: this.isLoaderVisible,
+      text: this.text,
+      color: this.backgroundColor,
+      text_color: this.textColor
+    });
+  }
+  set isEnabled(t) {
+    this.setParams({ isEnabled: t });
+  }
+  /**
+   * True if the MainButton is enabled.
+   */
+  get isEnabled() {
+    return this.get("isEnabled");
+  }
+  set isLoaderVisible(t) {
+    this.setParams({ isLoaderVisible: t });
+  }
+  /**
+   * True if the MainButton loader is visible.
+   */
+  get isLoaderVisible() {
+    return this.get("isLoaderVisible");
+  }
+  set isVisible(t) {
+    this.setParams({ isVisible: t });
+  }
+  /**
+   * True if the MainButton is visible.
+   */
+  get isVisible() {
+    return this.get("isVisible");
+  }
+  /**
+   * The MainButton background color.
+   */
+  get backgroundColor() {
+    return this.get("backgroundColor");
+  }
+  /**
+   * The MainButton text.
+   */
+  get text() {
+    return this.get("text");
+  }
+  /**
+   * The MainButton text color.
+   */
+  get textColor() {
+    return this.get("textColor");
+  }
+  /**
+   * Disables the MainButton.
+   * @see Does not work on Android: https://github.com/Telegram-Mini-Apps/issues/issues/1
+   */
+  disable() {
+    return this.isEnabled = !1, this;
+  }
+  /**
+   * Enables the MainButton.
+   */
+  enable() {
+    return this.isEnabled = !0, this;
+  }
+  /**
+   * Hides the MainButton.
+   */
+  hide() {
+    return this.isVisible = !1, this;
+  }
+  /**
+   * Hides the MainButton loading indicator.
+   */
+  hideLoader() {
+    return this.isLoaderVisible = !1, this;
+  }
+  /**
+   * Shows the MainButton.
+   *
+   * Note that opening the Mini App from the attachment menu hides the main button until the
+   * user interacts with the Mini App interface.
+   */
+  show() {
+    return this.isVisible = !0, this;
+  }
+  /**
+   * Shows a loading indicator on the Main Button.
+   */
+  showLoader() {
+    return this.isLoaderVisible = !0, this;
+  }
+  /**
+   * Sets a new MainButton text. Minimal length for the text is 1 symbol, and maximum is 64 symbols.
+   * @param text - a new text.
+   */
+  setText(t) {
+    return this.setParams({ text: t });
+  }
+  /**
+   * Sets a new Main Button text color.
+   * @param textColor - new text color.
+   */
+  setTextColor(t) {
+    return this.setParams({ textColor: t });
+  }
+  /**
+   * Updates current Main Button color.
+   * @param backgroundColor - color to set.
+   */
+  setBackgroundColor(t) {
+    return this.setParams({ backgroundColor: t });
+  }
+  /**
+   * Allows setting multiple Main Button parameters.
+   * @param params - Main Button parameters.
+   */
+  setParams(t) {
+    return this.set(t), this.commit(), this;
+  }
+}
+const hs = _("mainButton", ({
+  postEvent: e,
+  themeParams: t,
+  state: s = {
+    isVisible: !1,
+    isEnabled: !1,
+    text: "",
+    isLoaderVisible: !1,
+    textColor: t.buttonTextColor || "#ffffff",
+    backgroundColor: t.buttonColor || "#000000"
+  }
+}) => new cs({ ...s, postEvent: e }));
+function ps() {
+  return ct({
+    contact: f({
+      userId: {
+        type: x(),
+        from: "user_id"
+      },
+      phoneNumber: {
+        type: h(),
+        from: "phone_number"
+      },
+      firstName: {
+        type: h(),
+        from: "first_name"
+      },
+      lastName: {
+        type: h().optional(),
+        from: "last_name"
+      }
+    }),
+    authDate: {
+      type: Dt(),
+      from: "auth_date"
+    },
+    hash: h()
+  }, "RequestedContact");
+}
+function Kt(e, t) {
+  return (s) => {
+    const [n, r] = t[s];
+    return S(n, r, e);
+  };
+}
+function us(e) {
+  return new Promise((t) => {
+    setTimeout(t, e);
+  });
+}
+class ds extends V {
+  constructor({ postEvent: t, createRequestId: s, version: n, botInline: r, ...i }) {
+    super(i, n, {
+      requestPhoneAccess: "web_app_request_phone",
+      requestWriteAccess: "web_app_request_write_access",
+      switchInlineQuery: "web_app_switch_inline_query",
+      setHeaderColor: "web_app_set_header_color",
+      setBackgroundColor: "web_app_set_background_color"
+    }), c(this, "botInline"), c(this, "postEvent"), c(this, "createRequestId"), c(this, "requestPhoneAccessPromise"), c(this, "requestWriteAccessPromise"), c(this, "supportsParam"), this.createRequestId = s, this.postEvent = t, this.botInline = r;
+    const o = this.supports.bind(this);
+    this.supports = (a) => o(a) ? a !== "switchInlineQuery" || r : !1, this.supportsParam = Kt(n, {
+      "setHeaderColor.color": ["web_app_set_header_color", "color"]
+    });
+  }
+  /**
+   * Attempts to get requested contact.
+   * @param timeout - request timeout.
+   */
+  async getRequestedContact({
+    timeout: t = 1e4
+  } = {}) {
+    return ps().parse(
+      await I(
+        "getRequestedContact",
+        {},
+        this.createRequestId(),
+        { postEvent: this.postEvent, timeout: t }
+      )
+    );
+  }
+  /**
+   * The Mini App background color.
+   * @example "#ffaabb"
+   */
+  get bgColor() {
+    return this.get("bgColor");
+  }
+  /**
+   * Closes the Mini App.
+   */
+  close() {
+    this.postEvent("web_app_close");
+  }
+  /**
+   * The Mini App header color.
+   * @example "#ffaabb"
+   * @example "bg_color"
+   */
+  get headerColor() {
+    return this.get("headerColor");
+  }
+  /**
+   * True if the Mini App is currently launched in bot inline mode.
+   */
+  get isBotInline() {
+    return this.botInline;
+  }
+  /**
+   * True if current Mini App background color is recognized as dark.
+   */
+  get isDark() {
+    return qt(this.bgColor);
+  }
+  /**
+   * Informs the Telegram app that the Mini App is ready to be displayed.
+   *
+   * It is recommended to call this method as early as possible, as soon as all essential
+   * interface elements loaded. Once this method called, the loading placeholder is hidden
+   * and the Mini App shown.
+   *
+   * If the method not called, the placeholder will be hidden only when the page fully loaded.
+   */
+  ready() {
+    this.postEvent("web_app_ready");
+  }
+  /**
+   * Requests current user contact information. In contrary to requestPhoneAccess, this method
+   * returns promise with contact information that rejects in case, user denied access, or request
+   * failed.
+   * @param options - additional options.
+   */
+  async requestContact({ timeout: t = 5e3 } = {}) {
+    try {
+      return await this.getRequestedContact();
+    } catch {
+    }
+    if (await this.requestPhoneAccess() !== "sent")
+      throw new Error("Access denied.");
+    const s = Date.now() + t;
+    let n = 50;
+    return Ot(async () => {
+      for (; Date.now() < s; ) {
+        try {
+          return await this.getRequestedContact();
+        } catch {
+        }
+        await us(n), n += 50;
+      }
+      throw It(t);
+    }, t);
+  }
+  /**
+   * Requests current user phone access. Method returns promise, which resolves
+   * status of the request. In case, user accepted the request, Mini App bot will receive
+   * the according notification.
+   *
+   * To obtain the retrieved information instead, utilize the `requestContact` method.
+   * @param options - additional options.
+   * @see requestContact
+   */
+  async requestPhoneAccess(t = {}) {
+    return this.requestPhoneAccessPromise || (this.requestPhoneAccessPromise = m({
+      ...t,
+      method: "web_app_request_phone",
+      event: "phone_requested",
+      postEvent: this.postEvent
+    }).then(({ status: s }) => s).finally(() => this.requestPhoneAccessPromise = void 0)), this.requestPhoneAccessPromise;
+  }
+  /**
+   * Requests write message access to current user.
+   * @param options - additional options.
+   */
+  async requestWriteAccess(t = {}) {
+    return this.requestWriteAccessPromise || (this.requestWriteAccessPromise = m({
+      ...t,
+      method: "web_app_request_write_access",
+      event: "write_access_requested",
+      postEvent: this.postEvent
+    }).then(({ status: s }) => s).finally(() => this.requestWriteAccessPromise = void 0)), this.requestWriteAccessPromise;
+  }
+  /**
+   * A method used to send data to the bot. When this method called, a service message sent to
+   * the bot containing the data of the length up to 4096 bytes, and the Mini App closed. See the
+   * field `web_app_data` in the class [Message](https://core.telegram.org/bots/api#message).
+   *
+   * This method is only available for Mini Apps launched via a Keyboard button.
+   * @param data - data to send to bot.
+   * @throws {Error} data has incorrect size.
+   */
+  sendData(t) {
+    const { size: s } = new Blob([t]);
+    if (!s || s > 4096)
+      throw new Error(`Passed data has incorrect size: ${s}`);
+    this.postEvent("web_app_data_send", { data: t });
+  }
+  /**
+   * Updates current Mini App header color.
+   *
+   * @see No effect on desktop: https://github.com/Telegram-Mini-Apps/tma.js/issues/9
+   * @see Works incorrectly in Android: https://github.com/Telegram-Mini-Apps/tma.js/issues/8
+   * @param color - color key or RGB color.
+   */
+  setHeaderColor(t) {
+    this.postEvent("web_app_set_header_color", it(t) ? { color: t } : { color_key: t }), this.set("headerColor", t);
+  }
+  /**
+   * Updates current Mini App background color.
+   *
+   * @see No effect on desktop: https://github.com/Telegram-Mini-Apps/tma.js/issues/9
+   * @see Works incorrectly in Android: https://github.com/Telegram-Mini-Apps/tma.js/issues/8
+   * @param color - RGB color.
+   */
+  setBgColor(t) {
+    this.postEvent("web_app_set_background_color", { color: t }), this.set("bgColor", t);
+  }
+  /**
+   * Inserts the bot's username and the specified inline query in the current chat's input field.
+   * Query may be empty, in which case only the bot's username will be inserted. The client prompts
+   * the user to choose a specific chat, then opens that chat and inserts the bot's username and
+   * the specified inline query in the input field.
+   * @param text - text which should be inserted in the input after the current bot name. Max
+   * length is 256 symbols.
+   * @param chatTypes - List of chat types which could be chosen to send the message. Could be
+   * empty list.
+   */
+  switchInlineQuery(t, s = []) {
+    if (!this.supports("switchInlineQuery") && !this.isBotInline)
+      throw new Error("Method is unsupported because Mini App should be launched in inline mode.");
+    this.postEvent("web_app_switch_inline_query", { query: t, chat_types: s });
+  }
+}
+const ls = _("miniApp", ({
+  themeParams: e,
+  botInline: t = !1,
+  state: s = {
+    bgColor: e.bgColor || "#ffffff",
+    headerColor: e.headerBgColor || "#000000"
+  },
+  ...n
+}) => new ds({ ...n, ...s, botInline: t }));
+function _s(e) {
+  const t = e.message.trim(), s = (e.title || "").trim(), n = e.buttons || [];
+  let r;
+  if (s.length > 64)
+    throw new Error(`Title has incorrect size: ${s.length}`);
+  if (!t.length || t.length > 256)
+    throw new Error(`Message has incorrect size: ${t.length}`);
+  if (n.length > 3)
+    throw new Error(`Buttons have incorrect size: ${n.length}`);
+  return n.length ? r = n.map((i) => {
+    const { id: o = "" } = i;
+    if (o.length > 64)
+      throw new Error(`Button ID has incorrect size: ${o}`);
+    if (!i.type || i.type === "default" || i.type === "destructive") {
+      const a = i.text.trim();
+      if (!a.length || a.length > 64) {
+        const p = i.type || "default";
+        throw new Error(`Button text with type "${p}" has incorrect size: ${i.text.length}`);
+      }
+      return { ...i, text: a, id: o };
+    }
+    return { ...i, id: o };
+  }) : r = [{ type: "close", id: "" }], { title: s, message: t, buttons: r };
+}
+class gs extends V {
+  constructor(t, s, n) {
+    super({ isOpened: t }, s, { open: "web_app_open_popup" }), this.postEvent = n;
+  }
+  set isOpened(t) {
+    this.set("isOpened", t);
+  }
+  /**
+   * True if the Popup is opened.
+   */
+  get isOpened() {
+    return this.get("isOpened");
+  }
+  /**
+   * A method that shows a native popup described by the `params` argument.
+   * Promise will be resolved when popup is closed. Resolved value will have
+   * an identifier of pressed button.
+   *
+   * In case, user clicked outside the popup or clicked top right popup close
+   * button, null will be returned.
+   *
+   * @param options - popup parameters.
+   * @throws {Error} Popup is already opened.
+   */
+  async open(t) {
+    if (this.isOpened)
+      throw new Error("Popup is already opened.");
+    this.isOpened = !0;
+    try {
+      const { button_id: s = null } = await m({
+        event: "popup_closed",
+        method: "web_app_open_popup",
+        postEvent: this.postEvent,
+        params: _s(t)
+      });
+      return s;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const ws = _(
+  ({ postEvent: e, version: t }) => new gs(!1, t, e)
+);
+class fs extends V {
+  constructor(t, s, n) {
+    super({ isOpened: t }, s, {
+      close: "web_app_close_scan_qr_popup",
+      open: "web_app_open_scan_qr_popup"
+    }), this.postEvent = n;
+  }
+  /**
+   * Closes scanner.
+   */
+  close() {
+    this.postEvent("web_app_close_scan_qr_popup"), this.isOpened = !1;
+  }
+  set isOpened(t) {
+    this.set("isOpened", t);
+  }
+  /**
+   * Returns true in case, QR scanner is currently opened.
+   */
+  get isOpened() {
+    return this.get("isOpened");
+  }
+  /**
+   * Opens scanner with specified title shown to user. Method returns promise
+   * with scanned QR content in case, it was scanned. It will contain null in
+   * case, scanner was closed.
+   * @param text - title to display.
+   */
+  async open(t) {
+    if (this.isOpened)
+      throw new Error("QR scanner is already opened.");
+    this.isOpened = !0;
+    try {
+      return (await m({
+        method: "web_app_open_scan_qr_popup",
+        event: ["qr_text_received", "scan_qr_popup_closed"],
+        postEvent: this.postEvent,
+        params: { text: t }
+      }) || {}).data || null;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const ms = _(
+  ({ version: e, postEvent: t }) => new fs(!1, e, t)
+);
+class bs extends at {
+  constructor(t, s, n) {
+    super({ isVisible: t }, s, {
+      show: "web_app_setup_settings_button",
+      hide: "web_app_setup_settings_button"
+    }), c(this, "on", (r, i) => r === "click" ? E("settings_button_pressed", i) : this.state.on(r, i)), c(this, "off", (r, i) => r === "click" ? z("settings_button_pressed", i) : this.state.off(r, i)), this.postEvent = n;
+  }
+  set isVisible(t) {
+    this.set("isVisible", t), this.postEvent("web_app_setup_settings_button", { is_visible: t });
+  }
+  /**
+   * True if the SettingsButton is visible.
+   */
+  get isVisible() {
+    return this.get("isVisible");
+  }
+  /**
+   * Hides the SettingsButton.
+   */
+  hide() {
+    this.isVisible = !1;
+  }
+  /**
+   * Shows the SettingsButton.
+   */
+  show() {
+    this.isVisible = !0;
+  }
+}
+const vs = _("settingsButton", ({
+  version: e,
+  postEvent: t,
+  state: s = { isVisible: !1 }
+}) => new bs(s.isVisible, e, t));
+function Jt(e) {
+  return Bt().parse(e);
+}
+class ys extends ht {
+  /**
+   * @since v6.10
+   */
+  get accentTextColor() {
+    return this.get("accentTextColor");
+  }
+  get bgColor() {
+    return this.get("bgColor");
+  }
+  get buttonColor() {
+    return this.get("buttonColor");
+  }
+  get buttonTextColor() {
+    return this.get("buttonTextColor");
+  }
+  get destructiveTextColor() {
+    return this.get("destructiveTextColor");
+  }
+  /**
+   * Returns the copy of the internal state of the current component instance.
+   */
+  getState() {
+    return this.clone();
+  }
+  /**
+   * @since v6.10
+   */
+  get headerBgColor() {
+    return this.get("headerBgColor");
+  }
+  get hintColor() {
+    return this.get("hintColor");
+  }
+  /**
+   * @returns True in case, current color scheme is recognized as dark. This
+   * value is calculated according to theme bg color.
+   */
+  get isDark() {
+    return !this.bgColor || qt(this.bgColor);
+  }
+  get linkColor() {
+    return this.get("linkColor");
+  }
+  get secondaryBgColor() {
+    return this.get("secondaryBgColor");
+  }
+  /**
+   * @since v6.10
+   */
+  get sectionBgColor() {
+    return this.get("sectionBgColor");
+  }
+  /**
+   * @since v6.10
+   */
+  get sectionHeaderTextColor() {
+    return this.get("sectionHeaderTextColor");
+  }
+  /**
+   * Starts listening to the external theme changes and applies them.
+   * @returns Function to stop listening.
+   */
+  listen() {
+    return E("theme_changed", (t) => {
+      this.set(Jt(t.theme_params));
+    });
+  }
+  /**
+   * @since v6.10
+   */
+  get subtitleTextColor() {
+    return this.get("subtitleTextColor");
+  }
+  get textColor() {
+    return this.get("textColor");
+  }
+}
+const Es = _("themeParams", ({ themeParams: e, state: t = e }) => {
+  const s = new ys(t);
+  return C() || s.listen(), s;
+});
+function mn(e = {}) {
+  return m({
+    ...e,
+    method: "web_app_request_theme",
+    event: "theme_changed"
+  }).then(Jt);
+}
+class Ps extends pt {
+  constructor(t, s, n) {
+    super(t, { readTextFromClipboard: "web_app_read_text_from_clipboard" }), c(this, "supportsParam"), this.version = t, this.createRequestId = s, this.postEvent = n, this.supportsParam = Kt(t, {
+      "openLink.tryInstantView": ["web_app_open_link", "try_instant_view"]
+    });
+  }
+  /**
+   * Opens a link in an external browser. The Mini App will not be closed.
+   *
+   * Note that this method can be called only in response to the user
+   * interaction with the Mini App interface (e.g. click inside the Mini App
+   * or on the main button).
+   * @param url - URL to be opened.
+   * @param tryInstantView
+   */
+  openLink(t, s) {
+    const n = new URL(t, window.location.href).toString();
+    if (!S("web_app_open_link", this.version)) {
+      window.open(n, "_blank");
+      return;
+    }
+    this.postEvent("web_app_open_link", {
+      url: n,
+      ...typeof s == "boolean" ? { try_instant_view: s } : {}
+    });
+  }
+  /**
+   * Opens a Telegram link inside Telegram app. The Mini App will be closed. It expects passing
+   * link in full format, with hostname "t.me".
+   * @param url - URL to be opened.
+   * @throws {Error} URL has not allowed hostname.
+   */
+  openTelegramLink(t) {
+    const { hostname: s, pathname: n, search: r } = new URL(t, window.location.href);
+    if (s !== "t.me")
+      throw new Error(`URL has not allowed hostname: ${s}. Only "t.me" is allowed`);
+    if (!S("web_app_open_tg_link", this.version)) {
+      window.location.href = t;
+      return;
+    }
+    this.postEvent("web_app_open_tg_link", { path_full: n + r });
+  }
+  /**
+   * Reads text from clipboard and returns string or null. null is returned
+   * in cases:
+   * - Value in clipboard is not text
+   * - Access to clipboard is not allowed
+   */
+  async readTextFromClipboard() {
+    const t = this.createRequestId(), {
+      data: s = null
+    } = await m({
+      method: "web_app_read_text_from_clipboard",
+      event: "clipboard_text_received",
+      postEvent: this.postEvent,
+      params: { req_id: t },
+      capture: kt(t)
+    });
+    return s;
+  }
+}
+const Rs = _(
+  ({ version: e, postEvent: t, createRequestId: s }) => new Ps(e, s, t)
+);
+async function Qt(e = {}) {
+  const {
+    is_expanded: t,
+    is_state_stable: s,
+    ...n
+  } = await m({
+    ...e,
+    method: "web_app_request_viewport",
+    event: "viewport_changed"
+  });
+  return { ...n, isExpanded: t, isStateStable: s };
+}
+function k(e) {
+  return e < 0 ? 0 : e;
+}
+class Ft extends ht {
+  constructor({ postEvent: t, stableHeight: s, height: n, width: r, isExpanded: i }) {
+    super({
+      height: k(n),
+      isExpanded: i,
+      stableHeight: k(s),
+      width: k(r)
+    }), c(this, "postEvent"), this.postEvent = t;
+  }
+  /**
+   * Requests viewport information from the Telegram application and updates current Viewport
+   * instance.
+   * @param options - options to request fresh data.
+   */
+  async sync(t) {
+    const { isStateStable: s, ...n } = await Qt(t);
+    this.set({
+      ...n,
+      stableHeight: s ? n.height : this.get("stableHeight")
+    });
+  }
+  /**
+   * The current height of the **visible area** of the Mini App.
+   *
+   * The application can display just the top part of the Mini App, with its lower part remaining
+   * outside the screen area. From this position, the user can "pull" the Mini App to its
+   * maximum height, while the bot can do the same by calling `expand` method. As the position of
+   * the Mini App changes, the current height value of the visible area will be updated  in real
+   * time.
+   *
+   * Please note that the refresh rate of this value is not sufficient to smoothly follow the
+   * lower border of the window. It should not be used to pin interface elements to the bottom
+   * of the visible area. It's more appropriate to use the value of the `stableHeight`
+   * field for this purpose.
+   *
+   * @see stableHeight
+   */
+  get height() {
+    return this.get("height");
+  }
+  /**
+   * The height of the visible area of the Mini App in its last stable state.
+   *
+   * The application can display just the top part of the Mini App, with its lower part remaining
+   * outside the screen area. From this position, the user can "pull" the Mini App to its
+   * maximum height, while the application can do the same by calling `expand` method.
+   *
+   * Unlike the value of `height`, the value of `stableHeight` does not change as the position
+   * of the Mini App changes with user gestures or during animations. The value of `stableHeight`
+   * will be updated after all gestures and animations are completed and
+   * the Mini App reaches its final size.
+   *
+   * @see height
+   */
+  get stableHeight() {
+    return this.get("stableHeight");
+  }
+  /**
+   * Starts listening to viewport changes and applies them.
+   * @returns Function to stop listening.
+   */
+  listen() {
+    return E("viewport_changed", (t) => {
+      const {
+        height: s,
+        width: n,
+        is_expanded: r,
+        is_state_stable: i
+      } = t, o = k(s);
+      this.set({
+        height: o,
+        isExpanded: r,
+        width: k(n),
+        ...i ? { stableHeight: o } : {}
+      });
+    });
+  }
+  /**
+   * True if the Mini App is expanded to the maximum available height. Otherwise, if
+   * the Mini App occupies part of the screen and can be expanded to the full height using
+   * `expand` method.
+   * @see expand
+   */
+  get isExpanded() {
+    return this.get("isExpanded");
+  }
+  /**
+   * Current visible area width.
+   */
+  get width() {
+    return this.get("width");
+  }
+  /**
+   * A method that expands the Mini App to the maximum available height. To find out if the Mini
+   * App is expanded to the maximum height, refer to the value of the `isExpanded`.
+   * @see isExpanded
+   */
+  expand() {
+    this.postEvent("web_app_expand"), this.set("isExpanded", !0);
+  }
+  /**
+   * True if the current viewport height is stable and is not going to change in the next moment.
+   */
+  get isStable() {
+    return this.stableHeight === this.height;
+  }
+}
+async function xs(e, t = {}) {
+  const {
+    height: s,
+    width: n,
+    isExpanded: r,
+    isStateStable: i
+  } = await Qt({ ...t, postEvent: e });
+  return new Ft({
+    postEvent: e,
+    height: s,
+    width: n,
+    isExpanded: r,
+    stableHeight: i ? s : 0
+  });
+}
+function Ss({
+  state: e,
+  platform: t,
+  postEvent: s
+}) {
+  let n = !1, r = 0, i = 0, o = 0;
+  return e ? (n = e.isExpanded, r = e.height, i = e.width, o = e.stableHeight) : ["macos", "tdesktop", "unigram", "webk", "weba", "web"].includes(t) && (n = !0, r = window.innerHeight, i = window.innerWidth, o = window.innerHeight), new Ft({
+    postEvent: s,
+    height: r,
+    width: i,
+    stableHeight: o,
+    isExpanded: n
+  });
+}
+const Cs = _(
+  "viewport",
+  async (e) => {
+    if (C() && !e.state)
+      throw l(
+        nt,
+        "Viewport cannot be instantiated on the server side without passing the ssr.state object."
+      );
+    let t = Ss(e);
+    return C() || (t.width === 0 && await xs(e.postEvent, { timeout: 1e3 }).then((s) => t = s).catch((s) => H.error("Unable to sync viewport state", s)), t.listen()), t;
+  }
+);
+function R(e, t) {
+  document.documentElement.style.setProperty(e, t);
+}
+function bn(e, t, s) {
+  s || (s = (a) => `--tg-${a}-color`);
+  const n = s("header"), r = s("bg"), i = () => {
+    const { headerColor: a } = e;
+    if (it(a))
+      R(n, a);
+    else {
+      const { bgColor: p, secondaryBgColor: u } = t;
+      a === "bg_color" && p ? R(n, p) : a === "secondary_bg_color" && u && R(n, u);
+    }
+    R(r, e.bgColor);
+  }, o = [
+    t.on("change", i),
+    e.on("change", i)
+  ];
+  return i(), () => o.forEach((a) => a());
+}
+function vn(e, t) {
+  t || (t = (n) => `--tg-theme-${n.replace(/[A-Z]/g, (r) => `-${r.toLowerCase()}`)}`);
+  const s = () => {
+    Object.entries(e.getState()).forEach(([n, r]) => {
+      r && R(t(n), r);
+    });
+  };
+  return s(), e.on("change", s);
+}
+function yn(e, t) {
+  t || (t = (u) => `--tg-viewport-${u}`);
+  const [
+    s,
+    n,
+    r
+  ] = ["height", "width", "stable-height"].map((u) => t(u)), i = () => R(s, `${e.height}px`), o = () => R(n, `${e.width}px`), a = () => R(r, `${e.stableHeight}px`), p = [
+    e.on("change:height", i),
+    e.on("change:width", o),
+    e.on("change:stableHeight", a)
+  ];
+  return i(), o(), a(), () => p.forEach((u) => u());
+}
+function Ts(e = !0) {
+  const t = [
+    E("reload_iframe", () => {
+      q("iframe_will_reload"), window.location.reload();
+    })
+  ], s = () => t.forEach((n) => n());
+  if (e) {
+    const n = document.createElement("style");
+    n.id = "telegram-custom-styles", document.head.appendChild(n), t.push(
+      E("set_custom_style", (r) => {
+        n.innerHTML = r;
+      }),
+      () => document.head.removeChild(n)
+    );
+  }
+  return q("iframe_ready", { reload_supported: !0 }), s;
+}
+async function En() {
+  if (Ct(window))
+    return !0;
+  try {
+    return await m({ method: "web_app_request_theme", event: "theme_changed", timeout: 100 }), !0;
+  } catch {
+    return !1;
+  }
+}
+function As(e) {
+  return e instanceof W;
+}
+function Pn(e, t) {
+  return As(e) && e.type === t;
+}
+function J(e, t) {
+  let s, n, r;
+  return typeof e == "string" ? s = e : (s = e.pathname === void 0 ? t : e.pathname, n = e.params, r = e.id), Object.freeze({
+    id: r || (Math.random() * 2 ** 14 | 0).toString(16),
+    pathname: s,
+    params: n
+  });
+}
+class ks {
+  constructor(t, s, n = q) {
+    if (c(this, "history"), c(this, "ee", new U()), c(this, "attached", !1), c(this, "back", () => this.go(-1)), c(this, "on", this.ee.on.bind(this.ee)), c(this, "off", this.ee.off.bind(this.ee)), this._index = s, this.postEvent = n, t.length === 0)
+      throw l(ge, "History should not be empty.");
+    if (s < 0 || s >= t.length)
+      throw l(
+        we,
+        "Index should not be zero and higher or equal than history size."
+      );
+    this.history = t.map((r) => J(r, ""));
+  }
+  /**
+   * Allows this navigator to control the `BackButton` visibility state. It also tracks the
+   * `BackButton` clicks and calls the `back` method.
+   */
+  attach() {
+    this.attached || (this.attached = !0, this.sync(), E("back_button_pressed", this.back));
+  }
+  /**
+   * Currently active history item.
+   */
+  get current() {
+    return this.history[this.index];
+  }
+  /**
+   * Prevents current navigator from controlling the BackButton visibility state.
+   */
+  detach() {
+    this.attached = !1, z("back_button_pressed", this.back);
+  }
+  /**
+   * Goes to the next history item.
+   */
+  forward() {
+    this.go(1);
+  }
+  /**
+   * Changes currently active history item index by the specified delta. This method doesn't
+   * change index in case, the updated index points to the non-existing history item. This behavior
+   * is preserved until the `fit` argument is specified.
+   * @param delta - index delta.
+   * @param fit - cuts the delta argument to fit the bounds `[0, history.length - 1]`.
+   */
+  go(t, s) {
+    const n = this.index + t, r = Math.min(
+      Math.max(0, n),
+      this.history.length - 1
+    );
+    (n === r || s) && this.replaceAndMove(r, this.history[r]);
+  }
+  /**
+   * Goes to the specified index. Method does nothing in case, passed index is out of bounds.
+   *
+   * If "fit" option was specified and index is out of bounds, it will be cut to the nearest
+   * bound.
+   * @param index - target index.
+   * @param fit - cuts the index argument to fit the bounds `[0, history.length - 1]`.
+   */
+  goTo(t, s) {
+    this.go(t - this.index, s);
+  }
+  /**
+   * True if navigator has items before the current item.
+   */
+  get hasPrev() {
+    return this.index > 0;
+  }
+  /**
+   * True if navigator has items after the current item.
+   */
+  get hasNext() {
+    return this.index !== this.history.length - 1;
+  }
+  /**
+   * Currently active history item index.
+   */
+  get index() {
+    return this._index;
+  }
+  /**
+   * Adds a new history item removing all after the current one.
+   * @param item - item to add.
+   */
+  push(t) {
+    this.hasNext && this.history.splice(this.index + 1), this.replaceAndMove(this.index + 1, J(t, this.current.pathname));
+  }
+  /**
+   * Replaces the current history item.
+   * @param item - item to replace the current item with.
+   */
+  replace(t) {
+    this.replaceAndMove(this.index, J(t, this.current.pathname));
+  }
+  /**
+   * Sets history item by the specified index.
+   * @param index - history item index to replace.
+   * @param historyItem - history item to set.
+   */
+  replaceAndMove(t, s) {
+    const n = t - this.index;
+    if (!n && this.current === s)
+      return;
+    const r = this.current;
+    if (this.index !== t) {
+      const i = this._index;
+      this._index = t, this.attached && i > 0 != t > 0 && this.sync();
+    }
+    this.history[t] = s, this.ee.emit("change", {
+      navigator: this,
+      from: r,
+      to: this.current,
+      delta: n
+    });
+  }
+  /**
+   * Actualizes the `BackButton` visibility state.
+   */
+  sync() {
+    this.postEvent("web_app_setup_back_button", { is_visible: !!this.index });
+  }
+}
+function Q({
+  params: e,
+  ...t
+}) {
+  return { ...e || { hash: "", search: "" }, ...t };
+}
+function N(e, t) {
+  return e.startsWith(t) ? e : `${t}${e}`;
+}
+function $(e) {
+  return new URL(
+    typeof e == "string" ? e : `${e.pathname || ""}${N(e.search || "", "?")}${N(e.hash || "", "#")}`,
+    "http://a"
+  );
+}
+function L(e) {
+  const t = typeof e == "string" ? e.startsWith("/") : !!(e.pathname && e.pathname.startsWith("/")), s = $(e);
+  return `${t ? s.pathname : s.pathname.slice(1)}${s.search}${s.hash}`;
+}
+function F(e, t, s) {
+  let n, r;
+  typeof e == "string" ? n = e : (n = L(e), s = e.state, r = e.id);
+  const { pathname: i, search: o, hash: a } = new URL(n, `http://a${N(t, "/")}`);
+  return { id: r, pathname: i, params: { hash: a, search: o, state: s } };
+}
+async function O(e) {
+  return e === 0 ? !0 : Promise.race([
+    new Promise((t) => {
+      const s = tt("popstate", () => {
+        s(), t(!0);
+      });
+      window.history.go(e);
+    }),
+    // Usually, it takes about 1ms to emit this event, but we use some buffer.
+    new Promise((t) => {
+      setTimeout(t, 50, !1);
+    })
+  ]);
+}
+async function Is() {
+  if (window.history.length <= 1 || (window.history.pushState(null, ""), await O(1 - window.history.length)))
+    return;
+  let e = await O(-1);
+  for (; e; )
+    e = await O(-1);
+}
+function Yt(e) {
+  return $(e).pathname;
+}
+const bt = 0, Y = 1, Z = 2;
+class Zt {
+  constructor(t, s, { postEvent: n, hashMode: r, base: i } = {}) {
+    c(this, "navigator"), c(this, "ee", new U()), c(this, "hashMode"), c(this, "base"), c(this, "attached", !1), c(this, "onPopState", ({ state: o }) => {
+      if (o === null)
+        return this.push(this.parsePath(window.location.href));
+      o === bt ? window.history.forward() : o === Y && this.back(), o === Z && this.forward();
+    }), c(this, "onNavigatorChange", async ({
+      to: o,
+      from: a,
+      delta: p
+    }) => {
+      this.attached && await this.syncHistory(), this.ee.emit("change", {
+        delta: p,
+        from: Q(a),
+        to: Q(o),
+        navigator: this
+      });
+    }), c(this, "on", this.ee.on.bind(this.ee)), c(this, "off", this.ee.off.bind(this.ee)), this.navigator = new ks(
+      t.map((o) => F(o, "/")),
+      s,
+      n
+    ), this.navigator.on("change", this.onNavigatorChange), this.hashMode = r, this.base = Yt(i || "");
+  }
+  /**
+   * Attaches current navigator to the browser history allowing navigator to manipulate it.
+   */
+  async attach() {
+    this.attached || (this.attached = !0, this.navigator.attach(), window.addEventListener("popstate", this.onPopState), await this.syncHistory());
+  }
+  /**
+   * Goes back in history by 1.
+   */
+  back() {
+    this.navigator.back();
+  }
+  /**
+   * Detaches current navigator from the browser history.
+   */
+  detach() {
+    this.attached = !1, this.navigator.detach(), window.removeEventListener("popstate", this.onPopState);
+  }
+  /**
+   * Goes forward in history.
+   */
+  forward() {
+    return this.navigator.forward();
+  }
+  /**
+   * Current history cursor.
+   */
+  get index() {
+    return this.navigator.index;
+  }
+  /**
+   * Current history item identifier.
+   */
+  get id() {
+    return this.navigator.current.id;
+  }
+  /**
+   * Changes currently active history item index by the specified delta. This method doesn't
+   * change index in case, the updated index points to the non-existing history item. This behavior
+   * is preserved until the `fit` argument is specified.
+   * @param delta - index delta.
+   * @param fit - cuts the delta argument to fit the bounds `[0, history.length - 1]`.
+   */
+  go(t, s) {
+    return this.navigator.go(t, s);
+  }
+  /**
+   * Goes to the specified index. Method does nothing in case, passed index is out of bounds.
+   *
+   * If "fit" option was specified and index is out of bounds, it will be cut to the nearest
+   * bound.
+   * @param index - target index.
+   * @param fit - cuts the index argument to fit the bounds `[0, history.length - 1]`.
+   */
+  goTo(t, s) {
+    this.navigator.goTo(t, s);
+  }
+  /**
+   * Current history item hash.
+   * @see URL.hash
+   * @example
+   * "", "#my-hash"
+   */
+  get hash() {
+    return (this.navigator.current.params || {}).hash || "";
+  }
+  /**
+   * True if navigator has items before the current item.
+   */
+  get hasPrev() {
+    return this.navigator.hasPrev;
+  }
+  /**
+   * True if navigator has items after the current item.
+   */
+  get hasNext() {
+    return this.navigator.hasNext;
+  }
+  /**
+   * Navigation history.
+   */
+  get history() {
+    return this.navigator.history.map(Q);
+  }
+  /**
+   * Path, including pathname, search and hash.
+   * @example Pathname only.
+   * "/pathname"
+   * @example Pathname + search.
+   * "/pathname?search"
+   * @example Pathname + hash.
+   * "/pathname#hash"
+   * @example Pathname + search + hash.
+   * "/pathname?search#hash"
+   */
+  get path() {
+    return L(this);
+  }
+  /**
+   * Current pathname. Always starts with the slash.
+   * @see URL.pathname
+   * @example
+   * "/", "/abc"
+   */
+  get pathname() {
+    return this.navigator.current.pathname;
+  }
+  /**
+   * Depending on the current navigation type, parses incoming path and returns it presented as
+   * an object. In other words, this method parses the passed path and returns object, describing
+   * how the navigator "sees" it.
+   *
+   * @example Hash mode is omitted.
+   * parsePath('/abc?a=1#hash');
+   * // { pathname: '/abc', search: '?a=1', hash: '#hash' }
+   * parsePath('http://example.com/abc?a=1#hash');
+   * // { pathname: '/abc', search: '?a=1', hash: '#hash' }
+   *
+   * @example Hash mode is enabled.
+   * parsePath('/abc?a=1#tma?is=cool#yeah');
+   * // { pathname: '/tma', search: '?is=cool', hash: '#yeah' }
+   * parsePath('http://example.com/abc?a=1#tma?is=cool#yeah');
+   * // { pathname: '/tma', search: '?is=cool', hash: '#yeah' }
+   */
+  parsePath(t) {
+    let s = $(t);
+    return this.hashMode && (s = $(s.hash.slice(1))), {
+      pathname: s.pathname,
+      search: s.search,
+      hash: s.hash
+    };
+  }
+  push(t, s) {
+    const n = F(t, this.path), { state: r = s } = n.params;
+    this.navigator.push({ ...n, params: { ...n.params, state: r } });
+  }
+  replace(t, s) {
+    const n = F(t, this.path), { state: r = s } = n.params;
+    this.navigator.replace({ ...n, params: { ...n.params, state: r } });
+  }
+  /**
+   * Combines the navigator `base` property with the passed path data applying the navigator
+   * navigation mode.
+   * @param value - path presented as string or URLLike.
+   */
+  renderPath(t) {
+    const s = (this.base.length === 1 ? "" : this.base) + N(L(t), "/");
+    return this.hashMode ? N(s.slice(1), this.hashMode === "default" ? "#" : "#/") : s;
+  }
+  /**
+   * Synchronizes current navigator state with browser history.
+   */
+  async syncHistory() {
+    window.removeEventListener("popstate", this.onPopState);
+    const { state: t } = this, s = this.renderPath(this);
+    await Is(), this.hasPrev && this.hasNext ? (window.history.replaceState(Y, ""), window.history.pushState(t, "", s), window.history.pushState(Z, ""), await O(-1)) : this.hasPrev ? (window.history.replaceState(Y, ""), window.history.pushState(t, "", s)) : this.hasNext ? (window.history.replaceState(t, s), window.history.pushState(Z, ""), await O(-1)) : (window.history.replaceState(bt, ""), window.history.pushState(t, "", s)), window.addEventListener("popstate", this.onPopState);
+  }
+  /**
+   * Current query parameters.
+   * @see URL.search
+   * @example
+   * "", "?", "?a=1"
+   */
+  get search() {
+    return (this.navigator.current.params || {}).search || "";
+  }
+  /**
+   * Current history item state.
+   */
+  get state() {
+    return (this.navigator.current.params || {}).state;
+  }
+}
+function Os(e) {
+  e || (e = {});
+  const { href: t, hash: s } = window.location;
+  let n = L(
+    e.hashMode ? s.includes("?") ? s.slice(1) : `?${s.slice(1)}` : t
+  );
+  const r = e.base ? Yt(e.base) : void 0;
+  if (r) {
+    if (!n.startsWith(r))
+      throw l(
+        me,
+        `Path "${n}" expected to be starting with "${r}"`
+      );
+    n = n.slice(r.length);
+  }
+  return new Zt([n], 0, e);
+}
+function Rn(e) {
+  const t = e.match(/#(.+)/);
+  return t ? t[1] : null;
+}
+function qs(e, t) {
+  if (Gt()) {
+    const s = sessionStorage.getItem(e);
+    if (s)
+      try {
+        const { index: n, history: r } = JSON.parse(s);
+        return new Zt(r, n, t);
+      } catch (n) {
+        console.error("Unable to restore hash navigator state.", n);
+      }
+  }
+  return Os(t);
+}
+function xn(e, t) {
+  const s = qs(e, t), n = () => sessionStorage.setItem(e, JSON.stringify({
+    index: s.index,
+    history: s.history
+  }));
+  return s.on("change", n), n(), s;
+}
+function g(e, t) {
+  function s(n) {
+    return (r, i, o) => (a) => {
+      const p = a[i] || [], u = { ...a, [r]: n(...p) };
+      return /* @__PURE__ */ vt(o, { ...u });
+    };
+  }
+  return [s(e), s(t)];
+}
+const Xt = te(void 0);
+function Ns() {
+  const e = ee(Xt);
+  if (!e)
+    throw new Error("useSDK was used outside the SDKProvider.");
+  return e;
+}
+function w(e) {
+  const t = (...n) => {
+    const r = Ns();
+    return st(() => r.use(e, ...n), [r]);
+  };
+  return [t, (...n) => {
+    const r = t(...n);
+    if ("error" in r)
+      throw r.error;
+    return r.result;
+  }];
+}
+const [Ds, Vs] = w(ze), [Sn, Cn] = g(
+  Ds,
+  Vs
+), [Bs, Ms] = w(Je), [Tn, An] = g(
+  Bs,
+  Ms
+), [$s, Ls] = w(Fe), [kn, In] = g(
+  $s,
+  Ls
+), [Hs, Us] = w(es), [On, qn] = g(
+  Hs,
+  Us
+), [Ws, js] = w(ns), [Nn, Dn] = g(
+  Ws,
+  js
+), [Gs, zs] = w(is), [Vn, Bn] = g(Gs, zs), [Ks, Js] = w(as), [Mn, $n] = g(Ks, Js), [Qs, Fs] = w(hs), [Ln, Hn] = g(Qs, Fs), [Ys, Zs] = w(ls), [Un, Wn] = g(Ys, Zs), [Xs, tn] = w(ws), [jn, Gn] = g(Xs, tn), [en, sn] = w(ms), [zn, Kn] = g(en, sn), [nn, rn] = w(vs), [Jn, Qn] = g(
+  nn,
+  rn
+), [on, an] = w(Es), [Fn, Yn] = g(on, an);
+function Zn() {
+  return st(jt, []);
+}
+const [cn, hn] = w(Rs), [Xn, tr] = g(cn, hn), [pn, un] = w(Cs), [er, sr] = g(pn, un);
+function nr({ children: e, acceptCustomStyles: t, debug: s }) {
+  const n = lt(!0), [r, i] = se(
+    () => /* @__PURE__ */ new Map()
+  ), o = _t((d) => {
+    n.current && i((B) => (d && d(B), new Map(B)));
+  }, []), a = _t(() => o(), [o]), p = lt([]), u = st(() => ({
+    use(d, ...B) {
+      const ut = r.get(d);
+      if (ut)
+        return ut;
+      let b;
+      try {
+        b = { result: d(...B) };
+      } catch (v) {
+        b = { error: v };
+      }
+      if ("error" in b || !b.result)
+        return r.set(d, b), b;
+      const dt = (v) => ("on" in v && (v.on("change", a), p.current.push(v)), { result: v });
+      return b.result instanceof Promise ? (b.result.then(
+        (v) => o((K) => K.set(d, dt(v))),
+        (v) => o((K) => K.set(d, { error: v }))
+      ), r.set(d, {}), {}) : (r.set(d, b = dt(b.result)), b);
+    }
+  }), [r]);
+  return M(() => {
+    ae(s || !1);
+  }, [s]), M(() => () => {
+    n.current = !1;
+  }, []), M(() => {
+    if (Tt())
+      return Ts(t);
+  }, [t]), M(() => () => p.current.forEach((d) => d.off("change", a)), [a]), /* @__PURE__ */ vt(Xt.Provider, { value: u, children: e });
+}
+export {
+  Ne as BackButton,
+  ks as BasicNavigator,
+  ft as BiometryManager,
+  Zt as BrowserNavigator,
+  Qe as ClosingBehavior,
+  ts as CloudStorage,
+  me as ERR_INVALID_PATH_BASE,
+  de as ERR_INVOKE_CUSTOM_METHOD_RESPONSE,
+  pe as ERR_METHOD_PARAMETER_UNSUPPORTED,
+  he as ERR_METHOD_UNSUPPORTED,
+  ge as ERR_NAVIGATION_HISTORY_EMPTY,
+  we as ERR_NAVIGATION_INDEX_INVALID,
+  _n as ERR_NAVIGATION_ITEM_INVALID,
+  Pt as ERR_PARSE,
+  nt as ERR_SSR_INIT,
+  fe as ERR_SSR_POST_EVENT,
+  le as ERR_TIMED_OUT,
+  _e as ERR_UNEXPECTED_TYPE,
+  ue as ERR_UNKNOWN_ENV,
+  U as EventEmitter,
+  ss as HapticFeedback,
+  rs as InitData,
+  os as Invoice,
+  cs as MainButton,
+  ds as MiniApp,
+  gs as Popup,
+  fs as QRScanner,
+  W as SDKError,
+  nr as SDKProvider,
+  bs as SettingsButton,
+  ys as ThemeParams,
+  Ps as Utils,
+  Ft as Viewport,
+  Xe as array,
+  bn as bindMiniAppCSSVars,
+  vn as bindThemeParamsCSSVars,
+  yn as bindViewportCSSVars,
+  P as boolean,
+  kt as captureSameReq,
+  et as classNames,
+  Ae as compareVersions,
+  Os as createBrowserNavigatorFromLocation,
+  Oe as createPostEvent,
+  $ as createSafeURL,
+  Dt as date,
+  Rn as getHash,
+  Yt as getPathname,
+  ze as initBackButton,
+  Je as initBiometryManager,
+  Fe as initClosingBehavior,
+  es as initCloudStorage,
+  ns as initHapticFeedback,
+  is as initInitData,
+  as as initInvoice,
+  hs as initMainButton,
+  ls as initMiniApp,
+  xn as initNavigator,
+  ws as initPopup,
+  ms as initQRScanner,
+  vs as initSettingsButton,
+  Es as initThemeParams,
+  Rs as initUtils,
+  Cs as initViewport,
+  Ts as initWeb,
+  I as invokeCustomMethod,
+  qt as isColorDark,
+  Tt as isIframe,
+  Gt as isPageReload,
+  it as isRGB,
+  be as isRGBShort,
+  As as isSDKError,
+  Pn as isSDKErrorOfType,
+  C as isSSR,
+  En as isTMA,
+  f as json,
+  wn as mergeClassNames,
+  x as number,
+  z as off,
+  E as on,
+  fn as parseInitData,
+  Mt as parseLaunchParams,
+  Jt as parseThemeParams,
+  q as postEvent,
+  m as request,
+  Ke as requestBiometryInfo,
+  mn as requestThemeParams,
+  Qt as requestViewport,
+  jt as retrieveLaunchParams,
+  St as rgb,
+  ct as searchParams,
+  Ue as serializeLaunchParams,
+  He as serializeThemeParams,
+  R as setCSSVar,
+  ae as setDebug,
+  gn as setTargetOrigin,
+  h as string,
+  ie as subscribe,
+  S as supports,
+  Ie as targetOrigin,
+  xt as toRGB,
+  Et as unsubscribe,
+  L as urlToPath,
+  Vs as useBackButton,
+  Ds as useBackButtonRaw,
+  Ms as useBiometryManager,
+  Bs as useBiometryManagerRaw,
+  Ls as useClosingBehavior,
+  $s as useClosingBehaviorRaw,
+  Us as useCloudStorage,
+  Hs as useCloudStorageRaw,
+  js as useHapticFeedback,
+  Ws as useHapticFeedbackRaw,
+  zs as useInitData,
+  Gs as useInitDataRaw,
+  Js as useInvoice,
+  Ks as useInvoiceRaw,
+  Zn as useLaunchParams,
+  Fs as useMainButton,
+  Qs as useMainButtonRaw,
+  Zs as useMiniApp,
+  Ys as useMiniAppRaw,
+  tn as usePopup,
+  Xs as usePopupRaw,
+  sn as useQRScanner,
+  en as useQRScannerRaw,
+  Ns as useSDK,
+  rn as useSettingsButton,
+  nn as useSettingsButtonRaw,
+  an as useThemeParams,
+  on as useThemeParamsRaw,
+  hn as useUtils,
+  cn as useUtilsRaw,
+  un as useViewport,
+  pn as useViewportRaw,
+  Cn as withBackButton,
+  Sn as withBackButtonRaw,
+  An as withBiometryManager,
+  Tn as withBiometryManagerRaw,
+  In as withClosingBehavior,
+  kn as withClosingBehaviorRaw,
+  qn as withCloudStorage,
+  On as withCloudStorageRaw,
+  Dn as withHapticFeedback,
+  Nn as withHapticFeedbackRaw,
+  Bn as withInitData,
+  Vn as withInitDataRaw,
+  $n as withInvoice,
+  Mn as withInvoiceRaw,
+  Hn as withMainButton,
+  Ln as withMainButtonRaw,
+  Wn as withMiniApp,
+  Un as withMiniAppRaw,
+  Gn as withPopup,
+  jn as withPopupRaw,
+  Kn as withQRScanner,
+  zn as withQRScannerRaw,
+  Qn as withSettingsButton,
+  Jn as withSettingsButtonRaw,
+  Yn as withThemeParams,
+  Fn as withThemeParamsRaw,
+  Ot as withTimeout,
+  tr as withUtils,
+  Xn as withUtilsRaw,
+  sr as withViewport,
+  er as withViewportRaw
+};
+//# sourceMappingURL=index.js.map