@tma.js/sdk-solid 2.0.3 → 2.1.0

package/dist/index.js

@@ -0,0 +1,2939 @@
+import { createComponent as mt, mergeProps as ht, createContext as Qt, useContext as Ft, createEffect as pt, onCleanup as Yt, createResource as Zt, createMemo as ut, from as Xt } from "solid-js";
+var te = Object.defineProperty, ee = (e, t, s) => t in e ? te(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, c = (e, t, s) => (ee(e, typeof t != "symbol" ? t + "" : t, s), s);
+function wt(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 bt(e) {
+  const t = W(), { count: s } = t;
+  t.unsubscribe(e), s && !t.count && Se();
+}
+function se(e) {
+  return W().subscribe(e), () => bt(e);
+}
+class ne {
+  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 $ = new ne("SDK", {
+  bgColor: "forestgreen",
+  textColor: "white"
+});
+let Y = !1;
+const dt = ({ event: e, args: [t] }) => {
+  $.log("Event received:", t === void 0 ? { name: e } : { name: e, data: t });
+};
+function re(e) {
+  Y !== e && (Y = e, e ? se(dt) : bt(dt));
+}
+function ie(...e) {
+  Y && $.log(...e);
+}
+class L {
+  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 Z(e, t, s) {
+  return window.addEventListener(e, t, s), () => window.removeEventListener(e, t, s);
+}
+class U extends Error {
+  constructor(t, s, n) {
+    super(s, { cause: n }), this.type = t, Object.setPrototypeOf(this, U.prototype);
+  }
+}
+function d(e, t, s) {
+  return new U(e, t, s);
+}
+const oe = "ERR_METHOD_UNSUPPORTED", ae = "ERR_METHOD_PARAMETER_UNSUPPORTED", ce = "ERR_UNKNOWN_ENV", he = "ERR_INVOKE_CUSTOM_METHOD_RESPONSE", pe = "ERR_TIMED_OUT", ue = "ERR_UNEXPECTED_TYPE", vt = "ERR_PARSE", de = "ERR_NAVIGATION_LIST_EMPTY", le = "ERR_NAVIGATION_CURSOR_INVALID", Fs = "ERR_NAVIGATION_ITEM_INVALID", tt = "ERR_SSR_INIT", _e = "ERR_SSR_POST_EVENT", ge = "ERR_INVALID_PATH_BASE";
+function C() {
+  return d(ue, "Value has unexpected type");
+}
+class H {
+  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 d(
+          vt,
+          `Unable to parse value${this.type ? ` as ${this.type}` : ""}`,
+          s
+        );
+      }
+  }
+  optional() {
+    return this.isOptional = !0, this;
+  }
+}
+function R(e, t) {
+  return () => new H(e, !1, t);
+}
+const v = R((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 C();
+}, "boolean");
+function yt(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 d(vt, `Unable to parse field "${n}"`, a);
+    }
+  }
+  return s;
+}
+function et(e) {
+  let t = e;
+  if (typeof t == "string" && (t = JSON.parse(t)), typeof t != "object" || t === null || Array.isArray(t))
+    throw C();
+  return t;
+}
+function f(e, t) {
+  return new H((s) => {
+    const n = et(s);
+    return yt(e, (r) => n[r]);
+  }, !1, t);
+}
+const E = R((e) => {
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "string") {
+    const t = Number(e);
+    if (!Number.isNaN(t))
+      return t;
+  }
+  throw C();
+}, "number");
+function st(e) {
+  return /^#[\da-f]{6}$/i.test(e);
+}
+function fe(e) {
+  return /^#[\da-f]{3}$/i.test(e);
+}
+function Et(e) {
+  const t = e.replace(/\s/g, "").toLowerCase();
+  if (st(t))
+    return t;
+  if (fe(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 p = R((e) => {
+  if (typeof e == "string" || typeof e == "number")
+    return e.toString();
+  throw C();
+}, "string"), Pt = R((e) => Et(p().parse(e)), "rgb");
+function me(e) {
+  return f({
+    eventType: p(),
+    eventData: (t) => t
+  }).parse(e);
+}
+function we() {
+  ["TelegramGameProxy_receiveEvent", "TelegramGameProxy", "Telegram"].forEach((e) => {
+    delete window[e];
+  });
+}
+function be(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 ve() {
+  [
+    ["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] = be;
+        return;
+      }
+      s in t || (t[s] = {}), t = t[s];
+    });
+  });
+}
+const ye = f({
+  button_id: (e) => e == null ? void 0 : p().parse(e)
+}), Ee = {
+  clipboard_text_received: f({
+    req_id: p(),
+    data: (e) => e === null ? e : p().optional().parse(e)
+  }),
+  custom_method_invoked: f({
+    req_id: p(),
+    result: (e) => e,
+    error: p().optional()
+  }),
+  invoice_closed: f({
+    slug: p(),
+    status: p()
+  }),
+  phone_requested: f({
+    status: p()
+  }),
+  popup_closed: {
+    parse: (e) => ye.parse(e ?? {})
+  },
+  qr_text_received: f({
+    data: p().optional()
+  }),
+  theme_changed: f({
+    theme_params: (e) => {
+      const t = Pt().optional();
+      return Object.entries(et(e)).reduce((s, [n, r]) => (s[n] = t.parse(r), s), {});
+    }
+  }),
+  viewport_changed: f({
+    height: E(),
+    width: (e) => e == null ? window.innerWidth : E().parse(e),
+    is_state_stable: v(),
+    is_expanded: v()
+  }),
+  write_access_requested: f({
+    status: p()
+  })
+};
+function Pe() {
+  const e = new L();
+  ve();
+  let t = [
+    // Don't forget to remove created handlers.
+    we,
+    // 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
+    Z("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.
+    Z("message", (s) => {
+      if (s.source !== window.parent)
+        return;
+      let n;
+      try {
+        n = me(s.data);
+      } catch {
+        return;
+      }
+      const { eventType: r, eventData: i } = n, o = Ee[r];
+      try {
+        const a = o ? o.parse(i) : i;
+        e.emit(...a ? [r, a] : [r]);
+      } catch (a) {
+        $.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 [xe, Se] = wt(
+  (e) => {
+    const [t, s] = Pe(), 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 W() {
+  return xe()[0];
+}
+function j(e, t) {
+  W().off(e, t);
+}
+function b(e, t, s) {
+  return W().on(e, t, s);
+}
+function q(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function Ce(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 w(e, t) {
+  return Ce(e, t) <= 0;
+}
+function x(e, t, s) {
+  if (typeof s == "string") {
+    if (e === "web_app_open_link" && t === "try_instant_view")
+      return w("6.4", s);
+    if (e === "web_app_set_header_color" && t === "color")
+      return w("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 w("6.1", t);
+    case "web_app_open_popup":
+      return w("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 w("6.4", t);
+    case "web_app_switch_inline_query":
+      return w("6.7", t);
+    case "web_app_invoke_custom_method":
+    case "web_app_request_write_access":
+    case "web_app_request_phone":
+      return w("6.9", t);
+    case "web_app_setup_settings_button":
+      return w("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 w("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 Re(e) {
+  return "external" in e && q(e.external) && "notify" in e.external && typeof e.external.notify == "function";
+}
+function Te(e) {
+  return "TelegramWebviewProxy" in e && q(e.TelegramWebviewProxy) && "postEvent" in e.TelegramWebviewProxy && typeof e.TelegramWebviewProxy.postEvent == "function";
+}
+function xt() {
+  try {
+    return window.self !== window.top;
+  } catch {
+    return !0;
+  }
+}
+let St = "https://web.telegram.org";
+function Ys(e) {
+  St = e;
+}
+function Ae() {
+  return St;
+}
+function k(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 = Ae() } = n;
+  if (ie("Posting event:", r ? { event: e, data: r } : { event: e }), xt()) {
+    window.parent.postMessage(JSON.stringify({ eventType: e, eventData: r }), i);
+    return;
+  }
+  if (Re(window)) {
+    window.external.notify(JSON.stringify({ eventType: e, eventData: r }));
+    return;
+  }
+  if (Te(window)) {
+    window.TelegramWebviewProxy.postEvent(e, JSON.stringify(r));
+    return;
+  }
+  throw d(
+    ce,
+    "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 Ie(e) {
+  return (t, s) => {
+    if (!x(t, e))
+      throw d(oe, `Method "${t}" is unsupported in Mini Apps version ${e}`);
+    if (q(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 && !x(t, n, e))
+        throw d(
+          ae,
+          `Parameter "${n}" of "${t}" method is unsupported in Mini Apps version ${e}`
+        );
+    }
+    return k(t, s);
+  };
+}
+function Ct(e) {
+  return ({ req_id: t }) => t === e;
+}
+function Rt(e) {
+  return d(pe, `Timeout reached: ${e}ms`);
+}
+function Tt(e, t) {
+  return Promise.race([
+    typeof e == "function" ? e() : e,
+    new Promise((s, n) => {
+      setTimeout(() => {
+        n(Rt(t));
+      }, t);
+    })
+  ]);
+}
+async function m(e) {
+  let t;
+  const s = new Promise((u) => {
+    t = u;
+  }), {
+    method: n,
+    event: r,
+    capture: i,
+    postEvent: o = k,
+    timeout: a
+  } = e, h = (Array.isArray(r) ? r : [r]).map(
+    (u) => b(u, (D) => (!i || i(D)) && t(D))
+  );
+  try {
+    return o(n, e.params), await (a ? Tt(s, a) : s);
+  } finally {
+    h.forEach((u) => u());
+  }
+}
+async function A(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: Ct(s)
+  });
+  if (i)
+    throw d(he, i);
+  return r;
+}
+function X(...e) {
+  return e.map((t) => {
+    if (typeof t == "string")
+      return t;
+    if (q(t))
+      return X(Object.entries(t).map((s) => s[1] && s[0]));
+    if (Array.isArray(t))
+      return X(...t);
+  }).filter(Boolean).join(" ");
+}
+function Zs(...e) {
+  return e.reduce((t, s) => (q(s) && Object.entries(s).forEach(([n, r]) => {
+    const i = X(t[n], r);
+    i.length && (t[n] = i);
+  }), t), {});
+}
+function At(e) {
+  const t = Et(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 ke {
+  constructor(t) {
+    c(this, "ee", new L()), 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 nt {
+  constructor(t) {
+    c(this, "state"), c(this, "get"), c(this, "set"), c(this, "clone"), this.state = new ke(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 It(e, t) {
+  return (s) => x(t[s], e);
+}
+class rt extends nt {
+  constructor(t, s, n) {
+    super(t), c(this, "supports"), this.supports = It(s, n);
+  }
+}
+class Oe extends rt {
+  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" ? b("back_button_pressed", i) : this.state.on(r, i)), c(this, "off", (r, i) => r === "click" ? j("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 S() {
+  return typeof window > "u";
+}
+const kt = R((e) => e instanceof Date ? e : new Date(E().parse(e) * 1e3), "Date");
+function it(e, t) {
+  return new H((s) => {
+    if (typeof s != "string" && !(s instanceof URLSearchParams))
+      throw C();
+    const n = typeof s == "string" ? new URLSearchParams(s) : s;
+    return yt(e, (r) => {
+      const i = n.get(r);
+      return i === null ? void 0 : i;
+    });
+  }, !1, t);
+}
+const qe = f({
+  id: E(),
+  type: p(),
+  title: p(),
+  photoUrl: {
+    type: p().optional(),
+    from: "photo_url"
+  },
+  username: p().optional()
+}, "Chat").optional(), lt = f({
+  addedToAttachmentMenu: {
+    type: v().optional(),
+    from: "added_to_attachment_menu"
+  },
+  allowsWriteToPm: {
+    type: v().optional(),
+    from: "allows_write_to_pm"
+  },
+  firstName: {
+    type: p(),
+    from: "first_name"
+  },
+  id: E(),
+  isBot: {
+    type: v().optional(),
+    from: "is_bot"
+  },
+  isPremium: {
+    type: v().optional(),
+    from: "is_premium"
+  },
+  languageCode: {
+    type: p().optional(),
+    from: "language_code"
+  },
+  lastName: {
+    type: p().optional(),
+    from: "last_name"
+  },
+  photoUrl: {
+    type: p().optional(),
+    from: "photo_url"
+  },
+  username: p().optional()
+}, "User").optional();
+function Ot() {
+  return it({
+    authDate: {
+      type: kt(),
+      from: "auth_date"
+    },
+    canSendAfter: {
+      type: E().optional(),
+      from: "can_send_after"
+    },
+    chat: qe,
+    chatInstance: {
+      type: p().optional(),
+      from: "chat_instance"
+    },
+    chatType: {
+      type: p().optional(),
+      from: "chat_type"
+    },
+    hash: p(),
+    queryId: {
+      type: p().optional(),
+      from: "query_id"
+    },
+    receiver: lt,
+    startParam: {
+      type: p().optional(),
+      from: "start_param"
+    },
+    user: lt
+  }, "InitData");
+}
+function Ne(e) {
+  return e.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
+}
+function De(e) {
+  return e.replace(/[A-Z]/g, (t) => `_${t.toLowerCase()}`);
+}
+const qt = R(
+  (e) => {
+    const t = Pt().optional();
+    return Object.entries(et(e)).reduce((s, [n, r]) => (s[Ne(n)] = t.parse(r), s), {});
+  },
+  "ThemeParams"
+);
+function Nt(e) {
+  return it({
+    botInline: {
+      type: v().optional(),
+      from: "tgWebAppBotInline"
+    },
+    initData: {
+      type: Ot().optional(),
+      from: "tgWebAppData"
+    },
+    initDataRaw: {
+      type: p().optional(),
+      from: "tgWebAppData"
+    },
+    platform: {
+      type: p(),
+      from: "tgWebAppPlatform"
+    },
+    showSettings: {
+      type: v().optional(),
+      from: "tgWebAppShowSettings"
+    },
+    startParam: {
+      type: p().optional(),
+      from: "tgWebAppStartParam"
+    },
+    themeParams: {
+      type: qt(),
+      from: "tgWebAppThemeParams"
+    },
+    version: {
+      type: p(),
+      from: "tgWebAppVersion"
+    }
+  }).parse(e);
+}
+function Dt(e) {
+  return Nt(
+    e.replace(/^[^?#]*[?#]/, "").replace(/[?#]/g, "&")
+  );
+}
+function Ve() {
+  return Dt(window.location.href);
+}
+function Vt() {
+  return performance.getEntriesByType("navigation")[0];
+}
+function Me() {
+  const e = Vt();
+  if (!e)
+    throw new Error("Unable to get first navigation entry.");
+  return Dt(e.name);
+}
+function Mt(e) {
+  return `tma.js/${e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`)}`;
+}
+function Bt(e, t) {
+  sessionStorage.setItem(Mt(e), JSON.stringify(t));
+}
+function $t(e) {
+  const t = sessionStorage.getItem(Mt(e));
+  try {
+    return t ? JSON.parse(t) : void 0;
+  } catch {
+  }
+}
+function Be() {
+  return Nt($t("launchParams") || "");
+}
+function $e(e) {
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries(e).map(([t, s]) => [De(t), s])
+    )
+  );
+}
+function Le(e) {
+  const {
+    initDataRaw: t,
+    themeParams: s,
+    platform: n,
+    version: r,
+    showSettings: i,
+    startParam: o,
+    botInline: a
+  } = e, h = new URLSearchParams();
+  return h.set("tgWebAppPlatform", n), h.set("tgWebAppThemeParams", $e(s)), h.set("tgWebAppVersion", r), t && h.set("tgWebAppData", t), o && h.set("tgWebAppStartParam", o), typeof i == "boolean" && h.set("tgWebAppShowSettings", i ? "1" : "0"), typeof a == "boolean" && h.set("tgWebAppBotInline", a ? "1" : "0"), h.toString();
+}
+function Ue(e) {
+  Bt("launchParams", Le(e));
+}
+function He() {
+  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.
+    Ve,
+    // Then, try using the lower level API - window.performance.
+    Me,
+    // Finally, try to extract launch parameters from the session storage.
+    Be
+  ])
+    try {
+      const t = e();
+      return Ue(t), t;
+    } catch {
+    }
+  throw new Error("Unable to retrieve launch parameters from any known source.");
+}
+function Lt() {
+  const e = Vt();
+  return !!(e && e.type === "reload");
+}
+function We() {
+  let e = 0;
+  return () => (e += 1).toString();
+}
+const [je] = wt(We);
+function l(e, t) {
+  return ({ ssr: s } = {}) => {
+    let n;
+    if (S()) {
+      if (!s)
+        throw d(
+          tt,
+          "ssr.options must be specified to initialize component on the server side"
+        );
+      n = s;
+    } else
+      n = He();
+    const r = {
+      ...n,
+      postEvent: "version" in n ? Ie(n.version) : () => {
+        throw d(
+          _e,
+          "postEvent function is forbidden to be called on the server side."
+        );
+      },
+      createRequestId: je()
+    };
+    if (S() || typeof e == "function")
+      return typeof e == "function" ? e(r) : t(r);
+    const i = t({
+      ...r,
+      state: Lt() ? $t(e) : void 0
+    }), o = (a) => (a.on("change", (h) => {
+      Bt(e, h);
+    }), a);
+    return i instanceof Promise ? i.then(o) : o(i);
+  };
+}
+const Ge = l("backButton", ({
+  postEvent: e,
+  version: t,
+  state: s = { isVisible: !1 }
+}) => new Oe(s.isVisible, t, e));
+class N extends rt {
+  constructor() {
+    super(...arguments), c(this, "on", this.state.on.bind(this.state)), c(this, "off", this.state.off.bind(this.state));
+  }
+}
+function Ut(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 _t extends N {
+  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 = Ut(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 ze(e) {
+  return Ut(
+    await m({
+      ...e || {},
+      method: "web_app_biometry_get_info",
+      event: "biometry_info_received"
+    })
+  );
+}
+const Ke = l("biometryManager", async ({ postEvent: e, version: t, state: s }) => {
+  if (s)
+    return new _t({ ...s, version: t, postEvent: e });
+  if (S())
+    throw d(
+      tt,
+      "BiometryManager cannot be instantiated on the server side without passing the ssr.state object."
+    );
+  return new _t({
+    ...await ze({ timeout: 1e3 }),
+    version: t,
+    postEvent: e
+  });
+});
+class ot extends nt {
+  constructor() {
+    super(...arguments), c(this, "on", this.state.on.bind(this.state)), c(this, "off", this.state.off.bind(this.state));
+  }
+}
+class Je extends ot {
+  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 Qe = l("closingBehavior", ({
+  postEvent: e,
+  state: t = { isConfirmationNeeded: !1 }
+}) => new Je(t.isConfirmationNeeded, e));
+class at {
+  constructor(t, s) {
+    c(this, "supports"), this.supports = It(t, s);
+  }
+}
+function Fe(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 C();
+}
+class Ye extends H {
+  constructor(t, s, n) {
+    super(Fe, 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 Ze(e) {
+  return new Ye((t) => t, !1, e);
+}
+function gt(e, t) {
+  return Object.fromEntries(e.map((s) => [s, t]));
+}
+class Xe extends at {
+  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 A(
+      "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 Ze().of(p()).parse(
+      await A(
+        "getStorageKeys",
+        {},
+        this.createRequestId(),
+        { ...t, postEvent: this.postEvent }
+      )
+    );
+  }
+  async get(t, s = {}) {
+    const n = Array.isArray(t) ? t : [t];
+    if (!n.length)
+      return gt(n, "");
+    const r = await A(
+      "getStorageValues",
+      { keys: n },
+      this.createRequestId(),
+      { ...s, postEvent: this.postEvent }
+    ), i = f(gt(n, p()), "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 A(
+      "saveStorageValue",
+      { key: t, value: s },
+      this.createRequestId(),
+      { ...n, postEvent: this.postEvent }
+    );
+  }
+}
+const ts = l(
+  ({ createRequestId: e, postEvent: t, version: s }) => new Xe(s, e, t)
+);
+class es extends at {
+  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 ss = l(
+  ({ version: e, postEvent: t }) => new es(e, t)
+);
+class ns {
+  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 rs = l(
+  ({ initData: e }) => e ? new ns(e) : void 0
+);
+function Xs(e) {
+  return Ot().parse(e);
+}
+class is extends N {
+  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 os = l(
+  ({ version: e, postEvent: t }) => new is(!1, e, t)
+);
+class as extends nt {
+  constructor({ postEvent: t, ...s }) {
+    super(s), c(this, "postEvent"), c(this, "on", (n, r) => n === "click" ? b("main_button_pressed", r) : this.state.on(n, r)), c(this, "off", (n, r) => n === "click" ? j("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 cs = l("mainButton", ({
+  postEvent: e,
+  themeParams: t,
+  state: s = {
+    isVisible: !1,
+    isEnabled: !1,
+    text: "",
+    isLoaderVisible: !1,
+    textColor: t.buttonTextColor || "#ffffff",
+    backgroundColor: t.buttonColor || "#000000"
+  }
+}) => new as({ ...s, postEvent: e }));
+function hs() {
+  return it({
+    contact: f({
+      userId: {
+        type: E(),
+        from: "user_id"
+      },
+      phoneNumber: {
+        type: p(),
+        from: "phone_number"
+      },
+      firstName: {
+        type: p(),
+        from: "first_name"
+      },
+      lastName: {
+        type: p().optional(),
+        from: "last_name"
+      }
+    }),
+    authDate: {
+      type: kt(),
+      from: "auth_date"
+    },
+    hash: p()
+  }, "RequestedContact");
+}
+function Ht(e, t) {
+  return (s) => {
+    const [n, r] = t[s];
+    return x(n, r, e);
+  };
+}
+function ps(e) {
+  return new Promise((t) => {
+    setTimeout(t, e);
+  });
+}
+class us extends N {
+  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 = Ht(n, {
+      "setHeaderColor.color": ["web_app_set_header_color", "color"]
+    });
+  }
+  /**
+   * Attempts to get requested contact.
+   * @param timeout - request timeout.
+   */
+  async getRequestedContact({
+    timeout: t = 1e4
+  } = {}) {
+    return hs().parse(
+      await A(
+        "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 At(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 Tt(async () => {
+      for (; Date.now() < s; ) {
+        try {
+          return await this.getRequestedContact();
+        } catch {
+        }
+        await ps(n), n += 50;
+      }
+      throw Rt(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", st(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 ds = l("miniApp", ({
+  themeParams: e,
+  botInline: t = !1,
+  state: s = {
+    bgColor: e.bgColor || "#ffffff",
+    headerColor: e.headerBgColor || "#000000"
+  },
+  ...n
+}) => new us({ ...n, ...s, botInline: t }));
+function ls(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 h = i.type || "default";
+        throw new Error(`Button text with type "${h}" 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 _s extends N {
+  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: ls(t)
+      });
+      return s;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const gs = l(
+  ({ postEvent: e, version: t }) => new _s(!1, t, e)
+);
+class fs extends N {
+  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 = l(
+  ({ version: e, postEvent: t }) => new fs(!1, e, t)
+);
+class ws extends rt {
+  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" ? b("settings_button_pressed", i) : this.state.on(r, i)), c(this, "off", (r, i) => r === "click" ? j("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 bs = l("settingsButton", ({
+  version: e,
+  postEvent: t,
+  state: s = { isVisible: !1 }
+}) => new ws(s.isVisible, e, t));
+function Wt(e) {
+  return qt().parse(e);
+}
+class vs extends ot {
+  /**
+   * @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 || At(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 b("theme_changed", (t) => {
+      this.set(Wt(t.theme_params));
+    });
+  }
+  /**
+   * @since v6.10
+   */
+  get subtitleTextColor() {
+    return this.get("subtitleTextColor");
+  }
+  get textColor() {
+    return this.get("textColor");
+  }
+}
+const ys = l("themeParams", ({ themeParams: e, state: t = e }) => {
+  const s = new vs(t);
+  return S() || s.listen(), s;
+});
+function tn(e = {}) {
+  return m({
+    ...e,
+    method: "web_app_request_theme",
+    event: "theme_changed"
+  }).then(Wt);
+}
+class Es extends at {
+  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 = Ht(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 (!x("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 (!x("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: Ct(t)
+    });
+    return s;
+  }
+}
+const Ps = l(
+  ({ version: e, postEvent: t, createRequestId: s }) => new Es(e, s, t)
+);
+async function jt(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 T(e) {
+  return e < 0 ? 0 : e;
+}
+class Gt extends ot {
+  constructor({ postEvent: t, stableHeight: s, height: n, width: r, isExpanded: i }) {
+    super({
+      height: T(n),
+      isExpanded: i,
+      stableHeight: T(s),
+      width: T(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 jt(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 b("viewport_changed", (t) => {
+      const {
+        height: s,
+        width: n,
+        is_expanded: r,
+        is_state_stable: i
+      } = t, o = T(s);
+      this.set({
+        height: o,
+        isExpanded: r,
+        width: T(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 jt({ ...t, postEvent: e });
+  return new Gt({
+    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 Gt({
+    postEvent: s,
+    height: r,
+    width: i,
+    stableHeight: o,
+    isExpanded: n
+  });
+}
+const Cs = l(
+  "viewport",
+  async (e) => {
+    if (S() && !e.state)
+      throw d(
+        tt,
+        "Viewport cannot be instantiated on the server side without passing the ssr.state object."
+      );
+    let t = Ss(e);
+    return S() || (t.width === 0 && await xs(e.postEvent, { timeout: 1e3 }).then((s) => t = s).catch((s) => $.error("Unable to sync viewport state", s)), t.listen()), t;
+  }
+);
+function y(e, t) {
+  document.documentElement.style.setProperty(e, t);
+}
+function en(e, t, s) {
+  s || (s = (a) => `--tg-${a}-color`);
+  const n = s("header"), r = s("bg"), i = () => {
+    const { headerColor: a } = e;
+    if (st(a))
+      y(n, a);
+    else {
+      const { bgColor: h, secondaryBgColor: u } = t;
+      a === "bg_color" && h ? y(n, h) : a === "secondary_bg_color" && u && y(n, u);
+    }
+    y(r, e.bgColor);
+  }, o = [
+    t.on("change", i),
+    e.on("change", i)
+  ];
+  return i(), () => o.forEach((a) => a());
+}
+function sn(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 && y(t(n), r);
+    });
+  };
+  return s(), e.on("change", s);
+}
+function nn(e, t) {
+  t || (t = (u) => `--tg-viewport-${u}`);
+  const [
+    s,
+    n,
+    r
+  ] = ["height", "width", "stable-height"].map((u) => t(u)), i = () => y(s, `${e.height}px`), o = () => y(n, `${e.width}px`), a = () => y(r, `${e.stableHeight}px`), h = [
+    e.on("change:height", i),
+    e.on("change:width", o),
+    e.on("change:stableHeight", a)
+  ];
+  return i(), o(), a(), () => h.forEach((u) => u());
+}
+function Rs(e = !0) {
+  const t = [
+    b("reload_iframe", () => {
+      k("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(
+      b("set_custom_style", (r) => {
+        n.innerHTML = r;
+      }),
+      () => document.head.removeChild(n)
+    );
+  }
+  return k("iframe_ready", { reload_supported: !0 }), s;
+}
+async function rn() {
+  try {
+    return await m({ method: "web_app_request_theme", event: "theme_changed", timeout: 100 }), !0;
+  } catch {
+    return !1;
+  }
+}
+function Ts(e) {
+  return e instanceof U;
+}
+function on(e, t) {
+  return Ts(e) && e.type === t;
+}
+function z(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 As {
+  constructor(t, s, n = k) {
+    if (c(this, "history"), c(this, "ee", new L()), 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 d(de, "History should not be empty.");
+    if (s < 0 || s >= t.length)
+      throw d(
+        le,
+        "Index should not be zero and higher or equal than history size."
+      );
+    this.history = t.map((r) => z(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(), b("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, j("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, z(t, this.current.pathname));
+  }
+  /**
+   * Replaces the current history item.
+   * @param item - item to replace the current item with.
+   */
+  replace(t) {
+    this.replaceAndMove(this.index, z(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 K({
+  params: e,
+  ...t
+}) {
+  return { ...e || { hash: "", search: "" }, ...t };
+}
+function O(e, t) {
+  return e.startsWith(t) ? e : `${t}${e}`;
+}
+function M(e) {
+  return new URL(
+    typeof e == "string" ? e : `${e.pathname || ""}${O(e.search || "", "?")}${O(e.hash || "", "#")}`,
+    "http://a"
+  );
+}
+function B(e) {
+  const t = typeof e == "string" ? e.startsWith("/") : !!(e.pathname && e.pathname.startsWith("/")), s = M(e);
+  return `${t ? s.pathname : s.pathname.slice(1)}${s.search}${s.hash}`;
+}
+function J(e, t, s) {
+  let n, r;
+  typeof e == "string" ? n = e : (n = B(e), s = e.state, r = e.id);
+  const { pathname: i, search: o, hash: a } = new URL(n, `http://a${O(t, "/")}`);
+  return { id: r, pathname: i, params: { hash: a, search: o, state: s } };
+}
+async function I(e) {
+  return e === 0 ? !0 : Promise.race([
+    new Promise((t) => {
+      const s = Z("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 I(1 - window.history.length)))
+    return;
+  let e = await I(-1);
+  for (; e; )
+    e = await I(-1);
+}
+function zt(e) {
+  return M(e).pathname;
+}
+const ft = 0, Q = 1, F = 2;
+class Kt {
+  constructor(t, s, { postEvent: n, hashMode: r, base: i } = {}) {
+    c(this, "navigator"), c(this, "ee", new L()), 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 === ft ? window.history.forward() : o === Q && this.back(), o === F && this.forward();
+    }), c(this, "onNavigatorChange", async ({
+      to: o,
+      from: a,
+      delta: h
+    }) => {
+      this.attached && await this.syncHistory(), this.ee.emit("change", {
+        delta: h,
+        from: K(a),
+        to: K(o),
+        navigator: this
+      });
+    }), c(this, "on", this.ee.on.bind(this.ee)), c(this, "off", this.ee.off.bind(this.ee)), this.navigator = new As(
+      t.map((o) => J(o, "/")),
+      s,
+      n
+    ), this.navigator.on("change", this.onNavigatorChange), this.hashMode = r, this.base = zt(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(K);
+  }
+  /**
+   * 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 B(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 = M(t);
+    return this.hashMode && (s = M(s.hash.slice(1))), {
+      pathname: s.pathname,
+      search: s.search,
+      hash: s.hash
+    };
+  }
+  push(t, s) {
+    const n = J(t, this.path), { state: r = s } = n.params;
+    this.navigator.push({ ...n, params: { ...n.params, state: r } });
+  }
+  replace(t, s) {
+    const n = J(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) + O(B(t), "/");
+    return this.hashMode ? O(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(Q, ""), window.history.pushState(t, "", s), window.history.pushState(F, ""), await I(-1)) : this.hasPrev ? (window.history.replaceState(Q, ""), window.history.pushState(t, "", s)) : this.hasNext ? (window.history.replaceState(t, s), window.history.pushState(F, ""), await I(-1)) : (window.history.replaceState(ft, ""), 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 ks(e) {
+  e || (e = {});
+  const { href: t, hash: s } = window.location;
+  let n = B(
+    e.hashMode ? s.includes("?") ? s.slice(1) : `?${s.slice(1)}` : t
+  );
+  const r = e.base ? zt(e.base) : void 0;
+  if (r) {
+    if (!n.startsWith(r))
+      throw d(
+        ge,
+        `Path "${n}" expected to be starting with "${r}"`
+      );
+    n = n.slice(r.length);
+  }
+  return new Kt([n], 0, e);
+}
+function an(e) {
+  const t = e.match(/#(.+)/);
+  return t ? t[1] : null;
+}
+function Os(e, t) {
+  if (Lt()) {
+    const s = sessionStorage.getItem(e);
+    if (s)
+      try {
+        const { index: n, history: r } = JSON.parse(s);
+        return new Kt(r, n, t);
+      } catch (n) {
+        console.error("Unable to restore hash navigator state.", n);
+      }
+  }
+  return ks(t);
+}
+function cn(e, t) {
+  const s = Os(e, t), n = () => sessionStorage.setItem(e, JSON.stringify({
+    index: s.index,
+    history: s.history
+  }));
+  return s.on("change", n), n(), s;
+}
+function _(e) {
+  return (t, s, ...n) => (r) => mt(s, ht(() => ht({
+    [t]: e(...n)
+  }, r)));
+}
+const Jt = Qt();
+function qs() {
+  const e = Ft(Jt);
+  if (!e)
+    throw new Error("useSDK was used outside of SDKProvider.");
+  return e;
+}
+function g(e) {
+  return (...t) => qs()(e, ...t);
+}
+const Ns = g(Ge), hn = _(Ns), Ds = g(Ke), pn = _(Ds), Vs = g(Qe), un = _(Vs), Ms = g(ts), dn = _(Ms), Bs = g(ss), ln = _(Bs), $s = g(rs), _n = _($s), Ls = g(os), gn = _(Ls), Us = g(cs), fn = _(Us), Hs = g(ds), mn = _(Hs), Ws = g(gs), wn = _(Ws), js = g(ms), bn = _(js), Gs = g(bs), vn = _(Gs), zs = g(ys), yn = _(zs), Ks = g(Ps), En = _(Ks), Js = g(Cs), Pn = _(Js), xn = (e) => {
+  const t = /* @__PURE__ */ new Map(), s = (n, ...r) => {
+    if (t.has(n))
+      return t.get(n);
+    const [i] = Zt(() => {
+      try {
+        return n(...r);
+      } catch (h) {
+        return [h];
+      }
+    }), o = ut(() => {
+      if (i.error)
+        return [i.error];
+      if (i.state !== "ready")
+        return;
+      const h = i();
+      if (Array.isArray(h) || !h || !("on" in h))
+        return h;
+      const u = Xt((V) => (V(h), h.on("change", () => V(h)))), D = Object.getPrototypeOf(h), G = {};
+      return new Proxy(h, {
+        get(V, P) {
+          if (!(P in G)) {
+            const ct = Reflect.getOwnPropertyDescriptor(D, P);
+            G[P] = ct && "get" in ct ? ut(() => u()[P]) : () => Reflect.get(V, P);
+          }
+          return G[P]();
+        }
+      });
+    });
+    function a() {
+      const h = o();
+      if (Array.isArray(h))
+        throw h[0];
+      return h;
+    }
+    return Object.defineProperty(a, "error", {
+      get() {
+        const h = o();
+        return Array.isArray(h) ? h[0] : void 0;
+      }
+    }), t.set(n, a), a;
+  };
+  return pt(() => {
+    re(e.debug || !1);
+  }), pt(() => {
+    xt() && Yt(Rs(e.acceptCustomStyles));
+  }), mt(Jt.Provider, {
+    value: s,
+    get children() {
+      return e.children;
+    }
+  });
+};
+export {
+  Oe as BackButton,
+  As as BasicNavigator,
+  _t as BiometryManager,
+  Kt as BrowserNavigator,
+  Je as ClosingBehavior,
+  Xe as CloudStorage,
+  ge as ERR_INVALID_PATH_BASE,
+  he as ERR_INVOKE_CUSTOM_METHOD_RESPONSE,
+  ae as ERR_METHOD_PARAMETER_UNSUPPORTED,
+  oe as ERR_METHOD_UNSUPPORTED,
+  de as ERR_NAVIGATION_HISTORY_EMPTY,
+  le as ERR_NAVIGATION_INDEX_INVALID,
+  Fs as ERR_NAVIGATION_ITEM_INVALID,
+  vt as ERR_PARSE,
+  tt as ERR_SSR_INIT,
+  _e as ERR_SSR_POST_EVENT,
+  pe as ERR_TIMED_OUT,
+  ue as ERR_UNEXPECTED_TYPE,
+  ce as ERR_UNKNOWN_ENV,
+  L as EventEmitter,
+  es as HapticFeedback,
+  ns as InitData,
+  is as Invoice,
+  as as MainButton,
+  us as MiniApp,
+  _s as Popup,
+  fs as QRScanner,
+  U as SDKError,
+  xn as SDKProvider,
+  ws as SettingsButton,
+  vs as ThemeParams,
+  Es as Utils,
+  Gt as Viewport,
+  Ze as array,
+  en as bindMiniAppCSSVars,
+  sn as bindThemeParamsCSSVars,
+  nn as bindViewportCSSVars,
+  v as boolean,
+  Ct as captureSameReq,
+  X as classNames,
+  Ce as compareVersions,
+  ks as createBrowserNavigatorFromLocation,
+  Ie as createPostEvent,
+  M as createSafeURL,
+  kt as date,
+  an as getHash,
+  zt as getPathname,
+  Ge as initBackButton,
+  Ke as initBiometryManager,
+  Qe as initClosingBehavior,
+  ts as initCloudStorage,
+  ss as initHapticFeedback,
+  rs as initInitData,
+  os as initInvoice,
+  cs as initMainButton,
+  ds as initMiniApp,
+  cn as initNavigator,
+  gs as initPopup,
+  ms as initQRScanner,
+  bs as initSettingsButton,
+  ys as initThemeParams,
+  Ps as initUtils,
+  Cs as initViewport,
+  Rs as initWeb,
+  A as invokeCustomMethod,
+  At as isColorDark,
+  xt as isIframe,
+  Lt as isPageReload,
+  st as isRGB,
+  fe as isRGBShort,
+  Ts as isSDKError,
+  on as isSDKErrorOfType,
+  rn as isTMA,
+  f as json,
+  Zs as mergeClassNames,
+  E as number,
+  j as off,
+  b as on,
+  Xs as parseInitData,
+  Nt as parseLaunchParams,
+  Wt as parseThemeParams,
+  k as postEvent,
+  m as request,
+  ze as requestBiometryInfo,
+  tn as requestThemeParams,
+  jt as requestViewport,
+  He as retrieveLaunchParams,
+  Pt as rgb,
+  it as searchParams,
+  Le as serializeLaunchParams,
+  $e as serializeThemeParams,
+  y as setCSSVar,
+  re as setDebug,
+  Ys as setTargetOrigin,
+  p as string,
+  se as subscribe,
+  x as supports,
+  Ae as targetOrigin,
+  Et as toRGB,
+  bt as unsubscribe,
+  B as urlToPath,
+  Ns as useBackButton,
+  Ds as useBiometryManager,
+  Vs as useClosingBehavior,
+  Ms as useCloudStorage,
+  Bs as useHapticFeedback,
+  $s as useInitData,
+  Ls as useInvoice,
+  Us as useMainButton,
+  Hs as useMiniApp,
+  Ws as usePopup,
+  js as useQRScanner,
+  qs as useSDK,
+  Gs as useSettingsButton,
+  zs as useThemeParams,
+  Ks as useUtils,
+  Js as useViewport,
+  hn as withBackButton,
+  pn as withBiometryManager,
+  un as withClosingBehavior,
+  dn as withCloudStorage,
+  ln as withHapticFeedback,
+  _n as withInitData,
+  gn as withInvoice,
+  fn as withMainButton,
+  mn as withMiniApp,
+  wn as withPopup,
+  bn as withQRScanner,
+  vn as withSettingsButton,
+  yn as withThemeParams,
+  Tt as withTimeout,
+  En as withUtils,
+  Pn as withViewport
+};
+//# sourceMappingURL=index.js.map